简单记录 - 慕课网 Java设计模式精讲 Debug方式+内存分析 & 设计模式之禅-秦小波
文章目录
原型模式（Prototype Pattern）的简单程度仅次于单例模式和迭代器模式。正是由于简单，使用的场景才非常地多。原型模式是创建型模式，创建型模式一般用来创建一个新的对象，然后使用这个对象完成一些对象的操作，我们通过原型模式可以快速地创建一个对象而不需要提供专门的new()操作，这无疑是一种非常有效的方式，可以快速地创建一个新的对象。
1、原型模式的定义
原型-定义
定义：
指原型实例指定创建对象的种类，并且通过拷贝(复制)这些原型创建新的对象。
不需要知道任何创建的细节，不调用构造函数。
Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.
原型-类型
类型：创建型模式-原型模式
原型模式的最大的特点就是克隆一个现有的对象，这个克隆的结果有两种，一种是浅复制，另一种是深复制。
比其他的简单多，那怎么用好它，这是个问题。
2、原型模式的实现
原型模式的通用类图
原型模式的通用类图
实线箭头 关联关系
三角空心实线 泛化（继承）关系
原型模式的核心是一个clone方法，通过该方法进行对象的拷贝（复制），Java提供了一个Cloneable接口来标示这个对象是可拷贝的，为什么说是“标示”呢？
翻开JDK的帮助看看Cloneable是一个方法都没有的，这个接口只是一个标记作用，在JVM中具有这个标记的对象才有可能被拷贝。
那怎么才能从“有可能被拷贝”转换为“可以被拷贝”呢？方法是覆盖clone()方法，重写clone()方法。
在clone()方法上增加了一个注解@Override，没有继承一个类为什么可以覆写呢？
在Java中所有类的老祖宗是谁？是Object类，每个类默认都是继承了这个类，所以用覆写是非常正确的——覆写了Object类中的clone方法！在Java中原型模式是如此简单的。那到底如何实现呢？
原型模式通用源码
PrototypeClass.java
/**
* 原型模式通用代码
*/
public class PrototypeClass implements Cloneable{
//覆写父类Object方法
@Override
public PrototypeClass clone(){
PrototypeClass prototypeClass = null;
try {
prototypeClass = (PrototypeClass)super.clone();
} catch (CloneNotSupportedException e) {
//异常处理
}
return prototypeClass;
}
}
实现一个接口Cloneable，然后重写clone方法，就完成了原型模式！
3、原型模式的使用场合
原型模式的适用场景 适合什么场景用
- 类初始化消耗较多资源
- new产生的一个对象需要非常繁琐得过程（数据准备、访问权限等）
- 构造函数比较复杂
- 循环体中生产大量对象时
原型模式的使用场景 想用原型模式时的场景
- 资源优化场景
类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
- 性能和安全要求的场景
通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
简化创建过程
- 一个对象多个修改者的场景
一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与Java融为一体，我们可以随手拿来使用。
4、原型模式的应用
原型模式-优点
原型模式-优点
- 性能优良
原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。（原型模式性能比直接new一个对象性能高）
- 逃避构造函数的约束
这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的。优点就是减少了约束，缺点也是减少了约束，使用需要在实际应用时考虑。
原型模式性能比直接new一个对象性能高
简化创建过程
原型-缺点
缺点
- 必须配备克隆方法
重写
- 对克隆复杂对象或克隆出的对象进行复杂改造时，容易引入风险
- 深拷贝、浅拷贝要运用得当
很多坑
原型模式的注意事项
原型模式clone方法的有一些注意事项的。
构造函数不会被执行
一个实现了Cloneable并重写了clone方法的类A，有一个无参构造或有参构造B（B是构造函数），通过new关键字产生了一个对象S，再然后通过S.clone()方式产生了一个新的对象T，那么在对象拷贝时构造函数B是不会被执行的。 即对象拷贝时不会执行构造函数的。
一小段程序来说明这个问题，如代码所示。
代码简单的可拷贝对象 Thing.java
/**
* 万物
*/
public class Thing implements Cloneable{
public Thing(){
System.out.println("构造函数被执行了...");
}
@Override
public Thing clone(){
Thing thing=null;
try {
thing = (Thing)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return thing;
}
}
然后我们再来写一个Client类，进行对象的拷贝，如代码所示。
简单的场景类 Client.java
/**
* Client
*/
public class Client {
public static void main(String[] args) {
//产生一个对象
Thing thing = new Thing();
//拷贝一个对象
Thing cloneThing = thing.clone();
}
}
运行结果如下所示：
构造函数被执行了...
Process finished with exit code 0
这个创建对象
//产生一个对象 Thing thing = new Thing();
执行了一次构造函数
对象拷贝时构造函数确实没有被执行，这点从原理来讲也是可以讲得通的，Object类的clone方法的原理是从内存中（具体地说就是堆内存）以二进制流的方式进行拷贝，重新分配一个内存块，那构造函数没有被执行也是非常正常的了。
浅拷贝和深拷贝
在解释什么是浅拷贝和什么是深拷贝之前，先来看个例子，如代码所示。
浅拷贝
/**
* 万物
*/
public class Thing implements Cloneable{
//定义一个私有变量
private ArrayList<String> arrayList = new ArrayList<String>();
@Override
public Thing clone(){
Thing thing=null;
try {
thing = (Thing)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return thing;
}
//设置HashMap的值
public void setValue(String value){
this.arrayList.add(value);
}
//取得arrayList的值
public ArrayList<String> getValue(){
return this.arrayList;
}
}
在Thing类中增加一个私有变量arrayList，类型为ArrayList，然后通过setValue和getValue分别进行设置和取值，我们来看场景类是如何拷贝的，
如代码清单所示。 浅拷贝测试
/**
* 场景类
*/
public class Client {
public static void main(String[] args) {
//产生一个对象
Thing thing = new Thing();
//设置一个值
thing.setValue("张三");
//拷贝一个对象
Thing cloneThing = thing.clone();
cloneThing.setValue("李四");
System.out.println(thing.getValue());
}
}
猜想一下运行结果应该是什么？是仅一个“张三”吗？
运行结果如下所示：[张三，李四]
怎么会这样呢？怎么会有李四呢？是因为Java做了一个偷懒的拷贝动作，Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝。
确实是非常浅，两个对象共享了一个私有变量，你改我改大家都能改，是一种非常不安全的方式，在实际项目中使用还是比较少的（当然，这也是一种“危机”环境的一种救命方式）。
你可能会比较奇怪，为什么在Mail那个类中就可以使用String类型，而不会产生由浅拷贝带来的问题呢？内部的数组和引用对象才不拷贝，其他的原始类型比如int、long、char等都会被拷贝，但是对于String类型，Java就希望你把它认为是基本类型，它是没有clone方法的，处理机制也比较特殊，通过字符串池（stringpool）在需要的时候才在内存中创建新的字符串，读者在使用的时候就把String当做基本类使用即可。
注意 使用原型模式时，引用的成员变量必须满足两个条件才不会被拷贝：一是类的成员变量，而不是方法内变量；二是必须是一个可变的引用对象，而不是一个原始类型或不可变对象。浅拷贝是有风险的，那怎么才能深入地拷贝呢？我们修改一下程序就可以深拷贝，如代码所示。
代码 深拷贝
/**
* 万物
*/
public class Thing implements Cloneable{
//定义一个私有变量
private ArrayList<String> arrayList = new ArrayList<String>();
@Override
public Thing clone(){
Thing thing=null;
try {
thing = (Thing)super.clone();
thing.arrayList =(ArrayList<String>)this.arrayList.clone();//深拷贝
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return thing;
}
//设置HashMap的值
public void setValue(String value){
this.arrayList.add(value);
}
//取得arrayList的值
public ArrayList<String> getValue(){
return this.arrayList;
}
}
仅仅增加了thing.arrayList =(ArrayList<String>)this.arrayList.clone();//深拷贝，对私有的类变量进行独立的拷贝。Client类没有任何改变，
运行结果如下所示：[张三]该方法就实现了完全的拷贝，两个对象之间没有任何的瓜葛了，你修改你的，我修改我的，不相互影响，这种拷贝就叫做深拷贝。深拷贝还有一种实现方式就是通过自己写二进制流来操作对象，然后实现对象的深拷贝，有时间实现一下。
注意: 深拷贝和浅拷贝建议不要混合使用，特别是在涉及类的继承时，父类有多个引用的情况就非常复杂，建议的方案是深拷贝和浅拷贝分开实现。
clone与final两个冤家
对象的clone与对象内的final关键字是有冲突的，我们举例来说明这个问题，如代码所示。
代码 增加final关键字的拷贝
**
* 万物
*/
public class Thing implements Cloneable{
//定义一个私有变量
private final ArrayList<String> arrayList = new ArrayList<String>();
@Override
public Thing clone(){
Thing thing=null;
try {
thing = (Thing)super.clone();
this.arrayList = (ArrayList<String>)this.arrayList.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return thing;
}
//设置HashMap的值
public void setValue(String value){
this.arrayList.add(value);
}
//取得arrayList的值
public ArrayList<String> getValue(){
return this.arrayList;
}
}
粗体部分仅仅增加了一个final关键字，然后编译器就报斜体部分错误，正常呀，final类型你还想重赋值呀！你要实现深拷贝的梦想在final关键字的威胁下破灭了，路总是有的，我们来想想怎么修改这个方法：删除掉final关键字，这是最便捷、安全、快速的方式。你要使用clone方法，在类的成员变量上就不要增加final关键字。注意 要使用clone方法，类的成员变量上不要增加final关键字。这个代码去掉final就可以运行了
原型-扩展
扩展
- 深克隆
- 浅克隆
Coding
源码解析
克隆
扩展：Java SDK中的原型模式其实，在上面的例子中，我们就已经在使用JDK中的原型设计模式了。Object类是所有类的超类，子类可以重载Object类的clone方法克隆对象，但是必须记得一定要实现Cloneable接口才行，因为只有实现该接口的对象才能被复制。Object类的原型模式如图所示。
5、设计原则
原型模式的核心是一个clone方法，通过这个方法进行对象的复制，在Java中，提供了一个Cloneable接口来标示这个对象是可复制的，为什么说是“标示”呢？查看Cloneable类源码，会发现，Cloneable接口中一个方法都没有，这个接口的作用就是一个标示，只有实现该接口的对象才有可能被复制！到这里你可能又要问了，那又如何从“有可能被复制”变为“可以被复制”呢？方法就是覆盖超类的clone()方法！
原型设计模式的原则还是在解耦上。我们在类的交互中可以不把类名塞到源文件中，那样类将耦合在一起，达不到类复用的作用。当然，必须紧密结合在一起的类是应当将类名写到一起的，以增加系统的高内聚性，而那些应该独立成组件的类，则应当被分离出来。
6、最佳实践
原型模式先产生出一个包含大量共有信息的类，然后可以拷贝出副本，修正细节信息，建立了一个完整的个性对象。原型模式也就是由一个正本可以创建多个副本的概念。可以这样理解：一个对象的产生可以不由零起步，直接从一个已经具备一定雏形的对象克隆，然后再修改为生产需要的对象。
7、总结
1.原型模式
用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
2.注意事项
（1）克隆对象时，原始对象的构造方法不被执行。
（2）浅复制：浅复制只是复制本对象的原始数据类型，如int、float、String等，对于数组和对象引用等是不会复制的。因此，浅复制是有风险的。
（3）深复制：不但对原始数据类型做复制，对于对象中的数组和对象引用也做复制的行为，从而达到将对象完全复制的效果。
3.设计原则
（1）考虑产生对象的复杂度和类复用；
（2）结合系统结构考虑使用浅复制还是深复制。
4.使用场合
（1）产生对象过程比较复杂，初始化需要许多资源时；
（2）希望框架原型和产生对象分开时；
（3）同一个对象可能会供其他调用者同时调用访问时。
原型模式(Proxy Pattern)
定义：Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype. 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式的通用类图如下图：
原型模式的核心是一个clone方法，通过该方法进行对象的拷贝，Java提供了一个Cloneable接口来标示这个对象是可拷贝的，为什么说是“标示”呢？翻开JDK的帮助看看Cloneable是一个方法都没有的，这个接口只是一个标记作用，在JVM中具有这个标记的对象才有可能被拷贝，那怎么才能从“有可能被拷贝”转换为“可以被拷贝”呢？方法是覆盖clone()方法。实现一个接口，然后重写clone方法，就完成了原型模式！
原型模式的应用
1.原型模式的优点
- 性能优良。原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好的体现其优点。
- 逃避构造函数的约束。这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的（见“原型模式的注意事项”），优点就是减少了约束，缺点也是减少了约束，双刃剑，需要大家在实际应用时考虑。
2.原型模式的使用场景
- 资源优化场景。类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
- 性能和安全要求的场景。通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
- 一个对象多个修改者的场景。一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与Java融为浑然一体，大家可以随手拿来使用。
原型模式的注意事项
- 构造函数不会被执行。
- 浅拷贝和深拷贝。Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，确实是非常浅，两个对象共享了一个私有变量，你改我改大家都能改，是一种非常不安全的方式，在实际项目中使用还是比较少的（当然，这是也是一种“危机”环境的一种救命方式）。内部的数组和引用对象才不拷贝，其他的原始类型比如int,long,String(Java就希望你把String认为是基本类型，String是没有clone方法的)等都会被拷贝的。(注意：使用clone方法拷贝时，满足两个条件的对象才不会被拷贝：一是类的成员变量，而不是方法内的变量；二是必须是一个对象，而不是一个原始类型)
- clone与final两对冤家。对象的clone与对象内的final关键字是有冲突的。要使用clone方法，类的成员变量上不要增加final关键字。