原型模式

最新推荐文章于 2025-07-28 17:30:49 发布

vivismiledddd

最新推荐文章于 2025-07-28 17:30:49 发布

阅读量93

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签： java 设计模式

本文链接：https://blog.youkuaiyun.com/foozhe2000/article/details/84166800

设计模式专栏收录该内容

2 篇文章

订阅专栏

本文从以下三个方面来浅析原型模式：

1 解决的问题，应用场景

2 实现的原理

3 浅表复制和深表复制

4 它的优点和缺陷

5 总结

1 解决什么问题：

　它主要面对的问题是：“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象又经常面临着剧烈的变化。这时，重新new对象很耗费资源，也影响性能。因此，此时用原型模式更好解决。

应用场景：

a: 通过new一个对象需要非常繁琐的数据准备或者访问权限，此时可用原型模式。

b: 一个对象需要多次修改。

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

注：这三点是从另外摘抄的，原型模式主要解决的也是此类问题。

2 实现的原理：

原型模式也是一种创建型模式，它允许一个对象再创建另外一个可以定制的对象，根本无需知道任何创建的细节。通俗点的讲，应该就是复制。

通过implements Cloneable这个接口，用super.clone()克隆对象。

简单代码示例：

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

（说明：由于笔者是初学设计模式，开发经验有限，对于要举出满足上述应用场景复杂例子还一时无能为力，因此，在此从简的举例简单说明了下原型模式的实现，与初学者共享！）

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

应用场景举例：我们电脑上自带的画图板的工具选择框ToolBar功能，它的设计就很可能是Prototype模式（虽然不用这个模式也完全能实现）。工具条上的每一个按钮都是一个对象，开始，程序先登记每个对象存放在对象池中，然后，每点击一个按钮就克隆一个该按钮的对象模式，实现它的功能。

//原型模式范例
public class PrototypeDemo {

	public static void main(String[] args) {
		new PrototypeDemo().test();
	}
	
	//测试方法
	public void test() {
		//实例化一个圆
		Circle circle = new Circle();
		//克隆一个圆对象
		Circle KelongCir = (Circle) circle.CloneObject();
		KelongCir.Draw();//用克隆对象来画图
	}
}

//该接口继承Cloneable接口
interface prototype extends Cloneable {//注意：该接口中没有必须要实现的方法
	public Object CloneObject();
	public void Draw();//画图的方法
}


//定义圆。
class Circle implements prototype {

	@Override
	public Object CloneObject() {
		Object clone=null;
		try {
			//注意：根据api，因为Object类并没有实现Cloneable接口，因此类若没有实现Cloneable,在它的对象上
			//调用clone（）方法则会抛出异常。
			//克隆对象，注意此处！！！！！clone是父类Object的方法，为什么克隆出来的不是Object对象而是当前对象呢？
			//分析在下面
			clone=super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return clone;//返回克隆对象
	}
	
	@Override
	public void Draw() {
		System.out.println("画圆形");	
	}
	
}

打印“画圆形”。

代码的部分解析：

1 为什么用super.clone()克隆出的不是Object对象而是当前对象？

原因：Object中的Clone()执行时使用了java的RTTI(运行时加载？)机制，动态的找到正在调用clone()方法的那个reference.根据它的大小申请内存空间，然后进行bitwise复制，将该对象的内存空间完全复制到新空间中去，从而达到浅表复制（何谓浅表复制，如下）的目的。

3 浅表复制和深表复制

浅表复制：父类与子类共用一个引用对象，如果父类包含的子引用对象发生改变，则这个变化也回同时出现在它的浅表复制的克隆对象中。

引用一张网上出现的很经典的图：

深表复制：父类和子类分别拥有自己的子引用对象，子引用对象也是由父类的子引用对象复制过来的。即如果父类包含的子引用对象发生改变，该改变不会出现在它的浅表复制的克隆对象中。

说明两者区别的代码：

//原型模式范例
public class PrototypeDemo {
	
	public static void main(String[] args) {
		Lay1 obj1 = new Lay1();
		obj1.lay2 = new Lay2();
		obj1.x=1;
		obj1.lay2.y=1;
		Lay1 obj2 =(Lay1) obj1.Clone();
		obj2.x = 2;
		obj2.lay2.y = 2;
		System.out.println("obj1.x="+obj1.x+"    "+"obj1.lay2.y="+obj1.lay2.y);
		System.out.println("obj2.x="+obj2.x+"    "+"obj2.lay2.y="+obj2.lay2.y);
	}
}

class Lay1 implements Cloneable {
	public int x;
	public Lay2 lay2;
	public Object Clone() {
		Object clone = null;
		try {
			clone=super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return clone;
	}
}

class Lay2 implements Cloneable {
	public int y;
	public Object Clone() {
		Object clone = null;
		try {
			clone = super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return clone;
	}
}

打印：

obj1.x=1 obj1.lay2.y=2
obj2.x=2 obj2.lay2.y=2

注意：

super.clone()实现的是浅表复制。深层复制需要我们自己实现，可能需要编写复杂的代码。

深表复制的实现两种方法：

1 自己实现。方法如下：

class Lay1 implements Cloneable {
	public int x;
	public Lay2 lay2;
	public Object Clone() {
		Object clone = null;
		try {
			clone=super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		((Lay1)clone).lay2 = (Lay2)this.lay2.Clone();//Lay1的克隆对象的lay2指向源对象的lay2的克隆对象
		return clone;
	}
}

2 利用序列化来实现：详情请见http://blog.youkuaiyun.com/jack0511/article/details/3582562。

这两种方法的异同：前者自己在实现深层复制时可能需要编写复杂的代码（此处简化了），后者只用实现序列化，看似简单，但它的内部也经过了复杂的处理过程。

4 优点和缺陷。

优点：当在创建对象成本太高的情况下（即初始化会占用较长时间，占用太多的cpu资源或网络资源），而这个对象又需要重复使用，这种情况下，新的对象可以通过原型模式对已有对象的属性进行复制并稍作修改来获得。

缺点：自己实现深层复制需要编写复杂的代码。

5 总结：

a)浅层复制和深层复制的不同在于对象和克隆对象对引用变量的拥有不同。前者共同拥有，即复制的只是内存地址，指向的堆中的同一个对象。后者分别拥有的引用变量，即克隆时同时克隆了引用，两个引用指向堆中的两个对象。

b)super.clone()实现的是浅层复制。

c)序列化可以实现深层复制。我们的写入到流里面的是对象的拷贝，原对象仍存在于JVM里面。Java中深克隆一个对象，可以实现Serializable接口，然后把对象的拷贝写到流里，再从流里读回来，就可以重建对象。一般的变量类型都实现了Serializable接口，如String/File文件等，我们自定义的对象在写入流里面时则需要实现序列化，以保证网络传输的安全可靠。

附：Serilizable的作用：

1 可以永久的保存对象到文件中。因为一般对象只存在程序的运行周期内，最迟到运行结束就自动回收了。要想在下一次运行时取得上次运行时的某一对象，则只需把该对象序列化即可。

2 保证对象在网络上的可靠传输。

附：

为保知识产权，附上连接：http://www.cnblogs.com/hjqxaly/archive/2010/09/09/1822460.html。