Java的深拷貝和淺拷貝，我用一個最直接的例子來說明，需要執行程式碼直接拷貝過去，直接執行。

淺拷貝：重寫clone()方法，返回super.clone()方法，該方法在物件呼叫時候預設返回的就是淺拷貝，淺拷貝時只拷貝物件本身和物件的基本變數，物件的引用變數不會進行拷貝，還是指向原來的物件。

深拷貝：需要重寫clone()方法，我在程式碼中已經註釋掉了，如果該類有多個物件引用，需要都進行clone重寫，因為每次clone都是跟之前物件的地址是不同的，所以物件是使用==比較符是不相等返回false。

/**
 * @author 冉野 E-mail:[email protected]
 
.com
 * @version 建立時間：18/9/29 下午5:55
 */
public class CloneableTest2 implements Cloneable {
    private String name;
    private CloneableTest cloneableTest;
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public CloneableTest getCloneableTest() {
        return cloneableTest;
    }

    public void setCloneableTest(CloneableTest cloneableTest) {
        this.cloneableTest = cloneableTest;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CloneableTest2)) return false;
        CloneableTest2 that = (CloneableTest2) o;
        return Objects.equals(getName(), that.getName()) &&
                Objects.equals(getCloneableTest(), that.getCloneableTest());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getCloneableTest());
    }

    //  深拷貝時候的重寫clone()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        CloneableTest2 cloneableTest2 = (CloneableTest2) super.clone();
        cloneableTest2.cloneableTest = (CloneableTest) cloneableTest2.getCloneableTest().clone();
        return cloneableTest2;
    }

    //  淺拷貝時候clone()方法
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        return super.clone();
//    }

    public static void main(String[] args) {
        CloneableTest2 cl1 = new CloneableTest2();
        CloneableTest cloneableTest = new CloneableTest("1",1);
        cl1.setCloneableTest(cloneableTest);
        CloneableTest2 cl2 = null;

        try {
            //  淺拷貝是指在物件拷貝時候僅僅是拷貝物件本身和基本變數 關於物件的引用型別變數不進行拷貝
            cl2 = (CloneableTest2) cl1.clone();
            System.out.println(cl1.equals(cl2));  //  true
            System.out.println(cl1.getClass() == cl2.getClass()); //  true
            System.out.println(cl1 == cl2);  //  false
            //  拷貝時 每次都是新的物件 所以 == 比較總是返回false
       System.out.println(cl1.getCloneableTest()==cl2.getCloneableTest());// false 
            // 引用型別的變數 還是執行原來的物件 沒發生改變 但是深拷貝就會改變
            //  構造方法鏈 子類在呼叫自己構造方法前 如果繼承父類 會先使用父類的構造方法 如果父類還繼承了別的類 則
            //  也會先呼叫該父類的構造方法
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}
 

CloneableTest類

public class CloneableTest implements Cloneable{

    private String name;
    private int age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CloneableTest)) return false;
        CloneableTest that = (CloneableTest) o;
        return age == that.age &&
                Objects.equals(name, that.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }