介紹

原型模式(Prototype Pattern)：使用原型實(shí)例指定創(chuàng)建對(duì)象的種類，并且通過(guò)拷貝這些原型創(chuàng)建新的對(duì)象。原型模式是一種對(duì)象創(chuàng)建型模式。

原型模式的工作原理很簡(jiǎn)單：將一個(gè)原型對(duì)象傳給那個(gè)要發(fā)動(dòng)創(chuàng)建的對(duì)象，這個(gè)要發(fā)動(dòng)創(chuàng)建的對(duì)象通過(guò)請(qǐng)求原型對(duì)象拷貝自己來(lái)實(shí)現(xiàn)創(chuàng)建過(guò)程。

原型模式是一種“另類”的創(chuàng)建型模式，創(chuàng)建克隆對(duì)象的工廠就是原型類自身，工廠方法由克隆方法來(lái)實(shí)現(xiàn)。

需要注意的是通過(guò)克隆方法所創(chuàng)建的對(duì)象是全新的對(duì)象，它們?cè)趦?nèi)存中擁有新的地址，通常對(duì)克隆所產(chǎn)生的對(duì)象進(jìn)行修改對(duì)原型對(duì)象不會(huì)造成任何影響，每一個(gè)克隆對(duì)象都是相互獨(dú)立的。通過(guò)不同的方式修改可以得到一系列相似但不完全相同的對(duì)象。

角色

• Prototype（抽象原型類）：它是聲明克隆方法的接口，是所有具體原型類的公共父類，可以是抽象類也可以是接口，甚至還可以是具體實(shí)現(xiàn)類。
• ConcretePrototype（具體原型類）：它實(shí)現(xiàn)在抽象原型類中聲明的克隆方法，在克隆方法中返回自己的一個(gè)克隆對(duì)象。
• Client（客戶類）：讓一個(gè)原型對(duì)象克隆自身從而創(chuàng)建一個(gè)新的對(duì)象，在客戶類中只需要直接實(shí)例化或通過(guò)工廠方法等方式創(chuàng)建一個(gè)原型對(duì)象，再通過(guò)調(diào)用該對(duì)象的克隆方法即可得到多個(gè)相同的對(duì)象。由于客戶類針對(duì)抽象原型類Prototype編程，因此用戶可以根據(jù)需要選擇具體原型類，系統(tǒng)具有較好的可擴(kuò)展性，增加或更換具體原型類都很方便。

原型模式的核心在于如何實(shí)現(xiàn)克隆方法。

Java語(yǔ)言提供的clone()方法

學(xué)過(guò)Java語(yǔ)言的人都知道，所有的Java類都繼承自 java.lang.Object。事實(shí)上，Object 類提供一個(gè) clone() 方法，可以將一個(gè)Java對(duì)象復(fù)制一份。因此在Java中可以直接使用 Object 提供的 clone() 方法來(lái)實(shí)現(xiàn)對(duì)象的克隆，Java語(yǔ)言中的原型模式實(shí)現(xiàn)很簡(jiǎn)單。

需要注意的是能夠?qū)崿F(xiàn)克隆的Java類必須實(shí)現(xiàn)一個(gè) 標(biāo)識(shí)接口 Cloneable，表示這個(gè)Java類支持被復(fù)制。如果一個(gè)類沒(méi)有實(shí)現(xiàn)這個(gè)接口但是調(diào)用了clone()方法，Java編譯器將拋出一個(gè) CloneNotSupportedException 異常。

代碼演示—克隆羊

具體原型類:

//實(shí)現(xiàn)Cloneable接口
@Data
public class Sheep implements Cloneable
{
    private String name;
    private Integer age;
    //重寫Object的clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException 
    {
        Sheep sheep=null;
        sheep=(Sheep)super.clone();
        return sheep;
    }
}

客戶端創(chuàng)建并克隆原型對(duì)象：

        //創(chuàng)建原型對(duì)象
        Sheep sheep=new Sheep();
        sheep.setAge(3);
        sheep.setName("肖恩");
        //克隆
        Sheep sheep1 = sheep.clone();
        Sheep sheep2=sheep.clone();
        System.out.println(sheep1);
        System.out.println(sheep2);
        System.out.println(sheep1==sheep2);

結(jié)論

克隆出來(lái)的對(duì)象，它們的內(nèi)存地址均不同，說(shuō)明不是同一個(gè)對(duì)象，克隆成功，克隆僅僅通過(guò)調(diào)用 super.clone() 即可。

看一眼 Object#clone 方法

protected native Object clone() throws CloneNotSupportedException;

這是一個(gè) native 關(guān)鍵字修飾的方法

一般而言，Java語(yǔ)言中的clone()方法滿足：

