原型模式要求用深拷貝(複製/克隆)的方式實現，對這個概念很模糊。在自己查了相關資料後，我將從三個方面講述深淺拷貝：

• 圖形表述深淺拷貝區別及特點
• Object類中的clone()方法實現深淺拷貝
• 實際應用中深淺拷貝區別

一 圖形表述深淺拷貝區別及特點

前提：深淺拷貝基本上都是討論引用型別的變數(物件，String類等)，對基本資料型別的變數，深淺拷貝都是要複製的。下面以圖形的形式表述深淺拷貝的區別：

淺拷貝：只複製當前的物件，對該物件內部的引用（其他類物件作為自己的元素-也叫對其他物件的引用）不能複製（在堆記憶體中從新建立空間，內容相同，但地址不同）。 
深拷貝：對物件內部的引用均複製，是建立一個新的例項，並複製例項。

簡言之：是否複製了子物件。/修改了克隆後的物件的屬性值，影響到原物件-淺拷貝；不影響叫深拷貝。

二 Object類中的clone()方法實現深淺拷貝

2.1 java記憶體模型

棧：存放基本型別的變數資料，區域性變數，和物件的引用，但物件本身不存放在棧中，而是存放在堆（new 出來的物件）或者常量池中（字串常量物件存放在常量池中。）

堆：用來存放動態產生的資料，比如new產生的物件，陣列。注意創建出來的物件只包含屬於各自的成員變數，並不包括成員方法。因為同一個類的物件擁有各自的成員變數，儲存在各自的堆中，但是他們共享該類的方法，並不是每建立一個物件就把成員方法複製一次。

2.2 “==”和equals()區別

• 對於基本資料型別(int,float,double,byte,short,long,boolean,char)，只能用==
• 對於基本資料型別的封裝類(Boolean,Integer,Long,Float,Double)，==比較的是指向物件的地址，比較的是棧記憶體中存放的物件的引用（地址），equals比較的是值。
• 如果是類物件，那麼在物件的類沒有重寫equals()方法時，==和equals都是比較地址。如果覆蓋了equals()方法，根據實際情況比較。
• String類，Data類都重寫了equals方法，所以==比較地址，equals比較值。

另外equals滿足四大特性：自反性

2.3 clone()方法的使用

Java中父類java.lang.Object提供了clone()方法，但考慮到安全性問題，一方面將clone()方法的訪問級別設定為protected型別，限制外部類訪問，另一方面，強制需要提供clone功能的子類實現java.lang.Cloneable介面。總結就是如果一個類需要被克隆，該類需要實現clone方法和實現Cloneable介面，缺一不可。

在java中使用clone()方法如何判別深淺拷貝呢，就是判斷拷貝後的物件是否相等，即判斷兩物件的地址是否相同。B=clone(A),A==B為真否。以下圖為例：p1是物件1的引用變數，物件1含有對物件2和物件3的引用；p2是p1的clone()。執行p1.物件1==p2.物件1為ture，因為他們共同儲存物件2的引用。p1==p2為false,因為指向不同的地址。下面從4個角度說明clone()如何體現深淺拷貝。

Clone()方法只複製當前物件，對於沒有內部引用的物件，p2克隆p1後，兩個物件指向不同的地址，p1==p2操作返回false。

package clone1;
class  Person implements Cloneable{
    int age;
    String name;
    public  Person(int a, String b){
        age=a;
        name=b;
    }
    public Person(Person p){
        this.age=p.age;
        this.name=p.name;
    }
@Override
public Object clone() {
    Person per=null;    
    try {
            per=(Person)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return  per;
}
 
}
public class Body {
    public static void main(String[] args){
        Person p1=new Person(10,"wang");
        Person p2 = (Person) p1.clone();
        System.out.println(p1);//輸出堆記憶體的地址
        System.out.println(p2);
        System.out.println(p1==p2);
    }
 
}
}
輸出：
P1地址:[email protected]
P2地址:[email protected]
P1==p2:false
 

當Person類含有其他物件的引用時（含有其他類的物件），增加一個類student，內含成績grade這個元素，該類物件要作為Person類的成員，新增內部引用。呼叫clone方法會發現其他物件的引用並沒有克隆成功。

package clone1;
class Student{
    String grade;
    public Student(){
    }
    public void  setGrade(String a){
        this.grade=a;
    }
}
class  Person implements Cloneable{
    int age;
    String name;
    Student  grades;
    public void setGrades(Student gra){
        this.grades=gra;
    }
    public  Person(int a, String b,Student gra){
        age=a;
        name=b;
        this.grades=gra;
    }
    public Person(Person p){
        this.age=p.age;
        this.name=p.name;
        //this.grade1=p.grade;
    }
@Override
public Object clone() {
    Person per=null;    
    try {
            per=(Person)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return  per;
}
}
public class Body {
    public static void main(String[] args){
        // TODO Auto-generated method stub
        Student stu=new Student();
        stu.setGrade("100");
        Person p1=new Person(10,"wang",stu);
        Person p2 = (Person)  p1.clone();
        System.out.println(p1.grades==p2.grades);
    }
}
結果：p1.grades==p2.grades：true

執行

stu.setGrade("200");
System.out.println(p2.grades.grade);
System.out.println(p1.grades.grade);

後，會發現，兩個結果相同，說明指向同一個物件，一變全變。這就表明grade物件並沒有拷貝，p1和p2存放的是grade的引用。地址相同，這是淺拷貝，也就是說對於不重寫的clone()方法，預設是淺拷貝。

下面仔細的重寫下clone方法，變成深拷貝，不再是修改克隆後的物件的屬性值，影響到原物件。 

package clone1;
class Student implements Cloneable{
    String grade;
    public Student(){
 
    }
    public void  setGrade(String a){
        this.grade=a;
    }
    public Object clone(){
        Student stu=null;
        try {
            stu=(Student)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stu;
    }
}
class  Person implements Cloneable{
    int age;
    String name;
    Student  grades;
    public void setGrades(Student gra){
        this.grades=gra;
    }
    public  Person(int a, String b,Student gra){
        age=a;
        name=b;
        this.grades=gra;
    }
    public Person(Person p){
        this.age=p.age;
        this.name=p.name;
        this.grades=p.grades;
    }
@Override
public Object clone() {
    Person per=null;    
    try {
            per=(Person)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    per.grades=(Student)grades.clone();//深拷貝：就是對引用的物件單獨拷貝一次哦。
        return  per;
}
 
}
public class Body {
    public static void main(String[] args){
        // TODO Auto-generated method stub
        Student stu=new Student();
        stu.setGrade("100");
        Person p1=new Person(10,"wang",stu);
        Person p2 = (Person)  p1.clone();
        System.out.println(p1.grades==p2.grades);
    }
 
}
 
結果：p1.grades==p2.grades:fals

執行

stu.setGrade("200");
System.out.println(p2.grades.grade);
System.out.println(p1.grades.grade);

發現執行結果為200和100，說明的確不是指向同一個物件了(相同引用)，而是單獨指向，不再一變全變。

三 實際應用中深淺拷貝區別

• 如果拆開來對物件2的元素依次賦值，這樣的肯定就是深度複製了。例如p2.grades=new Student(){}因為這樣是明顯的建立新例項來進行賦值，沒有傳遞引用等操作。

• Person a1=new Person(“yellow”,new Person(“li”,10,F)); 
  Person a2=new Person(a1) //若a1中沒有引用，那肯定地址不同，若有物件引用，這種方式不能對引用建立新的記憶體空間，儲存引用。

• Person a2=a1;//最顯而易見的淺複製，全是引用。