Java 对象复制

Java 对象的一共有 3 种复制对象的方式。

1.直接赋值 （引用复制 ），此种复制方式比较常用。

诸如 A  a = b ;  a 是直接复制了b的引用 ，也就是说它俩指向的是同一个对象。 此时 a == b  [ true ] 。

class A{
    private String string;
    A(){string = new String("original state");}
    public void set(String string) {this.string = string;}
    public String get() {return string;}
}

public class B{
        public static void main(String[] args) {
        // TODO 自动生成的方法存根
        A a = new A();
        A b = a;
        System.out.println(a == b);
        a.set("state has changed");
        System.out.println(a == b);
    }
}

2.浅拷贝  -------  复制当前对象的非静态字段【静态字段只在类加载的时候加载一次】，如果当前字段为 值类型 字段，那么直接复制该字段，如果是 引用类型 的，则对其复制引用。

所谓的值类型就是指Java中的8种基本类型，那么什么是值类型的复制呢？

举个例子 int A = 0; int B = A; 那么这样B拷贝的是A指向的常量对象，而非A的引用，当A改变时，并不会影响B的指向。【Ps: A =1; 则B = 0 ，而非 1 ， 这就是值类型的复制】

所谓的引用类型就是一些你自己构建的类和库中的一些类实例化出来的对象，引用复制又指的啥呢？

举个例子

class A {public int value = 0 ; }  ====>     A a = new A(); A b = a;      =====>  a.value = 1;  那么 ==>  b.value = 1； 因为它们指向的是同一个对象【复制的是引用】

class B implements Cloneable{
    
    private C c;
    
    private String string ;
    public B() {string = new String("Init string"); c = new C();}
    public void set(String string) {this.string = string;}
    public String get() {return string;}
    
    //setC()方法中添加一句 c = new C() ,就变为深拷贝了，因为添加了 这句代码， 拷贝 引用类型时，就变成拷贝其对象，而不是引用了
    public void setC(String string) {c.set(string);} 
    public String getC() {return c.get();}
    
    
    @Override
    public Object clone() {
        B sCopy = null;
        try {
            sCopy = (B)super.clone();
        }catch(Exception e) {
            e.printStackTrace();
        }
        return sCopy;
    }
}
public static void main(String[] args) {
        // TODO 自动生成的方法存根
        
        
        B sCopyA = new B();
        B sCopyB = (B) sCopyA.clone();        
        
        sCopyA.set("hava changed !");    
        //    sCopyA.string = hava changed ! ------- sCopyA.string = Init string
        //    改变了 sCopyA 并没有改变 sCopyB。 因为 B.string  是一个值类型        
        System.out.println("sCopyA.string = "+ sCopyA.get()+" ------- sCopyA.string = "+ sCopyB.get());
        
        sCopyB.setC("C have Changed !");
        //    C.string = C have Changed ! ------- C.string = C have Changed !    
        //    改变了 sCopyA 同时也改变 sCopyB。因为 B.string  是一个引用类型    
        System.out.println("C.string = "+ sCopyA.getC()+" ------- C.string = "+ sCopyB.getC());
}

3.深拷贝  -------  和浅拷贝的区别就在于，其不管字段类型是什么，统统的全给拷贝过去【即使相对与 非基本类型而言 拷贝的也是对象而不是引用 ，深拷贝之后将会产生2个对象 ，浅拷贝只是一个对象的2个引用而已（相当于1个人的2个名字）】。

我们只要在 2的基础上添加一行代码就行， 因为只要将 引用字段，也进行复制 ，就是深拷贝了。

附：1.clone()方法 需要覆写。 2.覆写clone()方法需要实现Cloneable 接口， 未实现的话会抛出异常。 3 .clone()是本地方法，其内部实现如下图。