首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。值调用(call by value)表示方法接收的是调用者提供的值。而引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。“...调用”（call by）是一个标注的计算机科学术语，它用来描述各种程序设计语言中方法参数的传递方式（事实上，以前还有称（call by name），Algol程序设计语言是最古老的高级程序设计语言之一，它使用的就是这种参数传递方式。不过，对于今天，这种传递方式已经成为历史）。

    Java程序设计语言总是采用值调用。也就是说，方法得到的是所有参数值的一个拷贝，特别是，方法不能修改传递给它的任何参数变量的内容。

    例如，考虑下面的调用：

1. double percent = 10; 
2. harry.raiseSalary(percent); 

不必理睬这个方法的具体实现，在方法调用之后，percent的值还是10.

    下面再仔细地研究一下这种情况。假定一个方法试图将一个参数值增加至3倍：

1. public static void tripleValue(double x)    //doesn't work 
2. { 
3.     x = 3 * x; 
4. } 

    然后调用这个方法：

1. double percent = 10; 
2. tripleValue(percent); 

    可以看到，无论怎样，调用这个方法之后，percent的值还是10。下面看一下具体的执行过程：

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

    2）x被乘以3后等于30。但是percent仍然是10。

    3）这个方法结束之后，参数变量x不再使用。

    然而，方法参数共有两种类型：

• 基本数据类型（数字、布尔值）。
• 对象引用。

    读者已经看到，一个方法不可能修改一个基本数据类型的参数。而对象引用作为参数就不同了，可以很容易地利用下面这个方法实现将一个雇员的薪金提高两倍的操作：

1. public static void tripleSalary(Employee x)    // works 
2. { 
3.     x.raiseSalary(200); 
4. } 

当调用

1. harry = new Employee(...); 
2. tripleSalary(harry); 

时，具体的执行过程为：

    1）x被初始化为harry值的拷贝，这里是一个对象的引用。

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

    3）方法结束后，参数变量x不再使用。当然，对象变量harry继续引用那个薪金增至3倍的雇员对象。

    读者已经看到，实现一个改变对象参数状态的方法并不是一件难事。理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。

    很多程序设计语言（特别是，C++和Pascal）提供了两种参数传递的方式：值调用和引用调用。有些程序员（甚至本书的作者）认为Java程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种错误具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。

    首先，编写一个交换两个雇员对象的方法：

1. public static void swap(Employee x, Employee y) 
2. { 
3.     Employee temp = x; 
4.     x = y; 
5.     y = temp; 
6. } 

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

1. Employee a = new Employee("Alice", ...); 
2. Employee b = new Employee("Bob", ...); 
3. swap(a, b); 
4. // dose a now refer to Bob, b to Alice? 

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

1. // x refer to Alice, y to Bob 
2. Employee temp = x; 
3. x = y; 
4. y = temp; 
5. // now x refer Bob, y to Alice 

    最终，白费力气。在方法结束时参数变量x和y被丢弃了。原来的变量a和b仍然引用这个方法调用之前所引用的对象。

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

    下面总结一下在Java程序设计语言中，方法参数的使用情况：

• 一个方法不能修改一个基本数据类型的参数（即数值型和布尔型）。
• 一个方法可以改变一个对象参数的状态。
• 一个方法不能实现让对象参数引用一个新的对象。

    例4-4中的程序给出了相应的演示。在这个程序中，首先试图将一个值参数的值提高两倍，但是没有成功：

1. Testing tripleValue: 
2. Before: percent = 10.0 
3. End of method: x = 30.0
4. After: percent = 10.0 

    随后，成功地将一个雇员的薪金提高了两倍：

1. Testing tripleSalary: 
2. Before: salary = 50000.0 
3. End of method: salary = 150000.0 
4. After: salary = 150000.0 

    方法结束之后，harry引用的对象状态发生了改变。这是因为这个方法可以通过对象引用的拷贝修改所引用对象的状态。

    最后，程序演示了swap方法的失败效果：

1. Testing swap: 
2. Before: a = Alice 
3. Before: b = Bob 
4. End of method: x = Bob 
5. End of method: y = Alice 
6. After: a = Alice 
7. After: b = Bob 

    可以看出，参数变量x和y被交换了，但是变量a和b没有收到影响。

    C++注释：C++有值调用和引用调用。引用参数标有&符号。例如，可以轻松地实现void tripleValue（double& x）方法或void swap(Employee& x, Employee& y)方法实现修改它们的引用参数的目的。

1. /** 
2.  * This program demonstrates parameter passing in Java 
3.  * @version 1.01 2012-11-13 
4.  * @author Wucg 
5.  */ 
6. public class ParamTest 
7. { 
8.     public static void main(String[] args) 
9.     { 
10.         /* 
11.          * Test1: Methods can't modify numeric parameters 
12.          */ 
13.         System.out.println("Testing tripleValue:"); 
14.         double percent = 10; 
15.         System.out.println("Before: percent = " + percent); 
16.         tripleValue(percent); 
17.         System.out.println("After: percent = " + percent); 
18.  
19.         /* 
20.          * Test2: Methods can change the state of object parameters 
21.          */ 
22.         System.out.println("\nTesting tripleSalary:"); 
23.         Employee harry = new Employee("Harry", 70000); 
24.         System.out.println("Before: salary = " + harry.getSalary()); 
25.         tripleSalary(harry); 
26.         System.out.println("After: salary = " + harry.getSalary()); 
27.  
28.         /* 
29.          * Test3: Methods can't attach new objects to object parameters 
30.          */ 
31.         System.out.println("\nTesting swap:"); 
32.         Employee a = new Employee("Alice", 70000); 
33.         Employee b = new Employee("Bob", 60000); 
34.         System.out.println("Before: a = " + a.getName()); 
35.         System.out.println("Before: b = " + b.getName()); 
36.         swap(a, b); 
37.         System.out.println("After: a = " + a.getName()); 
38.         System.out.println("After: b = " + b.getName()); 
39.     } 
40.  
41.     public static void tripleValue(double x)    // doesn't work 
42.     { 
43.         x = 3 * x; 
44.         System.out.println("End of method: x = " + x); 
45.     } 
46.  
47.     public static void tripleSalary(Employee x)    // works 
48.     { 
49.         x.raiseSalary(200); 
50.         System.out.println("End of method: salary = " + x.getSalary()); 
51.     } 
52.  
53.     public static void swap(Employee x, Employee y) 
54.     { 
55.         Employee temp = x; 
56.         x = y; 
57.         y = temp; 
58.         System.out.println("End of method: x = " + x.getName()); 
59.         System.out.println("End of method: y = " + y.getName()); 
60.     } 
61. } 
62.  
63. class Employee    // simplified Employee class 
64. { 
65.     public Employee(String n, double s) 
66.     { 
67.         name = n; 
68.         salary = s; 
69.     } 
70.  
71.     public String getName() 
72.     { 
73.         return name; 
74.     } 
75.  
76.     public double getSalary() 
77.     { 
78.         return salary; 
79.     } 
80.  
81.     public void raiseSalary(double byPercent) 
82.     { 
83.         double raise = salary * byPercent / 100; 
84.         salary = salary + raise; 
85.     } 
86.      
87.     private String name; 
88.     private double salary; 
89. }