Java中對象的復制

　　假如說你想復制一個簡單變量。很簡單:

int n = 5;
int m = n;

　　不僅僅是int類型，其它七種原始數據類型(boolean,char,byte,short,float,double.long)同樣適用於該類情況。但是如果你復制的是一個對象，情況就有些復雜了。

　　假設說我是一個beginner，我會這樣寫：

class Student {
    private int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    
}
public class Test {
    
    public static void main(String args[]) {
        
        Student stu1 = new Student();
        stu1.setNumber(12345);
        Student stu2 = stu1;
        
        System.out.println("學生1:" + stu1.getNumber());
        System.out.println("學生2:" + stu2.getNumber());
    }
}

　　打印結果：

 
            
            學生1:12345   
            學生2:12345
學生1:12345
學生2:12345

　　這里我們自定義了一個學生類，該類只有一個number字段。

　　我們新建了一個學生實例，然后將該值賦值給stu2實例。(Student stu2 = stu1;)

　　再看看打印結果，作為一個新手，拍了拍胸腹，對象復制不過如此，

　　難道真的是這樣嗎？

　　我們試着改變stu2實例的number字段，再打印結果看看：

stu2.setNumber(54321);
    
System.out.println("學生1:" + stu1.getNumber());
System.out.println("學生2:" + stu2.getNumber());

　　打印結果:

 
            
            學生1:54321   
            學生2:54321
學生1:54321
學生2:54321

　　這就怪了，為什么改變學生2的學號，學生1的學號也發生了變化呢？

　　原因出在(stu2 = stu1) 這一句。該語句的作用是將stu1的引用賦值給stu2，

　　這樣，stu1和stu2指向內存堆中同一個對象。如圖：

 

　　那么，怎樣才能達到復制一個對象呢？

　　是否記得萬類之王Object。它有11個方法，有兩個protected的方法，其中一個為clone方法。

　　該方法的簽名是：

　　　　protected native Object clone() throws CloneNotSupportedException;

　　因為每個類直接或間接的父類都是Object，因此它們都含有clone()方法，但是因為該方法是protected，所以都不能在類外進行訪問。

　　要想對一個對象進行復制，就需要對clone方法覆蓋。

　　一般步驟是（淺復制）：

　　　　1. 被復制的類需要實現Clonenable接口（不實現的話在調用clone方法會拋出CloneNotSupportedException異常) 該接口為標記接口(不含任何方法)

　　　　2. 覆蓋clone()方法，訪問修飾符設為public。方法中調用super.clone()方法得到需要的復制對象，（native為本地方法)

　　下面對上面那個方法進行改造：

class Student implements Cloneable{
    private int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    
    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }
}
public class Test {
    
    public static void main(String args[]) {
        
        Student stu1 = new Student();
        stu1.setNumber(12345);
        Student stu2 = (Student)stu1.clone();
        
        System.out.println("學生1:" + stu1.getNumber());
        System.out.println("學生2:" + stu2.getNumber());
        
        stu2.setNumber(54321);
    
        System.out.println("學生1:" + stu1.getNumber());
        System.out.println("學生2:" + stu2.getNumber());
    }
}

 打印結果：

學生1:12345
學生2:12345
學生1:12345
學生2:54321

　　如果你還不相信這兩個對象不是同一個對象，那么你可以看看這一句：

System.out.println(stu1 == stu2); // false  

　　上面的復制被稱為淺復制(Shallow Copy)，還有一種稍微復雜的深度復制(deep copy)：

　　我們在學生類里再加一個Address類。

class Address  {
    private String add;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }
    
}

class Student implements Cloneable{
    private int number;

    private Address addr;
    
    public Address getAddr() {
        return addr;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    
    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }
}
public class Test {
    
    public static void main(String args[]) {
        
        Address addr = new Address();
        addr.setAdd("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);
        
        Student stu2 = (Student)stu1.clone();
        
        System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
    }
}

 

　　打印結果：

 
            
            學生1:123,地址:杭州市   
            學生2:123,地址:杭州市
學生1:123,地址:杭州市
學生2:123,地址:杭州市

　　乍一看沒什么問題，真的是這樣嗎？我們在main方法中試着改變addr實例的地址。

addr.setAdd("西湖區");
        
System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

　　打印結果：

學生1:123,地址:杭州市
學生2:123,地址:杭州市
學生1:123,地址:西湖區
學生2:123,地址:西湖區

　　這就奇怪了，怎么兩個學生的地址都改變了？

　　原因是淺復制只是復制了addr變量的引用，並沒有真正的開辟另一塊空間，將值復制后再將引用返回給新對象。

　　所以，為了達到真正的復制對象，而不是純粹引用復制。我們需要將Address類可復制化，並且修改clone方法，完整代碼如下：

package abc;

class Address implements Cloneable {
    private String add;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }
    
    @Override
    public Object clone() {
        Address addr = null;
        try{
            addr = (Address)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return addr;
    }
}

class Student implements Cloneable{
    private int number;

    private Address addr;
    
    public Address getAddr() {
        return addr;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    
    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();    //淺復制
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        stu.addr = (Address)addr.clone();    //深度復制
        return stu;
    }
}
public class Test {
    
    public static void main(String args[]) {
        
        Address addr = new Address();
        addr.setAdd("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);
        
        Student stu2 = (Student)stu1.clone();
        
        System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
        
        addr.setAdd("西湖區");
        
        System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
    }
}

　　打印結果：

學生1:123,地址:杭州市
學生2:123,地址:杭州市
學生1:123,地址:西湖區
學生2:123,地址:杭州市

　　這樣結果就符合我們的想法了。

　　最后我們可以看看API里其中一個實現了clone方法的類：

　　java.util.Date:

    /**
     * Return a copy of this object.
     */
    public Object clone() {
        Date d = null;
        try {
            d = (Date)super.clone();
            if (cdate != null) {
                d.cdate = (BaseCalendar.Date) cdate.clone();
            }
        } catch (CloneNotSupportedException e) {} // Won't happen
        return d;
    }

　　該類其實也屬於深度復制。