深拷贝和浅拷贝

• 浅拷贝：只拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。

或者说，被复制对象的所有变量都含有与原来的对象相同的值，对象的引用对象会在原来的对象和它的副本之间共享。 调用clone()得到的对象。

• 深拷贝：不仅拷贝对象本身，而且拷贝对象包含引用指向的所有对象。    

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。即对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容。override clone()得到的对象，

对其内的引用类型的变量，再进行一次 clone()。或者使用序列化。

范例：
    对象A1中包含对B1的引用，B1中包含对C1的引用。
    浅拷贝A1得到A2，A2中依然包含对B1的引用，B1中依然包含对C1的引用。
    深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2中包含对C2（C1的copy）的引用。

范例：浅拷贝
1.实体类 - Professor0

public class Professor0 implements Cloneable {

    public String name;
    
    public int age;

    public Professor0(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    

}

2.实体类 - Student0

public class Student0 implements Cloneable {

    public String name;
    public int age;
    public Professor0 p;
    public Student0(String name, int age, Professor0 p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
    
    public Object clone() {
        Student0 o = null;
        try {
            o = (Student0) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        return o;
    }
    
    
    
    
}

3.浅拷贝类 - ShallowCopy

public class ShallowCopy {

    public static void main(String[] args) {
        Professor0 p = new Professor0("张三", 50);
        Student0 s1 = new Student0("李四", 18, p);
        Student0 s2 = (Student0) s1.clone();
        s2.p.name = "王五";
        s2.p.age = 30;
        s2.name = "赵六";
        s2.age = 45;
        System.out.println("学生s1的姓名：" + s1.name + "
学生s1教授的姓名：" + s1.p.name + ",
学生s1教授的年龄：" + s1.p.age);
    }
    
}

结果：    学生s1的姓名：李四
        学生s1教授的姓名：王五,
        学生s1教授的年龄：30
        
总结：s2.p变了，s1.p也变了，证明s1的p和s2的p指向的是同一个对象

范例：深拷贝
1.实体类 - Professor

public class Professor implements Cloneable {

    public String name;
    
    public int age;

    public Professor(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public Object clone(){
        Object o = null;
        try {
            o = super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        return o;
    }
    
    

}

2.实体类 - Student

public class Student implements Cloneable {

    public String name;
    public int age;
    public Professor p;
    public Student(String name, int age, Professor p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
    
    public Object clone() {
        Student o = null;
        try {
            o = (Student) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        o.p = (Professor) p.clone();
        return o;
    }
    
    
    
    
}

3.深拷贝类 - DeepCopy

public class DeepCopy {

    public static void main(String[] args) {
        
        long t1 = System.currentTimeMillis();
        Professor p = new Professor("张三", 50);
        Student s1 = new Student("李四", 18, p);
        Student s2 = (Student) s1.clone();
        s2.p.name = "王五";
        s2.p.age = 30;
        System.out.println("学生s1的姓名：" + s1.name + "
学生s1教授的姓名：" + s1.p.name + ",
学生s1教授的年龄：" + s1.p.age);
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }
    
}

结果：    学生s1的姓名：李四
        学生s1教授的姓名：张三,
        学生s1教授的年龄：50
        1

总结：s2.p变了，s1.p没变。证明s1的p和s2的p指向的不是同一个对象

范例：采用序列化实现深拷贝
1.实体类 - Professor2

public class Professor2 implements Serializable {
    private static final long serialVersionUID = 1L;

    public String name;
    
    public int age;

    public Professor2(String name, int age) {
        this.name = name;
        this.age = age;
    }
    

}

2.实体类 - Student2

public class Student2 implements Serializable {
    private static final long serialVersionUID = 1L;
    public String name;
    public int age;
    public Professor2 p;
    
    public Student2(String name, int age, Professor2 p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
    
    public Object deepClone() throws IOException, ClassNotFoundException {
//        将对象写到流里
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
//        从流里读出来
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return oi.readObject();
        
    }
    
}

3.深拷贝类 - DeepCopy2

public class DeepCopy2 {

    public static void main(String[] args) throws ClassNotFoundException, IOException {
        
        long t1 = System.currentTimeMillis();
        Professor2 p = new Professor2("张三", 50);
        Student2 s1 = new Student2("李四", 18, p);
        Student2 s2 = (Student2) s1.deepClone();
        s2.p.name = "王五";
        s2.p.age = 30;
        System.out.println("学生s1的姓名：" + s1.name + "
学生s1教授的姓名：" + s1.p.name + ",
学生s1教授的年龄：" + s1.p.age);
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }
    
}

结果：    学生s1的姓名：李四
        学生s1教授的姓名：张三,
        学生s1教授的年龄：50
        85

总结：s2.p变了，s1.p没变。证明s1的p和s2的p指向的不是同一个对象。相比实现Cloneable，实现Serializable更耗时。