「这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战」

原型设计模式

1.原型设计模式的理解

原型模式是一种创建型模式，用已有的原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。通常用于创建重复的对象，且保证性能。原型模式主要是通过克隆方法实现的，克隆主要分为浅克隆（浅拷贝）、深克隆（深拷贝）。

2.克隆 --- 浅拷贝与深拷贝

2.1 浅拷贝

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

2.2深拷贝

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

3.uml类图

图片.png

-原理结构图说明

Prototype : 原型类，声明一个克隆自己的接口
ConcretePrototype: 具体的原型类, 实现一个克隆自己的操作
Client: 让一个原型对象克隆自己，从而创建一个新的对象(属性一样)

4.传统情况--复制对象

以下类均省略有参无参和get，set方法

public class Sheep {
   private String name;
   private int age;
   private String color;
}


public static void main(String[] args) {
   // TODO Auto-generated method stub
   //传统的方法
   Sheep sheep = new Sheep("tom", 1, "白色");
   
   Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
   Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
   //....
}

缺点：这种方式，效率低，当需要复制对象特别多时，代码量还比较大。且对于引用的对象，数据等类型数据，要想实现深拷贝，代码较复杂。

5.原型模式 -- 浅拷贝

1.浅拷贝，对象只需要实现 Cloneable 接口，使用Object 默认的对象继承方法即可

public class Sheep implements Cloneable {
   private String name;
   private int age;
   private String color;
   private String address = "蒙古羊";
   public Sheep friend;
   
    @Override
   public String toString() {
      return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
   }
   //克隆该实例，使用默认的clone方法来完成
   @Override
   protected Sheep clone()  {
      Sheep sheep = null;
      try {
         sheep = (Sheep)super.clone();
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      return sheep;
   }
   
   
}

测试类

public static void main(String[] args) {

   Sheep sheep = new Sheep("tom", 1, "白色");
   
   sheep.friend = new Sheep("jack", 2, "黑色");
   
   Sheep sheep2 = (Sheep)sheep.clone(); //克隆
   Sheep sheep3 = (Sheep)sheep.clone(); //克隆

   //sheep2 :Sheep [name=tom, age=1, color=白色, address=蒙古羊]  sheep2.friend:1807837413
   System.out.println("sheep2 :" + sheep2 + "  sheep2.friend:" + sheep2.friend.hashCode());
   //                false                       sheep3.friend:1807837413
   System.out.println((sheep == sheep3) + "  sheep3.friend:" + sheep3.friend.hashCode());
}

我们可以看到，两个对象确实不相等，但他们的引用类型变量指向的是同一个对象实例。这就是前面我们说的浅拷贝的特性。

6.原型模式 -- 深拷贝

6.1 深拷贝 -- 重写clone方法

public class DeepProtoType implements Cloneable{
   
   public String name; //String 属性
   // 引用类型，这里引用类型如果属性包含引用类型属性，要想实现完全深度克隆，它也要实现Cloneable接口，重写clone方法
   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();
      
      // TODO Auto-generated method stub
      return deepProtoType;
   }
}

这种方式虽然可以达到深拷贝的效果，在对象中引用类型属性过多，或引用类型属性中又包含引用类型的情况下，一般不推荐使用这种方式。

6.2 深拷贝 -- 序列化方式（推荐）

public class DeepProtoType implements Serializable{
   
   public String name; //String 属性
   //DeepCloneableTarget也要实现 Serializable接口，否则会报java.io.NotSerializableException
   public DeepCloneableTarget deepCloneableTarget;// 引用类型
   public DeepProtoType() {
      super();
   }
   
   //深拷贝 - 方式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) {
         // TODO: handle exception
         e.printStackTrace();
         return null;
      } finally {
         //关闭流
         try {
            bos.close();
            oos.close();
            bis.close();
            ois.close();
         } catch (Exception e2) {
            // TODO: handle exception
            System.out.println(e2.getMessage());
         }
      }
      
   }
   
}

这种深度克隆，需要该类和其属性类都实现，Serializable接口

7.总结

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

java设计模式 --- 原型模式