设计模式-05-原型模式

背景
原型模式
浅拷贝和深拷贝
- 1、浅拷贝介绍
- 2、深拷贝介绍
原型模式注意事项

背景

如果我们要创建多个对象，传统方式如下：

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());
Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());

传统方式的优缺点
易于理解，容易操作
在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
总是需要初始化对象，而不是动态的活动对象运行时的状态，灵活性差
改进思路
Java 中 Object 类是所有类的根类，Object 类提供了一个 clone()方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的Java 类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力 =>原型模式

原型模式

什么是原型模式

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

原型模式UML

首先，说一下Prototype，Prototype是一个原型类，声明一个克隆自己的接口；
其次， ConcretePrototype是具体的原型类, 实现一个克隆自己的操作；
最后， Client: 让一个原型对象克隆自己，从而创建一个新的对象(属性一样）

改进
```java public class Sheep {

private String name; private int age; private String color;

public Sheep(String name, int age, String color) { super(); this.name = name; this.age = age; this.color = color; } //getter and setter 方法 //… //克隆该实例，使用默认的clone方法来完成 @Override protected Object clone() {

Sheep sheep = null; try { sheep = (Sheep) super.clone();//super.clone()返回Object对象 } catch (CloneNotSupportedException e) { e.printStackTrace(); } return sheep; }

}

调用
```java
public static void main(String[] args) {
   System.out.println("原型模式完成对象的创建");
   Sheep sheep = new Sheep("tom", 1, "白色");
   Sheep sheep2 = (Sheep)sheep.clone(); //克隆
   Sheep sheep3 = (Sheep)sheep.clone(); //克隆
   Sheep sheep4 = (Sheep)sheep.clone(); //克隆
   Sheep sheep5 = (Sheep)sheep.clone(); //克隆
   }
}

浅拷贝和深拷贝

1、浅拷贝介绍

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

2、深拷贝介绍
复制对象的所有基本数据类型的成员变量值
为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝

深拷贝实现方式 1：重写 clone 方法来实现深拷贝

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();
   }
}

public class DeepProtoType implements Serializable, Cloneable{

   public String name; //String 属性
   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：通过对象序列化实现深拷贝(推荐)

//深拷贝 - 方式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());
      }
   }

}

//方式2 完成深拷贝
DeepProtoType p2 = (DeepProtoType) p.deepClone();

System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());

原型模式注意事项

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。
不用重新初始化对象，而是动态的获得对象运行时的状态
如果原始对象发生了变化（增加或减少属性），其他克隆对象的属性也会发生响应变化，而无需修改代码
在实现深克隆时可能需要较复杂代码

缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则

背景

原型模式

什么是原型模式

原型模式UML

改进

浅拷贝和深拷贝

1、浅拷贝介绍

2、深拷贝介绍

原型模式注意事项