最近重读Java核心技术，不得不说的是这本书确实不错。虽然本人不太喜欢做笔记，但还是觉得某些重要的地方必须要记一下。
 
 
关于方法参数调用一般有两种：值调用（call by value）和引用调用（call by reference）。顾名思义，值调用表示方法接收的是调用者提供的值；引用调用表示方法接收的是调用者提供的变量的地址。
 
 
特别重要的是：在Java中，程序设计总是采用值调用。即：方法得到的是所有参数值得一个拷贝，方法不能修改传递给它的任何参数变量的内容。
 
 

 
 
 
这里用一个例子来说明，如下代码：
 
 
 
 
public class TestMP {

	public static void main(String[] args) {
		System.out.println("=== 测试基本数据类型 ===");
		int a = 30;
		System.out.println("调用前 a=" + a);
		tripValue(a);
		System.out.println("调用后 a=" + a);
		System.out.println();

		System.out.println("=== 测试对象引用参数 ===");
		Book ba = new Book("Java核心技术", 30);
		Book bb = new Book("算法技术手册", 20);
		System.out.println("调用前");
		System.out.println(ba);
		System.out.println(bb);
		System.out.println();
		System.out.println("对象引用类型参数调用可以改变对象内容");
		adjustPrice(ba);
		System.out.println(ba);
		System.out.println();
		System.out.println("对象引用类型参数调用不能改变参数引用值");
		swapBook(ba, bb);
		System.out.println(ba);
		System.out.println(bb);

	}

	static void tripValue(int data) { // doesn't work
		data = data * 3;
	}

	static void adjustPrice(Book aBook) {
		aBook.setPrice(100.0);
	}

	static void swapBook(Book x, Book y) { // doesn't work
		Book temp = x;
		x = y;
		y = temp;
	}

}

class Book {

	private String name;
	private double price;

	public Book(String name, double price) {
		this.name = name;
		this.price = price;
	}

	public void setPrice(double p) {
		this.price = p;
	}

	//
	@Override
	public String toString() {
		return "[name=" + this.name + ", price=" + this.price + "]";
	}
}
 
 
这段程序输出如下：
 === 测试基本数据类型 ===
 
 调用前 a=30
 
 调用后 a=30
 
 
 
 === 测试对象引用参数 ===
 
 调用前
 
 [name=Java核心技术, price=30.0]
 
 [name=算法技术手册, price=20.0]
 
 
 
 对象引用类型参数调用可以改变对象内容
 
 [name=Java核心技术, price=100.0]
 
 
 
 对象引用类型参数调用不能改变参数引用值
 
 [name=Java核心技术, price=100.0]
 
 [name=算法技术手册, price=20.0]
 
 
 
总结一下：
 
 
 
 
Java程序设计中对象采用的不是引用调用，实际上，对象引用进行的是值传递。
一个方法不能修改一个基本数据类型的参数；
一个方法可以改变一个对象参数的状态；
一个方法不能实现让一个对象参数引用一个新的对象。
 
 
 

一、概念
 
              按值调用：表示方法接收的时调用者提供的值
 
              按引用调用：表示方法接收的时调用者提供的变量地址
 
          在Java中总是采用按值调用，方法得到的参数值是一个拷贝。
 
二、实例演示
 
        (1) 在 Java 中，八种基本数据类型和String类型，在方法中不能直接对类中使用该类型声明的变量进行修改。
 
         例如：
 
        
 
public class MainTest {
	public static void main(String[] args) {
		int a = 5;
		test(a);
		System.out.println(a);
	}
	public static void test(int a) {
		a++;
	}
}
 
       运行结果：5
 
       解释说明：在这里我们可以看出在方法中我们对a进行加1的运算，并没有起到作用，这是因为我们在进行传参的时候，对 a 变量进行了拷贝，修改它的拷贝的变量并不会影响到原先的 a ，所以我们输出的还是5.
 
 
   实际上我们只是对拷贝后的a进行了a++的操作，我们输出的任然是原先的a
 
  (2) 对于引用类型则可以通过方法对参数进行修改
 
   例如：
 
public class MainTest {
	public static void main(String[] args) {
		Employee em1 = new Employee();
		test(em1);
		System.out.println(em1.getName());
	}
	public static void test(Employee em) {
		em.setName("张三");
	}
}
 
   运行结果：张三
 
   解释说明：
 
 
对于引用类型，方法参数实际上只是拷贝的对象名称，实际上与em1指向的时同一个地址，所以当我们对em进行修改时，同时也会影响到em1。
 
 
 
 

方法参数的调用是值调用而不是引用调用
 
 

 
 

 
 

 
 
 
package com.ray.object;


/**
 * 方法参数的调用是值调用，而不是引用调用
 * 
 * @author ray
 * @since 2015-04-22
 * @version 1.0
 * 
 */
public class Person {

	private static void swap(Person a, Person b) {
		Person temp = a;
		a = b;
		System.out.println("a:" + a);
		b = temp;
		System.out.println("b:" + b);
	}

