給女友講講設計模式——原型模式（JAVA執行個體）4

前言

上高中那陣子，特别迷戀火影，是以每周都會等着更新。最讓我難忘的是裡面的主人公鳴人，和他的各種各樣炫酷的技能。他的影分身，一下子可以分離出來多個自己，并且這些自己的副本使用的技能都是相同的。如果他的副本想要使用其他的技能，除非分身再克隆出來一個技能的副本，然後去進行學習。

正文

剛剛說的那個例子，大家先記着，接下來我慢慢揭開圓形模式的面紗。

原型模式，簡單來說就像是我們操縱電腦使的複制粘貼，隻不過我們是要去操縱對象。在java中使用原型模式特别的簡單，隻需要重寫clone（）方法，然後實作Cloneable接口（其實這個接口是一個空接口，隻是為了告訴jvm，這個類是可以克隆的）；

原型模式一共分為兩種：

1.淺克隆

2.深克隆

下面看看淺克隆的代碼

這是一個忍者的實體類，代表鳴人的。

package prototype;

public class Nanjia implements Cloneable{
    
    private String name;
    private Integer age;
    private Skill skill;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
    public Skill getSkill() {
        return skill;
    }
    public void setSkill(Skill skill) {
        this.skill = skill;
    }
    @Override
    public Nanjia clone() {
        try {
            Nanjia nanjia=(Nanjia)super.clone();
            return nanjia;
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    @Override
    public String toString() {
        return "Nanjia [name=" + name + ", age=" + age + ", skill=" + skill + "]";
    }
    
}

           

然後是一個skill的實體類，可以裝者技能的種類和名稱

package prototype;

public class Skill{
    private String name;
    private String type;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    @Override
    public String toString() {
        return "Skill [name=" + name + ", type=" + type + "]";
    }
    
}

           

package prototype;

public class MainTest {

    public static void main(String[] args) {
        Nanjia nanjia=new Nanjia();
        nanjia.setAge(16);
        nanjia.setName("漩渦鳴人");
        Skill skill=new Skill();
        skill.setName("仙人模式");
        nanjia.setSkill(skill);
        System.out.println("這是需要被克隆的類");
        System.out.println(nanjia);
        Nanjia nanjia2=nanjia.clone();
        Skill skill2=nanjia2.getSkill();
        skill2.setName("螺旋丸");
        nanjia2.setSkill(skill2);
        System.out.println("這是克隆出來的類");
        System.out.println(nanjia2);
        System.out.println("這是原來的類");
        System.out.println(nanjia);
    }
}

           

在測試類中我們做了這樣的操作，将一些屬性賦予nanji的實體類中，然後我們通過克隆複制出了一個副本，可以看作類似于影分身一樣，然後拿出副本中的技能将它轉換為别的技能，最後我們會發現原來本身的技能也發生了變化，這是怎麼一回事呢？

這是因為淺克隆，在克隆的過程中，對象中的實體引用，隻是複制了這個引用的位址，是以在修改的時候就相當于把原來本體的技能同樣進行修改。

那我們要是想不影響之前的本體該怎麼辦呢，接下來隆重介紹深克隆。

深克隆是把忍者類中的技能類也重寫了克隆方法，這樣在影分身的副本中我們就可以自由轉換，而不影響忍者這個本體了。

然後是深克隆的代碼：

package prototype;

public class Nanjia implements Cloneable{
    
    private String name;
    private Integer age;
    private Skill skill;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
    public Skill getSkill() {
        return skill;
    }
    public void setSkill(Skill skill) {
        this.skill = skill;
    }
    @Override
    public Nanjia clone() {
        try {
            Nanjia nanjia=(Nanjia)super.clone();
            //關鍵的地方在這裡，我們像克隆忍者一樣，把技能這個類也進行了克隆
            nanjia.setSkill((Skill)nanjia.getSkill().clone());
            return nanjia;
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    @Override
    public String toString() {
        return "Nanjia [name=" + name + ", age=" + age + ", skill=" + skill + "]";
    }
    
}

           

我們繼承了Cloneable接口，重寫了Clone這個方法。

package prototype;

public class Skill implements Cloneable{
    private String name;
    private String type;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    @Override
    public String toString() {
        return "Skill [name=" + name + ", type=" + type + "]";
    }
    
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
    
}

           

package prototype;

public class MainTest {

    public static void main(String[] args) {
        Nanjia nanjia=new Nanjia();
        nanjia.setAge(16);
        nanjia.setName("漩渦鳴人");
        Skill skill=new Skill();
        skill.setName("仙人模式");
        nanjia.setSkill(skill);
        System.out.println("這是需要被克隆的類");
        System.out.println(nanjia);
        Nanjia nanjia2=nanjia.clone();
        Skill skill2=nanjia2.getSkill();
        skill2.setName("螺旋丸");
        nanjia2.setSkill(skill2);
        System.out.println("這是克隆出來的類");
        System.out.println(nanjia2);
        System.out.println("這是原來的類");
        System.out.println(nanjia);
    }
}

           

後記

克隆模式卻是在制作副本，并且副本極其相似的情況下，給我們帶來了很多便利性，但是如果類結構相對複雜，我們不但得在每一個實體中加入克隆方法，并且這樣做還不符合開閉原則。是以在使用之前，應該根據需求，看看需不需要用到原型模式