深入 -- 方法的参数传递

方法参数传递有两种方式

按值调用：表示方法接收的是调用者提供的值。

按引用调用：表示方法接收的是调用者提供的变量地址。

Java程序设计语言总是采用按值调用。

也就是说，方法得到的是所有参数值的一个拷贝。

举个例子：

public static void main(String[] args) {
	TestMethod testMethod = new TestMethod();
	int a = 10;
	testMethod.change(a);
	//change方法调用之后，a还是10
	System.out.println("a : " + a);
}

private void change(int number) {
	System.out.println("1 change : " + number);
	number += 100;
	System.out.println("2 change :" + number);
}

输出结果：

可以看到，无论怎样，调用这个方法之后，a依旧是10

分析下代码：

        a. a被初始化为10.

        b. 调用change(int number)方法，number被初始化为a值得一个拷贝(也就是10).

        c. number被操作之后等于110.但a依旧是10.

        d. 方法结束之后，参数变量number不再使用。

从以上分析看出：对方法 参数的修改并没有保留下来。

不过，方法参数共有两种类型：

    1. 基本数据类型(八种基本类型)

    2. 对象引用

通过上面的分析看到，一个方法不可能修改一个基本数据类型的参数。

但是对象引用作为参数就不同了，可以很轻易的修改它。

举个例子：

public static void main(String[] args) {

	TestMethod02 testMethod02 = new TestMethod02();

	Person person = new Person();
	person.setName("CYX");
	person.setAge(20);

	System.out.println("person1 : "+person.toString());

	//调用方法、修改对象中的值
	testMethod02.change(person);

	//调用方法之后发现，person中的参数改变了
	System.out.println("person2 : "+person.toString());

}

//修改person中的变量
private void change(Person p) {
	int age = p.getAge() * 10;
	p.setAge(age);
}

输出结果：

分析下代码：

a. 初始化person类对象，然后调用chage方法

b. p被初始化为person值的拷贝，这是一个对象的引用。

c. p.getAge() * 10; 操作，应用于这个对象的引用。p和person同时引用Person对象。

d. 方法结束之后，参数变量p不再使用。但 对象变量person依旧引用那个年龄改变了10倍的对象

通过上分析看出，方法得到的是对象引用的拷贝，对象引用  及  其他的拷贝  同时引用同一个对象。

很多程序语言(C++、Pascal)提供了两种参数传递的方式，值传递 和 引用传递。

那Java也是采用两种方式嘛？别着急，往下看….

再看一个例子，通过这个反例来看下：

public static void main(String[] args) {

	TestMethod03 testMethod03 = new TestMethod03();

	Employee a = new Employee("CYX", 10);
	Employee b = new Employee("ZZZ", 11);

	System.out.println("a1 : " + a);
	System.out.println("b1 : " + b);
	System.out.println();

	testMethod03.swap(a, b);

	System.out.println("a2 : " + a);
	System.out.println("b2 : " + b);
	System.out.println();
}

//交换两个对象
public void swap(Employee x, Employee y) {
	System.out.println("x1 : " + x);
	System.out.println("x1 : " + y);
	System.out.println();
	Employee temp = x;
	x = y;
	y = temp;
	System.out.println("x2 : " + x);
	System.out.println("x2 : " + y);
	System.out.println();
}

输出结果：

如果Java语言对 对象采用的是引用传递，那么这个方法能够实现交换数据的效果。

不过，从打印的数据来看，最后输出的a、b内容并没有改变。

我们来分析下代码：

a. 首先创建a、b两个对象。

b. 进入方法，将a赋值给x、b赋值给y，此时(a=x,b=y)

c. 对象开始交换：

a. x 赋值给 temp   (a=x=temp)

b. y 赋值给 x   (x = y = b)

c. temp 赋值给 y   (y = temp = a)

d. 这时候：x 和 y 原本的指向都改变了(x-b、y-a)。

i. 方法结束之后，x、y不再使用。

j. 回到上层，a、b的指向改变了嘛？ 没有改变。

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

小结一下：

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

一个方法可以改变一个对象参数的状态(对象内字段数据)。

一个方法不能让对象参数引用一个新的对象。