Java 中对象引用与复制

1. 对象的参数传递和赋值（=）

Java对对象和基本的数据类型的处理是不一样的。当把Java的基本数据类型（如int，char，double等）作为入口参数传给函数体的时候，是"值传递"。

而在Java中用对象的作为入口参数的传递的时候，却不是像C++那样的"引用传递"。能将改变的参数对象状态（即对象的成员变量的值）返回，不能
将一个参数对象赋值给另一个新的参数对象返回。以下是关于方法参数的规则(摘自Core Java 2 Volume I)：
・A method cannot modify a parameter of primitive type (that is, numbers or Boolean values).
・A method can change the state of an object parameter.
・A method cannot make an object parameter refer to a new object.

Example:----------------------
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("Harry", 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 method: x=" + x.getName()); System.out.println("End of method: y=" + y.getName()); }}class Employee // simplified Employee class{ 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; } private String name; private double salary;}

Run Result：------------
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

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

不过，在任何用"＝"向对象变量赋值的时候都是"引用传递"。
同样，在Vector、ArraryList、HashTable等Collection、Map里存储的对象也只是对象的引用。

 

2. 对象的复制（clone）

 

对象的复制，不能简单通过“=”赋值，否则也浅拷贝（Shallow Copy）, 一般用对象的clone方法进行深拷贝（Deep Copy），这个方法是Object类的protected方法。但是，your code can't simply call anObject.clone(). A subclass can call a protected clone method only to clone its own objects. You must redefine clone to be public to allow objects to be cloned by any method.

 If all data fields in the object are numbers or other basic types, use the default clone method, copying the fields is just fine. But if the object contains references to subobjects like String, Date and so on, you must redefine the clone method to make a deep copy that clones the subobjects as well because of subobjects are mutable.

  ・ Implement the Cloneable interface, and

  ・ Redefine the clone method with the public access modifier.

 The Cloneable interface is one of a handful of tagging interfaces that Java provides. (Some programmers call them marker interfaces.) A tagging interface has no methods; its only purpose is to allow the use of instanceof in a type inquiry:

          if (obj instanceof Cloneable) . . .
Even if the default (shallow copy) implementation of clone is adequate, you still need to implement the Cloneable interface, redefine clone to be public, and call super.clone().

 

Here is an example of a clone method that creates a deep copy:

class Employee implements Cloneable{ . . . public Object clone() throws CloneNotSupportedException { // call Object.clone() Employee cloned = (Employee) super.clone(); // clone mutable fields cloned.hireDay = (Date) hireDay.clone() return cloned; }}

The clone method of the Object class must explicitly throw a CloneNotSupportedException,or it will cause a compiled error. We usually declared the exception:

public Employee clone() throws CloneNotSupportedException

 

参考文献：
1. Core Java 2 Volume I 7th Edtion