学习笔记：设计模式之原型模式

问题：现有一只羊，名字叫小绿，它的配偶叫小红，现在请编写程序创建与小绿羊属性相同的5只羊。

1.传统方法

首先先创建一个羊类:

public class Sheep {
    private String name;
    private Sheep spouse;
    public Sheep(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Sheep getSpouse() {
        return spouse;
    }
    public void setSpouse(Sheep spouse) {
        this.spouse = spouse;
    }
    @Override
    public String toString() {
        return "Sheep [name=" + name + ", spouse=" + spouse + "]";
    }
}

在主方法中创建5只相同属性的羊:

public class Test {
    public static void main(String[] args){
        Sheep sheep1 = new Sheep("小绿");
        Sheep sheep2 = new Sheep(sheep1.getName());
        Sheep sheep3 = new Sheep(sheep1.getName());
        Sheep sheep4 = new Sheep(sheep1.getName());
        Sheep sheep5 = new Sheep(sheep1.getName());
    }
}

评价：

优点：比较好理解，简单易操作。
缺点：1.在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂
时，效率较低。 2.为对象增减属性时不够灵活，需要修改大量代码，不符合OCP原则。

2.浅拷贝

首先县创建一个羊类，该类要实现Cloneable接口，并且要重写clone()方法：

public class Sheep implements Cloneable{
    private String name;
    private Sheep spouse;
    public Sheep(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Sheep getSpouse() {
        return spouse;
    }
    public void setSpouse(Sheep spouse) {
        this.spouse = spouse;
    }
    @Override
    public String toString() {
        return "Sheep [name=" + name + ", spouse=" + spouse + "]";
    }
    @Override
    protected Object clone(){
        Object cloneSheep = null;
        try {
            cloneSheep = super.clone();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            System.out.println(e.getMessage());
        }
        return cloneSheep;
    }
}

调用该类中的clone()方法就能实现对该类的克隆（拷贝）：

public class Test {
    public static void main(String[] args){
        Sheep sheep1 = new Sheep("小绿");
        sheep1.setSpouse(new Sheep("小红"));
        Sheep sheep2 = (Sheep) sheep1.clone();
        Sheep sheep3 = (Sheep) sheep1.clone();
        Sheep sheep4 = (Sheep) sheep1.clone();
        Sheep sheep5 = (Sheep) sheep1.clone();
        
        System.out.println("sheep1" + sheep1 + "    sheep1配偶的hashcode : " + sheep1.getSpouse().hashCode());
        System.out.println("sheep2" + sheep2 + "    sheep2配偶的hashcode : " + sheep2.getSpouse().hashCode());
        System.out.println("sheep3" + sheep3 + "    sheep3配偶的hashcode : " + sheep3.getSpouse().hashCode());
        System.out.println("sheep4" + sheep4 + "    sheep4配偶的hashcode : " + sheep4.getSpouse().hashCode());
        System.out.println("sheep5" + sheep5 + "    sheep5配偶的hashcode : " + sheep5.getSpouse().hashCode());
    }
}

上述代码执行的结果为：

sheep1Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep1配偶的hashcode : 366712642
sheep2Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep2配偶的hashcode : 366712642
sheep3Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep3配偶的hashcode : 366712642
sheep4Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep4配偶的hashcode : 366712642
sheep5Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep5配偶的hashcode : 366712642

浅拷贝的特点：

对于基本数据类型和String类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

3.深拷贝

深拷贝有两种实现方式：1.重写clone()方法 2.对象序列化

3.1 重写clone()方法

与浅拷贝其它方面一样，只需对类中的每个引用数据类型（除String）单独的处理即可（在clone()方法中）

    @Override
    protected Object clone(){
        Object cloneSheep = null;
        try {
            cloneSheep = super.clone();
            Sheep sheep = (Sheep)cloneSheep;
            //对引用类行进行单独处理
            sheep.spouse = (Sheep) spouse.clone();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.getStackTrace();
        }
        return cloneSheep;
    }

此时的运行结果为：

sheep1Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep1配偶的hashcode : 366712642
sheep2Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep2配偶的hashcode : 1829164700
sheep3Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep3配偶的hashcode : 2018699554
sheep4Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep4配偶的hashcode : 1311053135
sheep5Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]    sheep5配偶的hashcode : 118352462

劣势：

要为类中每个引用类型的属性(除String)进行单独操作，若类中引用类型较多，编写麻烦。而且类增删引用类型的属性时，要相应的修改代码。

3.2 对象序列化

首先要创建一个羊类，该类需要实现Serializable接口，并且自己要写一个方法(方法名自己随便起)通过对象序列化来实现对对象的克隆：

public class Sheep implements Serializable{
    private String name;
    private Sheep spouse;
    public Sheep(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Sheep getSpouse() {
        return spouse;
    }
    public void setSpouse(Sheep spouse) {
        this.spouse = spouse;
    }
    @Override
    public String toString() {
        return "Sheep [name=" + name + ", spouse=" + spouse + "]";
    }
    public Sheep deepClone(){
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        Sheep cloneSheep = null;
        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            cloneSheep = (Sheep) ois.readObject();
            return cloneSheep;
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return cloneSheep;
    }
}

调用该类中的deepClone()方法就能实现对该类的克隆（拷贝）：

public class Test {
    public static void main(String[] args){
        Sheep sheep1 = new Sheep("小绿");
        sheep1.setSpouse(new Sheep("小红"));
        Sheep sheep2 = sheep1.deepClone();
        Sheep sheep3 = sheep1.deepClone();
        Sheep sheep4 = sheep1.deepClone();
        Sheep sheep5 = sheep1.deepClone();
        
        System.out.println("sheep1" + sheep1 + "    sheep1配偶的hashcode : " + sheep1.getSpouse().hashCode());
        System.out.println("sheep2" + sheep2 + "    sheep2配偶的hashcode : " + sheep2.getSpouse().hashCode());
        System.out.println("sheep3" + sheep3 + "    sheep3配偶的hashcode : " + sheep3.getSpouse().hashCode());
        System.out.println("sheep4" + sheep4 + "    sheep4配偶的hashcode : " + sheep4.getSpouse().hashCode());
        System.out.println("sheep5" + sheep5 + "    sheep5配偶的hashcode : " + sheep5.getSpouse().hashCode());
    }
}

输出的结果为：

sheep1Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]  sheep1配偶的hashcode : 589431969
sheep2Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]  sheep2配偶的hashcode : 1078694789
sheep3Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]  sheep3配偶的hashcode : 1831932724
sheep4Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]  sheep4配偶的hashcode : 1747585824
sheep5Sheep [name=小绿, spouse=Sheep [name=小红, spouse=null]]  sheep5配偶的hashcode : 1023892928

评价：

可以动态的获得对象运行时的状态，不需要对类引用类型的属性进行额外处理，原始对象发生变化，其克隆对象就会发生相应的变化，无需修改代码。因此，推荐使用对象序列化的方式作为实现深拷贝的首选方法。

4.总结

原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。但是，原型模型的实现需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，这违背了ocp原则。