原型模式1. 概述 2. UML图 3. 实例 4. 浅拷贝和深拷贝对于数据类型是基本数据类型的成员变量，浅拷贝会直接

1. 概述

原型模式（Prototype）是指使用原型实例指定创建对象的种类，并且通过拷贝这个模型，创建新的对象
原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制的对象，无需知道如何创建的细节
工作原理是通过将一个圆形对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()

2. UML图

Prototype：原型类，声明一个克隆自己的接口
ConcretePrototype：具体的原型类, 实现一个克隆自己的操作

3. 实例

Spring中在配置Bean的时候，能够配置scope属性为singleton还是prototype，这就是单例模式和原型模式的一个体现

在Java中，一个类需要实现Cloneable接口，并且重写Object类中的clone()方法，才能够调用对象.clone()方法来对自身进行克隆

public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Client2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("tom", 2, "白色");
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();
    }
}

4. 浅拷贝和深拷贝

4.1 浅拷贝

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

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

比如我们在Sheep类中定义一个引用数据类型Arraylist，然后直接使用默认的clone()方法拷贝，对比两个对象的list对象是否地址相同，会得到true的结果。但是注意，两个对象的地址值是不同的，但是引用类型的成员变量是同一份。

4.2 深拷贝

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

4.2.1 实现深拷贝的第一种方式

现在有一个类DeepClass，其中有String类型的成员变量和Sheep（自定义类）类型的成员变量，通过重写clone方法来实现深拷贝

public class DeepClass implements Serializable, Cloneable {
    private String string;
    private Sheep sheep;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        DeepClass deepClass = null;
        // 这里完成对基本数据类型和字符串的克隆
        deepClass = (DeepClass)super.clone();

        // 对引用类型的属性进行单独的处理
        Sheep deepSheep = (Sheep) sheep.clone();
        deepClass.setSheep(deepSheep);

        return deepClass;
    }
}

将引用数据类型设置为原有对象的clone对象来实现深拷贝。

这里注意：A类中含有引用类型的B对象，B类中含有引用类型的C对象，那么在深拷贝的时候，如果只去重写A类的clone()方法，而B和C仍然是使用的默认clone方法，那么这样还是不完全的深拷贝，因为克隆之后的A和原型A使用的B对象虽然不同，但是两个B对象其中的C对象仍然是同一份。所以为了实现完全深拷贝，需要重写B的clone方法和C的clone方法。也就是说，需要一层一层去重写clone方法才能够实现全部深拷贝

4.2.2 实现深拷贝的第二种方式

直接使用序列化和反序列化来实现

// 通过对象的序列化实现深拷贝
public class Client4 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("deep.class"));
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("deep.class"));

        ArrayList<Grass> list = new ArrayList<>();
        list.add(new Grass("green", "mengu"));
        DeepClass deepClass = new DeepClass("张子枫", new Sheep("tom", 1, "白色", list));
        // 序列化
        objectOutputStream.writeObject(deepClass);
        // 反序列化
        DeepClass deepClass1 = (DeepClass) objectInputStream.readObject();
        // 比较地址、成员的地址是否相同
        System.out.println(deepClass.hashCode() == deepClass1.hashCode());
        System.out.println(deepClass == deepClass1);
        System.out.println(deepClass.getSheep().hashCode() == deepClass1.getSheep().hashCode());
        System.out.println(deepClass.getSheep().getList().hashCode() == deepClass1.getSheep().getList().hashCode());

        objectInputStream.close();
        objectOutputStream.close();
    }
}

这是直线深拷贝的最直接的模式，不用一层一层地重写clone()方法，推荐使用

5. 结论

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
不用重新初始化对象，而是动态地获得对象运行时的状态
如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
在实现深克隆的时候可能需要比较复杂的代码
缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则