原型模式

定义：

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。

应用场景：

• 对象之间相同或相似，即只是个别的几个属性不同的时候。
• 对象的创建过程比较麻烦，但复制比较简单的时候。

特点：

用这种方式创建对象非常高效，根本无须知道对象创建的细节。

主要角色：

• 抽象原型类：规定了具体原型对象必须实现的接口。
• 具体原型类：实现抽象原型类的clone()方法，它是可被复制的对象。
• 访问类：使用具体原型类中的clone()方法来复制新的对象。

结构图：

浅拷贝

浅拷贝的介绍：

1. 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
2. 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
3. 浅拷贝是使用默认的clone()方法来实现：sheep = (Sheep) super.clone();

应用实例：

克隆羊问题：
现在有一只羊tom，姓名为: tom，年龄为：1，颜色为：白色，请编写程序创建和tom羊属性完全相同的10只羊。

思路：Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力 -> 原型模式。

Sheep.java

public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;
    private String address = "蒙古羊";
    public Sheep friend; //是对象，克隆会如何处理

    public Sheep(String name, int age, String color) {
        super();
        this.name = name;
        this.age = age;
        this.color = color;
    }
    @Override
    public String toString() {
        return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
    }
    //克隆该实例，使用默认的clone()方法来完成
    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("tom", 1, "白色");
        sheep1.friend = new Sheep("jack", 2, "黑色");

        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.hashCode() + " " + sheep1.friend + " " + sheep1.friend.hashCode());
        System.out.println(sheep2 + " " + sheep2.hashCode() + " " + sheep2.friend + " " + sheep2.friend.hashCode());
        System.out.println(sheep3 + " " + sheep3.hashCode() + " " + sheep3.friend + " " + sheep3.friend.hashCode());
        System.out.println(sheep4 + " " + sheep4.hashCode() + " " + sheep4.friend + " " + sheep4.friend.hashCode());
        System.out.println(sheep5 + " " + sheep5.hashCode() + " " + sheep5.friend + " " + sheep5.friend.hashCode());
        //Sheep [name=tom, age=1, color=白色, address=蒙古羊] 1349393271 Sheep [name=jack, age=2, color=黑色, address=蒙古羊] 1338668845
        //Sheep [name=tom, age=1, color=白色, address=蒙古羊] 1494279232 Sheep [name=jack, age=2, color=黑色, address=蒙古羊] 1338668845
        //Sheep [name=tom, age=1, color=白色, address=蒙古羊] 1650967483 Sheep [name=jack, age=2, color=黑色, address=蒙古羊] 1338668845
        //Sheep [name=tom, age=1, color=白色, address=蒙古羊] 87285178 Sheep [name=jack, age=2, color=黑色, address=蒙古羊] 1338668845
        //Sheep [name=tom, age=1, color=白色, address=蒙古羊] 610998173 Sheep [name=jack, age=2, color=黑色, address=蒙古羊] 1338668845
    }
}

深拷贝

深拷贝基本介绍：

• 复制对象的所有基本数据类型的成员变量值。
• 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
• 深拷贝实现方式1：重写clone方法来实现深拷贝。
• 深拷贝实现方式2：通过对象序列化实现深拷贝（推荐）。

DeepCloneableTarget.java

public class DeepCloneableTarget implements Serializable, Cloneable {
    private static final long serialVersionUID = 1L;
    private String cloneName;
    private String cloneClass;
    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }
    //因为该类的属性都是String，因此我们这里使用默认的clone()完成即可
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

DeepProtoType.java

public class DeepProtoType implements Serializable, Cloneable{
    public String name;
    public DeepCloneableTarget deepCloneableTarget;
    public DeepProtoType() {
        super();
    }
    //深拷贝 - 方式1 重写clone方法实现深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //这里完成对基本数据类型(属性)和String的克隆
        deep = super.clone();
        //对引用类型的属性，进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;
        deepProtoType.deepCloneableTarget  = (DeepCloneableTarget) deepCloneableTarget.clone();
        return deepProtoType;
    }
    //深拷贝 - 方式2 通过对象序列化实现深拷贝(推荐)
    public Object deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); //当前这个对象以对象流的方式输出
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepProtoType copyObj = (DeepProtoType) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}

Client.java

public class Client {
    public static void main(String[] args) throws Exception {
        DeepProtoType p1 = new DeepProtoType();
        p1.name = "宋江";
        p1.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
        //方式1 完成深拷贝
        DeepProtoType p2 = (DeepProtoType) p1.clone();
        System.out.println(p1.name + " " + p1.deepCloneableTarget.hashCode()); //宋江 1338668845
        System.out.println(p2.name + " " + p2.deepCloneableTarget.hashCode()); //宋江 932172204
        //方式2 完成深拷贝
        DeepProtoType p3 = (DeepProtoType) p1.deepClone();
        System.out.println(p1.name + " " + p1.deepCloneableTarget.hashCode()); //宋江 1338668845
        System.out.println(p3.name + " " + p3.deepCloneableTarget.hashCode()); //宋江 1789447862
    }
}