	public static void main(String[] args) throws Exception {
		Person bill = new Person();
		Person jack = new Person();
		System.out.println("--bill:" + bill);
		System.out.println("**jack:" + jack);
		Person.swap(bill, jack);
		System.out.println("--bill:" + bill);
		System.out.println("**jack:" + jack);
	}
}


 输出： 
 
--bill:com.ray.object.Person@1fb8ee3
 **jack:com.ray.object.Person@61de33
 a:com.ray.object.Person@61de33
 b:com.ray.object.Person@1fb8ee3
 --bill:com.ray.object.Person@1fb8ee3
 **jack:com.ray.object.Person@61de33
 
 

 
 
从上面的输出结果可以看见，在swap方法里面，两个参数的确是已经调换了，但是由于参数是对象，所有调用的时候是值调用，而不是引用调用，
 
只不过参数返回的值变动了，但是相应的对象还是没有变，因此，最后的结果两个对象是没有调换过来
 

 

我想，你只要看了C语言上关于传值函数调用的测试题，一切都会了然于胸：
 
考题一：程序代码如下： 
 void Exchg1(int x, int y) 
 { 
 int tmp; 
 tmp=x; 
 x=y; 
 y=tmp; 
 printf(“x=%d,y=%d/n”,x,y) 
 } 
 void main() 
 { 
 int a=4,b=6; 
 Exchg1 (a,b) ; 
 printf(“a=%d,b=%d/n”,a,b) 
 } 
 输出的结果： 
 x=_, y=_ 
 a=_, b=_ 
 问下划线的部分应是什么，请完成。
考题二：代码如下。 
 Exchg2(int *px, int *py) 
 { 
 int tmp=*px; 
 *px=*py; 
 *py=tmp; 
 print(“*px=%d,*py=%d/n”,*px,*py); 
 } 
 main() 
 { 
 int a=4; 
 int b=6; 
 Exchg2(&a,&b); 
 Print(“a=%d,b=%d/n”, a, b); 
 } 
 输出的结果为： 
 *px=_, *py=_ 
 a=_, b=_ 
 问下划线的部分应是什么，请完成。
考题三： 
 Exchg2(int &x, int &y) 
 { 
 int tmp=x; 
 x=y; 
 y=tmp; 
 print(“x=%d,y=%d/n”,x,y); 
 } 
 main() 
 { 
 int a=4; 
 int b=6; 
 Exchg2(a,b); 
 Print(“a=%d,b=%d/n”, a, b); 
 }
 
二． 函数参数传递方式之一：值传递
 
1． 值传递的一个错误认识 
 先看题一中Exchg1函数的定义： 
 void Exchg1(int x, int y) //定义中的x,y变量被称为Exchg1函数的形式参数 
 { 
 int tmp; 
 tmp=x; 
 x=y; 
 y=tmp; 
 printf(“x=%d,y=%d/n”,x,y) 
 } 
 问：你认为这个函数是在做什么呀？ 
 答：好像是对参数x,y的值对调吧？ 
 请往下看，我想利用这个函数来完成对a,b两个变量值的对调，程序如下： 
 void main() 
 { 
 int a=4,b=6; 
 Exchg1 (a,b) //a,b变量为Exchg1函数的实际参数。 
 / printf(“a=%d,b=%d/n”,a,b) 
 } 
 我问：Exchg1 ()里头的 printf(“x=%d,y=%d/n”,x,y)语句会输出什么啊？ 
 我再问：Exchg1 ()后的 printf(“a=%d,b=%d/n”,a,b)语句输出的是什么？ 
 程序输出的结果是： 
 x=6 , y=4 
 a=4 , b=6 //为什么不是a=6,b=4呢？
 
奇怪，明明我把a,b分别代入了x,y中，并在函数里完成了两个变量值的交换，为什么a,b变量值还是没有交换（仍然是a==4,b==6，而不是a==6,b==4）？如果你也会有这个疑问，那是因为你跟本就不知实参a,b与形参x,y的关系了。
 
2． 一个预备的常识 
 为了说明这个问题，我先给出一个代码： 
 int a=4; 
 int x; 
 x=a; 
 x=x+3; 
 看好了没，现在我问你：最终a值是多少，x值是多少? 
 （怎么搞的，给我这个小儿科的问题。还不简单，不就是a==4 x==7嘛！） 
 在这个代码中，你要明白一个东西：虽然a值赋给了x，但是a变量并不是x变量哦。我们对x任何的修改，都不会改变a变量。呵呵！虽然简单，并且一看就理所当然，不过可是一个很重要的认识喔。
 
3． 理解值传递的形式 
 看调用Exch1函数的代码：
 
main() 
 { 
 int a=4,b=6; 
 Exchg1(a,b) //这里调用了Exchg1函数 
 printf(“a=%d,b=%d”,a,b) 
 }
 
