Java学习day020 方法参数

使用的教材是java核心技术卷1，我将跟着这本书的章节同时配合视频资源来进行学习基础java知识。

day020  方法参数

了解一些在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。

按值调用（call by value)表示方法接收的是调用者提供的值。而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。

---

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

例如，考虑下面的调用：

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

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

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

public static void tripleValue(double x)//doesn't work
	{
		x = 3 * x;
		System.out.println("End of method: x = "+x);
	}

然后调用这个方法：

double percent = 10;
tripleValue(percent);

不过，并没有做到这一点调用这个方法之后，percent的值还是10。

下面看一下具体的执行过程：

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

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

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

                                               

方法参数共有两种类型：

1.基本数据类型（数字、布尔值）。

2.对象引用

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

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

当调用

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

时，具体的执行过程为：

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

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

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

                        

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

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

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

public static void swap(Employee x,Employee y)//doesn't work
	{
		Employee temp = x;
		x = y;
		y = temp;
	}

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

Employee a = new Employee("Alice", . . .); 
Employee b = new Employee("Bob", . . .); 
swap(a, b); 
//does a now refer to Bob, b to Alice?

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

//x refers to Alice, y to Bob 
Employee temp = x; 
x =y; 
y=temp;
//now x refers to Bob, y to Alice

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

                     

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

下面总结一下Java中方法参数的使用情况：

1.一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）。

2.一个方法可以改变一个对象参数的状态。

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

---

下面给出一个程序的代码，将演示上面的这些情况成功与失败：

/*
 *@zzhao
 */

public class ParamTest
{
	public static void main(String[] args) 
	{
		/*
		 *Test 1:Methods can't modify numeric parameters
		 */
		System.out.println("Testing tripleValue:");
		double percent = 10;
		System.out.println("Before: percent = "+percent);
		tripleValue(percent);
		System.out.println("After: percent = "+percent);

		 /*
		  *Test 2:Methods can change the state of object parameters
		  */
		 System.out.println("\nTesting tripleSalary:");
		 Employee harry = new Employee("Herry",50000);
		 System.out.println("Before: salary = "+harry.getSalary());
		 tripleSalary(harry);
		 System.out.println("After: salary = "+harry.getSalary());

		 /*
		  *Test 3:Methods can't attach new objects to object parameters
		  */
		 System.out.println("\nTesting swap:");
		 Employee a = new Employee("Alice",70000);
		 Employee b = new Employee("Bob",60000);
		 System.out.println("Before: a = "+a.getName());
		 System.out.println("Before: b = "+b.getName());
		 swap(a,b);
		 System.out.println("After: a = "+a.getName());
		 System.out.println("After: b = "+b.getName());
		 
	}

	public static void tripleValue(double x)//doesn't work
	{
		x = 3 * x;
		System.out.println("End of method: x = "+x);
	}

	public static void tripleSalary(Employee x)//works
	{
		x.raiseSalary(200);
		System.out.println("End of method: salary = "+x.getSalary());
	}

	public static void swap(Employee x,Employee y)
	{
		Employee temp = x;
		x = y;
		y = temp;
		System.out.println("End of mathod: x = "+x.getName());
		System.out.println("End of mathod: y = "+y.getName());
	}
}

//simplified Employee class
class Employee
{
	private String name;
	private double salary;

	public Employee(String n,double s)
	{
		name = n;
		salary = s;
	}

	public String getName()
	{
		return name;
	}

	public double getSalary()
	{
		return salary;
	}

	public void raiseSalary(double byPercent)
	{
		double raise = salary * byPercent / 100;
		salary += raise;
	}
}

在这个程序中，首先试图将一个值参数的值提高两倍，但没有成功：

Testing tripleValue: 
Before: percent=10.0 
End of method: x=30.0 
After: percent=10.0

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

Testing tripleSalary: 
Before: salary=50000.0 
End of method: salary=150000.0 
After: salary=150000.0

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

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

Testing swap: 
Before: a=Alice 
Before: b=Bob 
End of method: x=Bob 
End of method: y=Alice 
After: a=Alice 
After: b=Bob

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

下面是这个程序运行的结果截图：

                              

---