Java设计模式 六 原型模式 (Prototype Pattern)
原型模式 (Prototype Pattern)
原型模式是一种创建型设计模式，通过复制现有对象来创建新对象，而不是直接实例化类。这种模式适用于创建成本较高的对象，或者需要重复创建相似对象的场景。
原型模式的核心思想是：
通过对象自身提供的复制方法（通常是 clone() 方法），快速生成新对象，同时保持高效和灵活。
1. 原型模式的组成
- Prototype（原型接口）： 定义一个用于复制自身的接口，通常包括
clone()方法。 - ConcretePrototype（具体原型类）： 实现
Prototype接口，定义具体的克隆方法。 - Client（客户端）： 通过调用原型对象的
clone()方法创建新的对象，而不需要知道具体类的信息。
2. 原型模式的优点
- 提高对象创建效率： 克隆比使用构造函数重新实例化对象要高效。
- 减少耦合： 客户端不需要依赖具体类，通过原型接口即可创建对象。
- 动态创建对象： 可以在运行时动态调整对象的状态并克隆，灵活性强。
3. 原型模式的缺点
- 复杂性增加： 如果对象包含复杂的引用类型，可能需要处理深拷贝和浅拷贝的问题。
- 依赖
clone()方法： 在 Java 中，必须正确实现clone()方法，且需要实现Cloneable接口，这可能会破坏类的封装性。
4. Java 中的实现
1) 实现浅拷贝的原型模式
浅拷贝只复制对象本身及其基本类型的字段，引用类型字段仅复制引用地址。
示例代码：
class Prototype implements Cloneable {
private String field;
public Prototype(String field) {
this.field = field;
}
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 浅拷贝
}
@Override
public String toString() {
return "Prototype [field=" + field + "]";
}
}
public class Client {
public static void main(String[] args) {
try {
// 创建原型对象
Prototype prototype = new Prototype("Original");
System.out.println("Original: " + prototype);
// 克隆对象
Prototype clonedPrototype = (Prototype) prototype.clone();
System.out.println("Cloned: " + clonedPrototype);
// 修改克隆对象的字段值
clonedPrototype.setField("Cloned");
System.out.println("After Modification:");
System.out.println("Original: " + prototype);
System.out.println("Cloned: " + clonedPrototype);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
输出：
Original: Prototype [field=Original]
Cloned: Prototype [field=Original]
After Modification:
Original: Prototype [field=Original]
Cloned: Prototype [field=Cloned]
2) 实现深拷贝的原型模式
深拷贝不仅复制对象本身，还递归复制引用类型的字段。
示例代码：
import java.io.*;
class DeepPrototype implements Serializable {
private static final long serialVersionUID = 1L;
private String field;
private Reference reference;
public DeepPrototype(String field, Reference reference) {
this.field = field;
this.reference = reference;
}
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
public Reference getReference() {
return reference;
}
public void setReference(Reference reference) {
this.reference = reference;
}
// 深拷贝方法
public DeepPrototype deepClone() throws IOException, ClassNotFoundException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (DeepPrototype) ois.readObject();
}
@Override
public String toString() {
return "DeepPrototype [field=" + field + ", reference=" + reference + "]";
}
}
class Reference implements Serializable {
private static final long serialVersionUID = 1L;
private String data;
public Reference(String data) {
this.data = data;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
@Override
public String toString() {
return "Reference [data=" + data + "]";
}
}
public class Client {
public static void main(String[] args) {
try {
// 创建原型对象
Reference reference = new Reference("Original Reference");
DeepPrototype prototype = new DeepPrototype("Original Field", reference);
System.out.println("Original: " + prototype);
// 深拷贝
DeepPrototype clonedPrototype = prototype.deepClone();
System.out.println("Cloned: " + clonedPrototype);
// 修改克隆对象的引用字段值
clonedPrototype.getReference().setData("Modified Reference");
System.out.println("After Modification:");
System.out.println("Original: " + prototype);
System.out.println("Cloned: " + clonedPrototype);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
输出：
Original: DeepPrototype [field=Original Field, reference=Reference [data=Original Reference]]
Cloned: DeepPrototype [field=Original Field, reference=Reference [data=Original Reference]]
After Modification:
Original: DeepPrototype [field=Original Field, reference=Reference [data=Original Reference]]
Cloned: DeepPrototype [field=Original Field, reference=Reference [data=Modified Reference]]
5. 原型模式的应用场景
- 对象创建成本较高时： 如对象初始化过程复杂，或需要大量计算。
- 对象差异很小且需要频繁创建时： 使用克隆可以减少重复代码。
- 需要保存对象历史状态时： 通过克隆保存对象的副本以实现备份或撤销功能。
- 需要创建与已有对象相似的对象时： 克隆提供了一种快速复制现有对象的方法。
6. 优缺点总结
优点：
- 性能优越： 通过克隆直接复制对象，而不需要重新构建。
- 简化创建过程： 尤其是对于包含大量字段的对象。
- 动态创建： 可以在运行时动态创建对象，而无需依赖类。
缺点：
- 复杂性： 需要正确实现
clone()方法，尤其是处理复杂对象中的深拷贝。 - 依赖 Cloneable 接口： Java 中的
clone()方法存在局限性，并且可能破坏封装性。 - 潜在安全隐患： 如果对象中的字段不安全或未正确处理，可能导致意外行为。
7. 与其他模式的比较
| 模式 | 主要用途 | 与原型模式的区别 |
|---|---|---|
| 工厂方法模式 | 通过子类决定对象创建 | 原型模式通过克隆现有对象来创建 |
| 抽象工厂模式 | 创建相关或依赖对象的产品族 | 原型模式关注单个对象的复制 |
| 建造者模式 | 分步骤构建复杂对象 | 原型模式直接克隆对象，无需分步骤构建 |
8. 总结
原型模式是解决对象重复创建问题的强大工具，特别适合那些创建成本高或需要快速生成对象的场景。根据具体需求，可以选择浅拷贝或深拷贝的实现方式。尽管实现上可能会稍复杂，但它提供了灵活性和高效性，是值得掌握的重要设计模式之一。
原文地址：https://blog.csdn.net/WithCYwind/article/details/145285467
免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！