Java设计模式--原型模式

原型模式

用原型实例制定创建对象的种类，并且通过复制这些原型创建新的对象。

Prototype Pattern

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

类图

模式的结构与使用

原型方法模式的结构中包括两种角色。

  • 抽象原型（Abstract Prototype）：是一个接口，负责定义对象复制自身的方法。
  • 具体原型（Concrete Prototype）：实现Prototype接口的类。具体原型实现抽象原型中的方法，以便所创建的对象调用该方法复制自己。

克隆方法

理解深克隆和浅克隆

  • 1：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
  • 2：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

clone()方法

java.lang包中的Object类提供了一个权限是protected的用于复制对象的clone()的方法。我们知道Java中所有的类都是java.lang包中Object类的子类或者间接子类，因此Java中所有的类都继承这个clone()方法，但是由于clone()方法的访问权限是protected的，这就意味着，如果一个对象想使用该方法得到自己的一个复制品，就必须保证自己所在的类与Object类在同一个包中，这显然是不可能的，因为Java不允许用户编写的类拥有java.lang这样的包名（尽管可以编译拥有java.lang包名的类，但允许时JVM拒绝加载这样的类）。

clone()方法的重写与Cloneable接口

为了能让一个对象使用clone()方法，创建该对象的类可以重写(覆盖)clone()方法，并将访问权限提高为public权限，为了能使用被覆盖的clone()方法，只需在重写的clone()方法中使用关键字super调用Object类的clone()方法即可。也可以在创建对象的类中新定义一个复制对象的方法，将访问权限定义为public，并在该方法中调用Object类的clone()方法。
另外，当对象调用Object类中的clone()方法时，JVM将会逐个复制该对象的成员变量，然后创建一个新对象返回，所以JVM要求调用clone()方法的对象必须实现Cloneable接口。Cloneable接口中没有任何方法，该接口的唯一作用就是让JVM知道实现该接口的对象是可以被克隆的。

下面Circle类的对象使用clone方法克隆自己的CloneExample.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package Prototype;
class Circle implements Cloneable {
	private double radius;
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public Object clone() throws CloneNotSupportedException {
		Object object = super.clone();
		return object;
	}
}
public class CloneExample {
	public static void main(String[] args) {
		Circle circle = new Circle();
		circle.setRadius(198.99);
		try {
			Circle circleCopy = (Circle) circle.clone();
			System.out.println("circle对象中的数据：" + circle.getRadius());
			System.out.println("circleCopy对象中的数据：" + circleCopy.getRadius());
			circle.setRadius(200);
			System.out.println("circle对象中的数据：" + circle.getRadius());
			System.out.println("circleCopy对象中的数据：" + circleCopy.getRadius());
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

深度克隆

Object类中的clone()方法将复制当前对象变量中的值来创建一个新对象，例如，一个对象Object有两个int型的成员变量x、y，那么该对象a与它调用clone()方法返回的cloneObject对象如图所示。

需要注意的是，如果调用clone()方法的当前对象拥有的成员变量是一个对象，那么clone()方法仅仅复制了当前对象所拥有的对象的引用，并没有复制这个对象所拥有的变量，这就是使clone()方法返回的新对象和当前对象拥有一个相同的对象，未能实现完全意义的复制。例如一个对象Object有两个变量rectangle和height，其中height是int型变量，但是变量rectangle是一个对象，这个对象rectangle有两个double型的变量m、n，那么对象object与它调用clone()方法返回的cloneObject对象如图所示。

这样一来就涉及一个深度克隆问题，因为，当前对象的成员变量中可能还会有其他对象。所以使用clone()方法复制对象有许多细节问题需要考虑，比如，在重写clone()方法时，必须也要对当前对象中的rectangle对象进行复制。下面DeepCloneExample使用clone()方法克隆自己并处理了深度克隆的问题。

注释掉了处理深度克隆的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package Prototype;
class Geometry implements Cloneable {
	int height;
	Rectangle rectangle;
	public Geometry(int height, Rectangle rectangle) {
		this.height = height;
		this.rectangle = rectangle;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Geometry object = (Geometry) super.clone();
		//object.rectangle = (Rectangle) rectangle.clone();
		return object;
	}
}
class Rectangle implements Cloneable {
	double m, n;
	public Rectangle(double m, double n) {
		this.m = m;
		this.n = n;
	}
//	@Override
//	protected Object clone() throws CloneNotSupportedException {
//		return super.clone();
//	}
}
public class DeepCloneExample {
	public static void main(String[] args) {
		Geometry geometry = new Geometry(100, new Rectangle(10, 20));
		try {
			Geometry geometryCopy = (Geometry) geometry.clone();
			System.out.println("geometry对象中的rectangle矩形的长和宽：");
			System.out.println(geometry.rectangle.m + "," + geometry.rectangle.n);
			System.out.println("geometryCopy对象中的rectangle矩形的长和宽：");
			System.out.println(geometryCopy.rectangle.m + "," + geometryCopy.rectangle.n);
			System.out.println("geometry对象修改其中的rectangle矩形的长和宽：");
			geometry.rectangle.m = 100;
			geometry.rectangle.n = 200;
			System.out.println("geometry对象中的rectangle矩形的长和宽：");
			System.out.println(geometry.rectangle.m + "," + geometry.rectangle.n);
			System.out.println("geometryCopy对象中的rectangle矩形的长和宽：");
			System.out.println(geometryCopy.rectangle.m + "," + geometryCopy.rectangle.n);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

注释掉了处理深度克隆的代码的程序运行效果图

把注释去掉之后处理了深克隆的运行效果图

序列化 Serializable接口与克隆对象

相对于clone()方法，Java又提供了一种较简单的解决方案，这个方案就是使用Serializable接口和对象流来复制对象。
如果希望得到对象object的复制品，必须保证该对象是序列化的，即创建object对象的类必须实现Serializable接口。Serializable接口中的方法对程序是不可见的，因此实现该接口的类不需要实现额外的方法。
为了得到object的复制品，首先需要将object写入ObjectOutputStream流中，当把一个序列化的对象写入ObjectInputStream输出流时，JVM就会实现Serializable接口中的方法，将一定格式的文本–对象的序列化信息，写入ObjectOutputStream输出流的目的地。然后使用ObjectInputStream对象输入流从ObjectOutputStream输出流的目的地读取对象，这时ObjectInputStream对象流就读回object对象的序列化信息，并根据序列化信息创建一个新的对象，这个新对象就是object对象的一个复制品。
需要注意的是，使用对象流把一个对象写入文件时不仅要保证该对象是序列化的，而且该对象的成员对象也必须是序列化的。

简单的例子

Abstract Prototype的接口类MilitaryPerson.java

1
2
3
4
5
package Prototype;
public interface Prototype {
	public Object cloneMe() throws CloneNotSupportedException;
}

Abstract Prototype的实现类Cubic.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package Prototype;
public class Cubic implements Prototype {
	double length,width,heigth;
	
	public Cubic(double length, double width, double heigth) {
		this.length = length;
		this.width = width;
		this.heigth = heigth;
	}
	@Override
	public Object cloneMe() throws CloneNotSupportedException {
		Object object = (Cubic)clone();        //调用从Object类继承的clone方法
		return object;
	}
}

Abstract Prototype的实现类Goat.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package Prototype;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Goat implements Prototype, Serializable {
	StringBuffer color;
	
	public StringBuffer getColor() {
		return color;
	}
	public void setColor(StringBuffer color) {
		this.color = color;
	}
	@Override
	public Object cloneMe() throws CloneNotSupportedException {
		Object object = null;
		try {
			ByteArrayOutputStream outOne = new ByteArrayOutputStream();
			ObjectOutputStream outTwo = new ObjectOutputStream(outOne);
			outTwo.writeObject(this);    //将原型对象写入对象输出流
			ByteArrayInputStream inOne = new ByteArrayInputStream(outOne.toByteArray());
			ObjectInputStream inTwo = new ObjectInputStream(inOne);
			object = inTwo.readObject();  //创建新的对象，原型的复制品
		} catch (Exception e) {
			e.printStackTrace();
		}
		return object;
	}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package Prototype;
public class Application {
	public static void main(String[] args) {
		Cubic cubic = new Cubic(12, 20, 66);
		System.out.println("cubic的长、宽、高：");
		System.out.println(cubic.length + "," + cubic.width + ","
				+ cubic.heigth);
		try {
			Cubic cubicCopy = (Cubic) cubic.cloneMe();
			System.out.println("cubicCopy的长、宽、高：");
			System.out.println(cubicCopy.length + "," + cubicCopy.width + ","
					+ cubicCopy.heigth);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		Goat goat = new Goat();
		goat.setColor(new StringBuffer("白颜色的山羊"));
		System.out.println("goat是" + goat.getColor());
		try {
			Goat goatCopy = (Goat) goat.cloneMe();
			System.out.println("goatCopy是" + goatCopy.getColor());
			System.out.println("goatCopy将自己的颜色改变成黑色");
			goatCopy.setColor(new StringBuffer("黑颜色的山羊"));
			System.out.println("goat仍然是" + goat.getColor());
			System.out.println("goatCopy是" + goatCopy.getColor());
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

执行效果图

原型模式的优点

  • 当创建类的新实例的代价更大时，使用原型模式复制一个已有的实例可以提高创建新实例的效率。
  • 可以动态地保存当前对象的状态。在运行时，可以随时使用对象流保存当前对象的一个复制品。
  • 可以在运行时创建新的对象，而无须创建一系列类和继承结构。
  • 可以动态地添加、删除原型的复制品。

适用原型模式的情景

  • 程序需要从一个对象出发，得到若干个和其状态相同，并可独立变化其状态的对象时。
  • 当对象的创建需要独立于它的构造过程和表示时。
  • 一个类创建实例状态不是很多，那么就可以将这个类的一个实例定义为原型，那么通过复制该原型得到新的实例可能比重新使用类的构造方法创建新实例更方便。

下载源码请到

MyGitHub

本文标题:Java设计模式--原型模式

文章作者:yxx

发布时间:2016年09月19日 - 18时43分

最后更新:2016年09月20日 - 09时43分

原始链接:http://yoursite.com/2016/09/19/Java设计模式--原型模式/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 原型模式
  2. 2. Prototype Pattern
  3. 3. 类图
  4. 4. 模式的结构与使用
  5. 5. 克隆方法
    1. 5.1. 理解深克隆和浅克隆
    2. 5.2. clone()方法
    3. 5.3. clone()方法的重写与Cloneable接口
  6. 6. 下面Circle类的对象使用clone方法克隆自己的CloneExample.java
  7. 7. 深度克隆
    1. 7.1. 注释掉了处理深度克隆的代码
    2. 7.2. 注释掉了处理深度克隆的代码的程序运行效果图
    3. 7.3. 把注释去掉之后处理了深克隆的运行效果图
  8. 8. 序列化 Serializable接口与克隆对象
  9. 9. 简单的例子
    1. 9.1. Abstract Prototype的接口类MilitaryPerson.java
    2. 9.2. Abstract Prototype的实现类Cubic.java
    3. 9.3. Abstract Prototype的实现类Goat.java
    4. 9.4. 测试类Application.java
  10. 10. 执行效果图
  11. 11. 原型模式的优点
  12. 12. 适用原型模式的情景
  13. 13. 下载源码请到