JAVA基础--方法传参

为啥拿这个当话题？

在初学者阶段，许多童鞋都对方法传参比较迷茫，知其然不知其所以然。

一.先说说参数传递的几个术语：

值调用(call by vale):表示方法接收的是调用者传递的值。

引用调用(call by reference):表示方法接收的是调用者传递的变量地址。

一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值；

**JAVA语言总是采用值调用。

也就是说，JAVA方法得到的是所有参数值的一个拷贝，方法不能修改传递给他的任何参数变量的内容。

例如：

int age=100;

person.setAge(age);

在以上方法调用后，age 的值还是100；

下面再看一例子，假如某方法将一个变更值修改为原来的值的3倍：

public void addValue(int x){

x = 3 * x;

}

然后调用这个方法：

int percent = 10;

addValue(percnet);

无论如何调用，percent的值还是10，下面是执行过程：

1.x被初始化为percent值的一个拷贝（也就是10）；

2.x被乘以3后，值变为30。但是percent仍然是10；

3.该方法结束后，参数变量x不再使用。

如图一：



二.java方法传参类型:

 

基本数据类型:(数字,布尔型)

对象引用类型:

基本数据类型传参在上例中已经说过了,是不能修改基本数据类型参数的值的.

那么对于对象引用类型的传参,能否修改呢?

先来看例子:

有如下方法:

public static void tripleSalary(Employee x)

 

{

   x.raiseSalary(200);

}

当调用如下代码

harry = new Employee();

tripleSalary(harry);

时,具体的执行过程如下:

1).x被初始化为harry对象的拷贝,这里是一个对象的引用;

2).raiseSalary方法应用于这个对象引用.即x和harry同时引用的Employee对象薪金提高了200%.

3).方法调用结束后,参数变量x不再使用.但对象变量harry继续引用那个薪金增至3倍Employee对象.

其过程如下图:



通过以上实例,可以看出对象参数传递的是对象引用的拷贝,对象引用及其他的拷贝同时引用同一个对象.

 

很多程序语言提供两种传递方式:值传递和引用传递(C++和Pascal).

有些程序员认为java语言对对象参数传递也是用的引用调用.实际上是理解错误.这种错误具有一定的普遍性.下面通过一反例来说明该问题:

首先,编写一个交换两个Employee对象的方法:

public staitc void swap(Employee x,Emplyee y)

{

    Employee temp = x;

    x = y;

    y = temp;

}

如果JAVA程序语言是对对象采用引用调用，那么这个方法就应该能够实现交换数据的效果：

    Employee a = new Employee("Alice",...);

    Employee b = new Employee("Bob",...);

    swap(a,b);

但是，方法并没有改变存储在变量a和b中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝。

在方法结束时，参数变量x和y被丢弃了。原来的变量a和b仍然引用这个方法调用之前所引用的对象如下图：



这个过程说明：java语言对对象采用的不是引用调用，实际上对象引用进行的是值传递。

 

最后总结一下在JAVA中，方法参数的使用情况：

*一个方法不能修改一个基本数据类型的参数；

*一个方法可以改变一个对象参数的状态（属性）；

*一个方法不能实现让对象参数引用一个新对象；

Java方法传参：
在java中方法的参数传递为值传递。
给方法传值，其实是就是将实参数值的副本（内存中实参的一份复制）传入方法内，而参数本身不受到影响。
简单数据类型和复合数据类型都传递一份实参栈值的副本。
下面我们来看一个例子：
public class Demo
{
	//更改这两个变量的值
	public static void change(int i,int j)
	{
		int t = i;
		i = j;
		j = t;
		System.out.println("改更后:i = "+ i +"\tj = "+j);
		
	}
	public static void change(Point p)
	{
		int t = p.x;
		p.x = p.y;
		p.y = t;
		System.out.println("交换后:x = "+ p.x + "\ty=" + p.y);
		
	}
	public static void main(String args[])
	{  
	    int a=10,b=20;
		Demo.change(a,b);//方法传参，传的是实参副本，不是实参本身
		System.out.println("a = " + a + "\tb = "+b);
		
		System.out.println("---------------------------------");
		
		Point p=new Point(60,80);
		p.info();
		change(p);
		p.info();  
	}
}
class Point
{
	int x;
	int y;
	public Point(int x,int y)
	{
		this.x = x;
		this.y = y;
	}
	
	public void info()
	{
		System.out.println("x = "+x+"\ty = "+y);
	}
	
}
运行结果截图：
从运行结果我们可以看出将a与b传给change方法后a与b的值并没有改变，但p中的x与y的值却改变了。
想知道为什么我们可以简单画一个该程序在JVM中的内存图解
我们知道基本数据类型直接在栈中开辟内存由上图可知，change交换了a1与b1的值但不会改变a与b的值；而对象（复杂）数据类型在堆中开辟内存因为p1是p的副本所以其指向堆中同一块内存，change方法对p1的操作改变了p1所指向内存中x与y的值所以p所指向内存中x与y的值也改变了。

方法中有无参方法和带参方法两种，
无参方法
            没有参数，可以有返回值也可以没有返回值。有返回值的要有返回值的类型（既数据类型）。
            没有返回值的用void修饰。
带参方法
            带参方法就是方法定义处带有参数，且定义了参数类型。

            参数
                  形式参数，也叫形参。 它主要用于约束参数的类型，在方法定义处中，形式参数的名字可以随便取，但是要符合驼                     峰命名规则。
                  实际参数，也叫实参。主要存在于方法调用处，名字也可以随便取，也要符合驼峰命名规则。
                  形参和实参的类型必须一致，名字可以一样也可以不一样。
方法传参
            方法传参时会传两种数据类型， 一种是基本数据类型，一种是引用数据类型。传基本数据类型传的是数据的值，最终的               运算结果不会改变它的值，传引用数据类型时传的是数据的地址。引用数据被改变它的值也相应被改变。（所以的数组               都是引用数据类型）
           
           如果调用这个方法的时候n=8，那么调用后n还是等于8，
           如果调用这个方法的时候student.age=18，那么调用后student.age等于19，

方法传参

class Bbq(object):

‘’‘这是实现烧烤类’’’

def init(self,level):

self.level=level#这是生熟程度

self.flavour=[]#这是调料

self.levelstring=‘生’

def kao(self,time):#类里面的方法传参

‘’‘这是实现烤的过程，时间由用户决定’’’

self.level += time

self.levelstring=’%d成熟’%self.level

if self.level >10:

self.levelstring=‘碳化’

def add(self,fla):#这是增加调料

self.flavour.append(fla)

def str(self):

return ‘生熟的程度是%s,调料是%s’%(self.levelstring,self.flavour)

#可以返回变量，变量的类型是字符串类型

#return ‘’ 这种返回空字符串也可以

#return 空格 这种不行，没有返回值

if name == ‘main’:

obj1 = Bbq(0)

print(obj1)
print('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$')

obj1.add('孜然')
print(obj1)
print('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$')
obj1.kao(10)
print(obj1)