<span>原型模式</span>

 

一、原型模式的作用？

1、基本就是你需要从A的实例得到一份与A内容相同，但是又互不干扰的实例的话，就需要使用原型模式。

2、用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这个其实和C++的拷贝构造函数的作用是相似的（但不相同），实际上就是动态抽取 当前对象 运行时 的 状态。

3、当然有的时候，如果我们并不需要基于现有的对象复制新的对象，或者我们需要的就是一个干净的空对象，那么我的首先还是工厂模式或者抽象工厂模式。

二、为什么需要原型模式？

1、为什么不用new直接新建对象，而要用原型模式？

首先，用new新建对象不能获取当前对象运行时的状态，其次就算new了新对象，在将当前对象的值复制给新对象，效率也不如原型模式高。

2、为什么不直接使用拷贝构造函数，而要使用原型模式？

原型模式与拷贝构造函数是不同的概念，拷贝构造函数涉及的类是已知的，原型模式涉及的类可以是未知的（基类的拷贝构造函数只能复制得到基类的对象）。

原型模式生成的新对象可能是一个派生类。拷贝构造函数生成的新对象只能是类本身。原型模式是描述了一个通用方法(或概念)，它不管是如何实现的，而拷贝构造则是描述了一个具体实现方法。

三、使用场景

1、资源优化场景

类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

2、性能和安全要求的场景

通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

3、一个对象多个修改者的场景

一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

4、结合使用

在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与Java融为浑然一体，大家可以随手拿来使用。

四、缺点

1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。

2、实现原型模式每个派生类都必须实现 Clone接口。

3、逃避构造函数的约束。

1.前言

---

单例模式可以避免重复创建消耗资源的对象，但是却不得不共用对象。若是对象本身也不让随意访问修改时，怎么办？通常做法是备份到副本，其它对象操作副本，最后获取权限合并，类似git上的PR操作。

2.概念

---

原型模式用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。需要注意的关键字是，新的对象，类没变。Java正好提供了Cloneable接口，它标识的类可以调用Object中实现的clone()方法而不抛出异常，即运行时通知虚拟机可以安全使用clone()方法返回拷贝对象。由于它直接操作内存中的二进制流，当大量操作或操作复杂对象时，性能优势将会很明显。

3.场景

---

动物园中有一只羊，对它进行克隆，产生另外一只完全一样的羊，分别安排两位有孩子的管理员照顾。有一天，对克隆羊进行基因操作，观察变化。

4.写法

// 1.声明此类可以被clone public class Sheep implements Cloneable { private int age; private String sex; private Admin admin; public Sheep(int age, String sex, Admin admin) { super(); this.age = age; this.sex = sex; this.admin = admin; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Admin getAdmin() { return admin; } public void setAdmin(Admin admin) { this.admin = admin; } @Override public String toString() { return "Sheep [age=" + age + ", sex=" + sex + ", admin=" + admin + "]"; } // 2.调用Object的clone方法 public Sheep startClone() { Sheep sheep = null; try { sheep = (Sheep) super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return sheep; } } 

public class Admin { private int age; private String sex; private Child child; public Admin(int age, String sex, Child child) { super(); this.age = age; this.sex = sex; this.child = child; } public void setAge(int age) { this.age = age; } public void setSex(String sex) { this.sex = sex; } public void setChild(Child child) { this.child = child; } @Override public String toString() { return "Admin [age=" + age + ", sex=" + sex + ", child=" + child + "]"; } } 

public class Child { } 

public class Zoo { public static void main(String[] args) { Sheep old = new Sheep(2, "雄性", new Admin(25, "女", new Child())); System.out.println(old.toString()); Sheep current = old.startClone(); System.out.println(current.toString()); // 对克隆羊做处理 current.setAge(1); current.setSex("雌性"); current.getAdmin().setAge(34); current.getAdmin().setSex("男"); System.out.println(old.toString()); System.out.println(current.toString()); } } 

根据上面的代码，我们知道羊引用了管理员，管理员引用了孩子。当对内存中数据拷贝时，除了基本数据类型（包括封装类型）及String类型，其它的引用关系将直接传递给副本，并不是重新创建一个对象。所以当对克隆羊操作时，年龄和性别直接改变，而对管理员的操作将寻址到内存中对应部分进行修改，导致原型也被修改。孩子与管理员的关系就如同管理员与羊，通过哈希值可以知道，孩子始终就一个，没有拷贝成功。

上面的错误是由于只拷贝了最外层对象的原因，我们称之为浅拷贝。为了解决这个问题，需要对内部的引用类型进行拷贝（Java中大部分引用类型实现了Cloneable接口，可以方便的拷贝），具体如下：

// 1.声明此类可以被clone public class Sheep implements Cloneable { // 前面省略 // 2.调用Object的clone方法 public Sheep startClone() { Sheep sheep = null; try { sheep = (Sheep) super.clone(); // 3.调用Admin的clone方法 sheep.admin = this.admin.startClone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return sheep; } } 

public class Admin implements Cloneable { // 前面省略 public Admin startClone() { Admin admin = null; try { admin = (Admin) super.clone(); admin.child = this.child.startClone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return admin; } } 

public class Child implements Cloneable { public Child startClone() { Child child = null; try { child = (Child) super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return child; } } 

通过日志的打印，发现这种方式（深拷贝）起作用了。由1、2行可以知道，拷贝时引用类型已经重新创建了对象。由3、4行可以知道，修改其中一个对象不会再改变另一个了。

5.总结

---

原型模式通过Object的clone()方法实现，由于是内存操作，即二进制流的形式，无视构造方法和访问权限，直接获取新的对象。但对于引用类型，需使用深拷贝，其它浅拷贝即可。

（1）浅拷贝：直接使用Object类的native本地clone方法，该方法是基于二进制形式拷贝的，前提是被拷贝的类必须实现了标记型接口Cloneable。

（2）深拷贝：举例说明，A类中有B类对象引用属性，B类中有C类对象的引用属性，C类里面的属性全是基本类型（String也是基本类型）。如果想要深拷贝A类对象，那么要求A类中的B类对象引用属性也需要深拷贝一次，B类中C类对象引用属性也需要深拷贝一次。因此需要层层递归深拷贝，每一层都是深拷贝，除非是没有引用属性的类。所有引用属性都需要在clone方法中单独深拷贝一次。每层都需要实现深拷贝，即每层都实现了Cloneable接口和覆写了clone方法。

#############################################################################################################################

深拷贝举例。

----------------------------------------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------------------------------------------------