设计模式 - 原型模式

💝💝💝首先，欢迎各位来到我的博客，很高兴能够在这里和您见面！希望您在这里不仅可以有所收获，同时也能感受到一份轻松欢乐的氛围，祝你生活愉快！

文章目录

- - 引言
  - 一、原型模式的基本概念
  - 二、原型模式的实现
  - - [1. 定义抽象原型接口](#1. 定义抽象原型接口)
    - [2. 定义具体原型类](#2. 定义具体原型类)
    - [3. 客户端代码](#3. 客户端代码)
  - 三、原型模式的优点
  - 四、原型模式的缺点
  - 五、原型模式的应用场景
  - 六、原型模式的扩展
  - 七、深拷贝与浅拷贝
  - 八、原型模式与工厂模式的区别
  - 九、总结

引言

原型模式是一种创建型设计模式，它通过复制现有的对象实例来创建新对象，而不是通过传统的构造函数创建。这种模式适用于对象创建成本较高的场景，以及需要动态创建大量相似对象的情况。本文将详细介绍原型模式的概念，并通过具体的Java代码示例来说明如何实现这一模式。

一、原型模式的基本概念

原型模式的主要参与者包括：

Prototype：定义了克隆自身的接口。
ConcretePrototype：实现了 Prototype 接口，并提供了克隆自身的方法。
Client：使用 Prototype 对象创建新的对象实例。

二、原型模式的实现

接下来，我们将通过一个示例来详细了解原型模式的实现步骤。

1. 定义抽象原型接口

首先，定义抽象原型接口，该接口声明了克隆方法：

java 复制代码

// 抽象原型接口
public interface CloneablePrototype extends Cloneable {
    CloneablePrototype clone() throws CloneNotSupportedException;
}

2. 定义具体原型类

接下来，定义具体原型类，这些类实现了前面定义的抽象原型接口：

java 复制代码

// 具体原型类
public class Employee implements CloneablePrototype {
    private String name;
    private int id;
    private Address address;

    public Employee(String name, int id, Address address) {
        this.name = name;
        this.id = id;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public CloneablePrototype clone() throws CloneNotSupportedException {
        Employee clonedEmployee = (Employee) super.clone();
        clonedEmployee.address = this.address.clone();  // Deep copy of the address
        return clonedEmployee;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", address=" + address +
                '}';
    }
}

public class Address implements CloneablePrototype {
    private String street;
    private String city;
    private String state;
    private String zipCode;

    public Address(String street, String city, String state, String zipCode) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zipCode = zipCode;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getZipCode() {
        return zipCode;
    }

    public void setZipCode(String zipCode) {
        this.zipCode = zipCode;
    }

    @Override
    public CloneablePrototype clone() throws CloneNotSupportedException {
        return (Address) super.clone();
    }

    @Override
    public String toString() {
        return "Address{" +
                "street='" + street + '\'' +
                ", city='" + city + '\'' +
                ", state='" + state + '\'' +
                ", zipCode='" + zipCode + '\'' +
                '}';
    }
}

3. 客户端代码

客户端代码使用原型对象创建新的对象实例：

java 复制代码

public class ClientApplication {
    public static void main(String[] args) {
        try {
            // 创建原始对象
            Address originalAddress = new Address("123 Main St", "Springfield", "IL", "62704");
            Employee originalEmployee = new Employee("John Doe", 1001, originalAddress);

            // 复制对象
            Employee clonedEmployee = originalEmployee.clone();

            // 修改原始对象
            originalEmployee.setName("Jane Smith");
            originalEmployee.getAddress().setCity("Chicago");

            // 输出原始对象和克隆对象的信息
            System.out.println("Original Employee: " + originalEmployee);
            System.out.println("Cloned Employee: " + clonedEmployee);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

三、原型模式的优点

性能提升：克隆现有对象比重新创建一个新对象要快得多，特别是在对象创建成本较高的情况下。
代码复用：通过克隆对象，可以减少重复代码，提高代码的复用性。
灵活性：原型模式允许在运行时动态创建对象，增强了程序的灵活性。

四、原型模式的缺点

深拷贝和浅拷贝：克隆对象时需要注意深拷贝和浅拷贝的问题，以避免引用相同对象而导致的问题。
实现细节 ：实现原型模式需要实现 clone() 方法，这可能涉及到对象的序列化和反序列化等细节问题。
对象依赖：如果对象之间存在复杂的依赖关系，克隆对象可能会变得复杂。

五、原型模式的应用场景

原型模式适用于以下情况：

对象创建成本较高：当创建一个新对象的成本很高时，可以通过复制现有对象来避免高昂的成本。
对象配置多样：当需要创建大量相似但略有不同的对象时，可以通过复制现有对象并稍作修改来实现。
性能敏感：当性能是一个关键因素时，使用原型模式可以减少对象创建的时间和空间开销。

六、原型模式的扩展

在实际应用中，可以通过以下方式扩展原型模式：

深拷贝和浅拷贝：根据需要选择深拷贝或浅拷贝策略，以满足不同的需求。
对象池：可以使用对象池来管理原型对象，以便多次复用这些对象。
参数化原型：允许客户端通过参数来指定具体原型，从而在运行时动态选择原型对象。

七、深拷贝与浅拷贝

在实现原型模式时，深拷贝和浅拷贝是非常重要的概念。简单来说：

浅拷贝：创建一个新的对象，然后将原对象的非引用类型的成员变量复制到新对象中。如果成员变量是引用类型，则仅仅复制指向同一对象的引用。
深拷贝：不仅复制原对象的所有非引用类型的成员变量，还会复制所有引用类型的成员变量所指向的对象，这样两个对象完全独立，互不影响。

在上述示例中，我们通过以下方式实现了深拷贝：

覆盖 clone() 方法 ：覆盖了 Object 类中的 clone() 方法，使其能够深拷贝对象。
递归克隆：对于引用类型成员变量，我们也进行了递归克隆，以确保深拷贝。

八、原型模式与工厂模式的区别

原型模式和工厂模式都是创建型设计模式，但它们之间存在显著差异：

目的：工厂模式关注的是如何创建对象，而原型模式关注的是如何通过复制现有对象来创建新对象。
适用范围：工厂模式适用于创建简单的对象，而原型模式适用于创建复杂的对象，尤其是对象创建成本较高的情况。
创建过程：工厂模式通过构造函数创建对象，而原型模式通过复制现有对象来创建新对象。

九、总结

原型模式是面向对象设计中一种非常有用的模式，特别是在需要高效创建大量相似对象的情况下。在实际编程中，原型模式可以用于创建高度可配置和可扩展的系统，尤其是在需要支持多种不同类型的产品时。通过上述实现，你可以根据自己的需求进一步扩展和优化原型模式的应用。

原型模式虽然简单，但在设计系统时需要考虑到其潜在的问题，比如深拷贝和浅拷贝的选择等。正确地使用原型模式可以使你的代码更加健壮和易于维护。

💝💝💝如有需要请大家订阅我的专栏【设计模式】哟！我会定期更新相关系列的文章
💝💝💝关注！关注！！请关注！！！请大家关注下博主，您的支持是我不断创作的最大动力！！！

设计模式相关文章索引	文章链接
设计模式 - 抽象工厂模式	设计模式 - 抽象工厂模式
设计模式 - 单例模式	设计模式 - 单例模式
设计模式 - 建造者模式	设计模式 - 建造者模式

❤️❤️❤️觉得有用的话点个赞 👍🏻 呗。
❤️❤️❤️本人水平有限，如有纰漏，欢迎各位大佬评论批评指正！😄😄😄
💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍
🔥🔥🔥Stay Hungry Stay Foolish 道阻且长,行则将至,让我们一起加油吧！🌙🌙🌙