给女友讲讲设计模式——原型模式（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);
    }
}

后记

克隆模式却是在制作副本，并且副本极其相似的情况下，给我们带来了很多便利性，但是如果类结构相对复杂，我们不但得在每一个实体中加入克隆方法，并且这样做还不符合开闭原则。所以在使用之前，应该根据需求，看看需不需要用到原型模式