【设计模式】Java设计模式精讲之原型模式

简单记录 - 慕课网 Java设计模式精讲 Debug方式+内存分析 & 设计模式之禅-秦小波

文章目录

• 1、原型模式的定义
• 原型-定义
• 原型-类型
• 2、原型模式的实现
• 原型模式的通用类图
• 原型模式通用源码
• 3、原型模式的使用场合
• 4、原型模式的应用
• 原型模式-优点
• 原型-缺点
• 原型模式的注意事项
• 构造函数不会被执行
• 浅拷贝和深拷贝
• clone与final两个冤家
• 原型-扩展
• 5、设计原则
• 6、最佳实践
• 7、总结

原型模式（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关键字。