• 對(duì)任何對(duì)象x，都有 x.clone() != x，即克隆對(duì)象與原型對(duì)象不是同一個(gè)對(duì)象；
• 對(duì)任何對(duì)象x，都有 x.clone().getClass() == x.getClass()，即克隆對(duì)象與原型對(duì)象的類型一樣；
• 如果對(duì)象x的 equals() 方法定義恰當(dāng)，那么 x.clone().equals(x) 應(yīng)該成立。
• 為了獲取對(duì)象的一份拷貝，我們可以直接利用Object類的clone()方法，具體步驟如下：

在派生類中覆蓋基類的 clone() 方法，并聲明為public；

在派生類的 clone() 方法中，調(diào)用 super.clone()；

派生類需實(shí)現(xiàn)Cloneable接口。

此時(shí)，Object類相當(dāng)于抽象原型類，所有實(shí)現(xiàn)了Cloneable接口的類相當(dāng)于具體原型類。

深淺拷貝

pig類:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pig 
{
    String name;
    Integer age;
}

sheep類:

//實(shí)現(xiàn)Cloneable接口
@Data
public class Sheep implements Cloneable
{
    private String name;
    private Integer age;
    private  Pig pig;
    //重寫Object的clone方法
    @Override
    protected Sheep clone() throws CloneNotSupportedException
    {
        Sheep sheep=null;
        sheep=(Sheep)super.clone();
        return sheep;
    }
}

客戶端進(jìn)行克隆:

public class test
{
    @Test
    public void test() throws CloneNotSupportedException {
        //創(chuàng)建原型對(duì)象
        Sheep sheep=new Sheep();
        sheep.setAge(3);
        sheep.setName("肖恩");
        sheep.setPig(new Pig("大忽悠",3));
        //克隆
        Sheep sheep1 = sheep.clone();
        Sheep sheep2=sheep.clone();
        System.out.println(sheep1);
        System.out.println(sheep2);
        System.out.println(sheep1==sheep2);
        System.out.println("==============================");
        System.out.println(sheep1.getPig()==sheep2.getPig());
    }
}

這里對(duì)Sheep類里面的引用類型Pig的克隆方式只是簡(jiǎn)單的地址拷貝，即淺拷貝操作

深淺拷貝探討

淺克隆：

• 在淺克隆中，如果原型對(duì)象的成員變量是值類型，將復(fù)制一份給克隆對(duì)象；如果原型對(duì)象的成員變量是引用類型，則將引用對(duì)象的地址復(fù)制一份給克隆對(duì)象，也就是說(shuō)原型對(duì)象和克隆對(duì)象的成員變量指向相同的內(nèi)存地址。
• 簡(jiǎn)單來(lái)說(shuō)，在淺克隆中，當(dāng)對(duì)象被復(fù)制時(shí)只復(fù)制它本身和其中包含的值類型的成員變量，而引用類型的成員對(duì)象并沒(méi)有復(fù)制。
• 在Java語(yǔ)言中，通過(guò)覆蓋Object類的clone()方法可以實(shí)現(xiàn)淺克隆

深克?。?/strong>

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pig implements Cloneable
{
    String name;
    Integer age;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

//實(shí)現(xiàn)Cloneable接口
@Data
public class Sheep implements Cloneable
{
    private String name;
    private Integer age;
    private  Pig pig;
    //重寫Object的clone方法
    @Override
    protected Sheep clone() throws CloneNotSupportedException
    {
        Sheep sheep=null;
        sheep=(Sheep)super.clone();
        sheep.pig=(Pig)sheep.pig.clone();
        return sheep;
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pig implements Serializable
{
    String name;
    Integer age;
}

//實(shí)現(xiàn)Cloneable接口
@Data
public class Sheep implements Serializable
{
    private String name;
    private Integer age;
    private  Pig pig;
 //序列化方式完成深拷貝
    public Sheep deepClone() throws IOException, ClassNotFoundException {
        //先將要序列化的對(duì)象寫入流中
        ByteArrayOutputStream baot=new ByteArrayOutputStream();
        //ObjectOutputStream構(gòu)造函數(shù)的參數(shù)是，將對(duì)象流寫入到哪里
        ObjectOutputStream oot=new ObjectOutputStream(baot);
          oot.writeObject(this);
          //將序列化的對(duì)象從流中讀取出來(lái)
        ByteArrayInputStream bait=new ByteArrayInputStream(baot.toByteArray());
        ObjectInputStream oit=new ObjectInputStream(bait);
        return (Sheep) oit.readObject();
    }
}

public class HungrySingleton implements Serializable, Cloneable {
    private final static HungrySingleton hungrySingleton;
    static {
        hungrySingleton = new HungrySingleton();
    }
    private HungrySingleton() 
    {}
    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
    private Object readResolve() {
        return hungrySingleton;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        HungrySingleton hungrySingleton = HungrySingleton.getInstance();
        Method method = hungrySingleton.getClass().getDeclaredMethod("clone");
        method.setAccessible(true);
        HungrySingleton cloneHungrySingleton = (HungrySingleton) method.invoke(hungrySingleton);
        System.out.println(hungrySingleton);
        System.out.println(cloneHungrySingleton);
    }
}

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