Exchg1(a,b)时所完成的操作代码如下所示。 
 int x=a;//← 
 int y=b;//←注意这里，头两行是调用函数时的隐含操作 
 int tmp; 
 tmp=x; 
 x=y; 
 y=tmp; 
 请注意在调用执行Exchg1函数的操作中我人为地加上了头两句： 
 int x=a; 
 int y=b; 
 这是调用函数时的两个隐含动作。它确实存在，现在我只不过把它显式地写了出来而已。问题一下就清晰起来啦。（看到这里，现在你认为函数里面交换操作的是a,b变量或者只是x,y变量呢？） 
 原来 ，其实函数在调用时是隐含地把实参a,b 的值分别赋值给了x,y，之后在你写的Exchg1函数体内再也没有对a,b进行任何的操作了。交换的只是x,y变量。并不是a,b。当然a,b的值没有改变啦！函数只是把a,b的值通过赋值传递给了x,y，函数里头操作的只是x,y的值并不是a,b的值。这就是所谓的参数的值传递了。 
 哈哈，终于明白了，正是因为它隐含了那两个的赋值操作，才让我们产生了前述的迷惑（以为a,b已经代替了x,y，对x,y的操作就是对a,b的操作了，这是一个错误的观点啊！）。
 
三． 函数参数传递方式之二：地址传递 
 继续——地址传递的问题！ 
 看题二的代码： 
 Exchg2(int *px, int *py) 
 { 
 int tmp=*px; 
 *px=*py; 
 *py=tmp; 
 print(“*px=%d,*py=%d/n”,*px,*py); 
 } 
 main() 
 { 
 int a=4; 
 int b=6; 
 Exchg2(&a,&b); 
 Print(“a=%d,b=%d/n”, a, b); 
 } 
 它的输出结果是： 
 *px=6,*py=4 
 a=6,b=4
 
看函数的接口部分：Exchg2(int *px,int *py)，请注意：参数px,py都是指针。
再看调用处：Exchg2(&a, &b);
它将a的地址（&a）代入到px，b的地址(&b)代入到py。同上面的值传递一样，函数调用时作了两个隐含的操作：将&a，&b的值赋值给了px,py。
 
px=&a; 
 py=&b; 
 呵呵！我们发现，其实它与值传递并没有什么不同，只不过这里是将a,b的地址值传递给了px,py，而不是传递的a,b的内容，而（请好好地在比较比较啦） 
 整个Exchg2函数调用是如下执行的： 
 px=&a; // 
 py=&b; //请注意这两行，它是调用Exchg2的隐含动作。 
 int tmp=*px; 
 *px=*py; 
 *py=tmp; 
 print(“*px=%d,*py=%d/n”,*px,*py); 
 这样，有了头两行的隐含赋值操作。我们现在已经可以看出，指针px,py的值已经分别是a,b变量的地址值了。接下来，对*px，*py的操作当然也就是对a,b变量本身的操作了。所以函数里头的交换就是对a,b值的交换了，这就是所谓的地址传递（传递a,b的地址给了px,py），你现在明白了吗？
 
四． 函数参数传递方式之三：引用传递 
 看题三的代码： 
 Exchg3(int &x, int &y) //注意定义处的形式参数的格式与值传递不同 
 { 
 int tmp=x; 
 x=y; 
 y=tmp; 
 print(“x=%d,y=%d/n”,x,y); 
 } 
 main() 
 { 
 int a=4; 
 int b=6; 
 Exchg3(a,b); //注意：这里调用方式与值传递一样 
 Print(“a=%d,b=%d/n”, a, b); 
 } 
 输出结果： 
 x=6, y=4 
 a=6, b=4 //这个输出结果与值传递不同。 
 看到没有，与值传递相比，代码格式上只有一处是不同的，即在定义处： 
 Exchg3(int &x, int &y)。 
 但是我们发现a与b的值发生了对调。这说明了Exchg3(a,b)里头修改的是a,b变量，而不只是修改x,y了。 
 我们先看Exchg3函数的定义处Exchg3(int &x,int &y)。参数x,y是int的变量，调用时我们可以像值传递(如： Exchg1(a,b); )一样调用函数(如： Exchg3(a,b); )。但是x,y前都有一个取地址符号&。有了这个，调用Exchg3时函数会将a,b 分别代替了x,y了，我们称x,y分别引用了a,b变量。这样函数里头操作的其实就是实参a,b本身了，也就是说函数里是可以直接修改到a,b的值了。
 
最后对值传递与引用传递作一个比较：
 
1． 在函数定义格式上有不同： 
 值传递在定义处是：Exchg1(int x, int y); 
 引用传递在这义处是：Exchg1(int &x, int &y);
 
2． 调用时有相同的格式： 
 值传递：Exchg1(a,b); 
 引用传递：Exchg3(a,b);
 
3． 功能上是不同的： 
 值传递的函数里操作的不是a,b变量本身，只是将a,b值赋给了x,y函数里操作的只是x,y变量而不是a,b，显示a,b的值不会被Exchg1函数所修改。 
 引用传递Exchg3(a,b)函数里是用a,b分别代替了x,y。函数里操作的是a,b。
 
转自：http://blog.csdn.net/xiaosong2008/article/details/25430261