对象的复制

问题

先放一段代码

Point.java

public class Point {
    private int i;
 
    public Point(int i) {
        this.i = i;
    }
 
    public int getI() {
        return i;
    }
 
    public void setI(int i) {
        this.i = i;
    }
}

 PointTest.java

public class PointTest {
    public static void main(String[] args) {
        //创建一个Point对象，使用pa这个引用变量来指向它
        Point pa = new Point(5);
        //创建一个pb引用变量，将pa的值赋值给pb
        Point pb = pa;
        //改变pa中的属性的值
        pa.setI(3);
        //显示pb中的值
        System.out.println(pb.getI());
    }
}

输出的值为：3

因为pa和pb指向的是同一个对象（地址），改变其中任何一个都会改变该对象的内容。
那么如何做到分开呢？就是改变pa的时候不让pb发生改变（一般用于设置中间变量），这里就涉及到对象的复制。

浅拷贝

将Point类修改为Point2类：

public class Point2 implements Cloneable {
    private int i;
 
    public Point2(int i) {
        this.i = i;
    }
 
    public int getI() {
        return i;
    }
 
    public void setI(int i) {
        this.i = i;
    }
 
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Point2Test.java

public class Point2Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        //创建一个Point2对象，使用p2a这个引用变量来指向它
        Point2 p2a = new Point2(5);
        //创建一个新对象，它是p2a的克隆，然后将这个新对象的引用赋值个p2b
        Point2 p2b = (Point2)p2a.clone();
        //改变p2a中的属性的值
        p2a.setI(3);
        //显示p2b中的值
        System.out.println(p2b.getI());
    }
}

输出的值为：5

p2a和p2b是内容相容的不同对象。
Object类中的clone方法将原始对象的每个数据域复制给目标对象：
1.如果一个数据域是基本类型，复制的就是它的值；
2.如果一个数据域是对象，那么复制的就是它的引用。注意这里是它的引用。
如果Point2类中有一个数据域Address类，那么虽然p2a==p2b为假，但是p2a.address==p2b.address为真。
所以这称之为浅拷贝。

深拷贝

Address类

public class Address implements Cloneable {
    private String addressName;
 
    public String getAddressName() {
        return addressName;
    }
 
    public void setAddressName(String addressName) {
        this.addressName = addressName;
    }
 
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Point3类

public class Point3 implements Cloneable {
    private int i;
    private Address address;
 
    public Point3(int i) {
        this.i = i;
    }
 
    public int getI() {
        return i;
    }
 
    public void setI(int i) {
        this.i = i;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public void setAddress(Address address) {
        this.address = address;
    }
 
    @Override
    public Object clone() throws CloneNotSupportedException {
        Point3 p3 = null;
        p3 = (Point3) super.clone();
        p3.address = (Address) address.clone();
 
        return p3;
    }
}

Point3Test.java

public class Point3Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        //初始化对象p3a
        Point3 p3a = new Point3(5);
        Address address = new Address();
        address.setAddressName("位置1");
        p3a.setAddress(address);
 
        //复制对象
        Point3 p3b = (Point3) p3a.clone();
 
        //改变p3a的address
        address.setAddressName("位置2");
 
        //输出结果比较
        System.out.println("p3a的i: " + p3a.getI() + " p3a的address: " +
            p3a.getAddress().getAddressName());
        System.out.println("p3b的i: " + p3b.getI() + " p3b的address: " +
            p3b.getAddress().getAddressName());
    }
}

结果如图：

总结

结论：如果在拷贝一个对象时，要想让这个拷贝的对象和源对象完全彼此独立，那么在引用链上的每一级对象都要被显式的拷贝。所以创建彻底的深拷贝是非常麻烦的，尤其是在引用关系非常复杂的情况下。

所以有了如下一点，阿里巴巴Java开发手册第四章第19条：
【推荐】慎用 Object 的 clone 方法来拷贝对象。
说明： 对象的 clone 方法默认是浅拷贝，若想实现深拷贝需要重写 clone 方法实现属性对象的拷贝。

参考资料：
https://www.cnblogs.com/dolphin0520/p/3700693.html
https://blog.csdn.net/u014727260/article/details/55003402

本文系原创，转载请注明出处，谢谢。