原型模式：克隆对象的艺术

最新推荐文章于 2024-10-16 11:03:19 发布

技术拾光者

最新推荐文章于 2024-10-16 11:03:19 发布

阅读量444

点赞数 8

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

本文链接：https://blog.csdn.net/weixin_43319056/article/details/142281515

版权

设计模式专栏收录该内容

29 篇文章 0 订阅

订阅专栏

在软件开发中，对象的创建和管理是一个常见且关键的任务。有时候，我们需要创建一个与现有对象完全相同或者相似的新对象，而不是通过构造函数从头开始创建。这时，原型模式（Prototype Pattern）就派上用场了。本文将详细介绍原型模式的概念、实现方式以及在Java中的使用示例。

原型模式是一种创建型设计模式，它允许一个对象在创建另一个可定制的对象，而无需知道如何创建的细节。这种模式通过复制现有对象来创建新对象，从而避免了复杂的对象创建过程。

一，原型模式的优点

性能提升：通过克隆对象来创建新对象，比直接实例化对象更高效，尤其是当创建对象的过程比较复杂时。
减少子类数量：通过克隆对象，可以减少需要创建的子类数量，因为可以通过原型对象来创建不同的对象。
简化对象创建：对于一些复杂对象，通过克隆现有对象可以简化对象的创建过程。

二，原型模式的实现

在Java中，实现原型模式通常需要实现 Cloneable 接口，并覆盖 clone 方法。以下是一个简单的示例：

// 原型类
class Prototype implements Cloneable {
    private String name;

    public Prototype(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 客户端代码
public class PrototypePatternDemo {
    public static void main(String[] args) {
        try {
            Prototype original = new Prototype("Original");
            Prototype clone = (Prototype) original.clone();

            System.out.println("Original: " + original.getName());
            System.out.println("Clone: " + clone.getName());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，Prototype 类实现了 Cloneable 接口，并覆盖了 clone 方法。客户端代码创建了一个原型对象，并通过调用 clone 方法创建了一个副本。

三，深拷贝与浅拷贝

在原型模式中，有两种类型的拷贝：浅拷贝和深拷贝。

浅拷贝：创建一个新对象，这个新对象是对原始对象的字段的精确拷贝。如果字段是基本数据类型，拷贝的就是基本数据类型的值；如果字段是引用类型，拷贝的就是引用地址。
深拷贝：不仅复制对象的所有字段，还复制所有引用对象所指向的对象。深拷贝比浅拷贝更复杂，因为它需要递归地复制所有引用对象。

以下是一个深拷贝的示例：

import java.io.*;

// 原型类
class DeepPrototype implements Serializable {
    private String name;
    private InnerObject innerObject;

    public DeepPrototype(String name, InnerObject innerObject) {
        this.name = name;
        this.innerObject = innerObject;
    }

    public String getName() {
        return name;
    }

    public InnerObject getInnerObject() {
        return innerObject;
    }

    // 深拷贝方法
    public DeepPrototype deepClone() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            oos.flush();
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (DeepPrototype) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

// 内部对象类
class InnerObject implements Serializable {
    private String value;

    public InnerObject(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

// 客户端代码
public class DeepPrototypePatternDemo {
    public static void main(String[] args) {
        InnerObject innerObject = new InnerObject("Inner Value");
        DeepPrototype original = new DeepPrototype("Original", innerObject);
        DeepPrototype clone = original.deepClone();

        System.out.println("Original: " + original.getName() + ", Inner: " + original.getInnerObject().getValue());
        System.out.println("Clone: " + clone.getName() + ", Inner: " + clone.getInnerObject().getValue());
    }
}