设计模式——原型模式

小白起 v2024-02-23 23:30

定义：

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

模式的结构中包括两种角色:

v 抽象原型 ( Prototype): 一个接口，负责定义对象复制自身的方法
v 具体原型 (Concrete Prototype): 实现 Prototype 接口的类。具体原型实现抽象原型中的方法，以便所创建的对象调用该方法复制自己。
深克隆实现:
v 实现 Cloneable 接口重写 clone 方法

java 复制代码 
import java.util.ArrayList;
import java.util.List;

// 可克隆接口
interface CloneablePrototype {
    CloneablePrototype clone() throws CloneNotSupportedException;
}

// 具体原型类
class Prototype implements CloneablePrototype {
    private int id;
    private List<String> list;

    public Prototype(int id, List<String> list) {
        this.id = id;
        this.list = list;
    }

    @Override
    public Prototype clone() throws CloneNotSupportedException {
        // 创建新的列表对象，并将原列表中的元素复制到新列表中
        List<String> newList = new ArrayList<>(list);
        // 创建新的原型对象并返回
        return new Prototype(id, newList);
    }

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

    public void addToList(String item) {
        this.list.add(item);
    }

    public void displayInfo() {
        System.out.println("ID: " + id);
        System.out.println("List: " + list);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建原型对象
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        Prototype original = new Prototype(1, list);

        try {
            // 进行深克隆
            Prototype deepClone = original.clone();
            // 修改克隆对象的属性
            deepClone.setId(2);
            deepClone.addToList("C");

            // 显示原型对象和克隆对象的信息
            System.out.println("Original:");
            original.displayInfo();
            System.out.println("Clone:");
            deepClone.displayInfo();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，Prototype 类实现了 CloneablePrototype 接口，并提供了 clone() 方法来实现深度克隆。在 clone() 方法中，我们手动创建了一个新的列表对象，并将原列表中的元素复制到新列表中，然后使用新列表创建了一个新的原型对象并返回。
浅克隆实现:
v 利用序列化和反序列化技术
v 深克隆把引用的变量指向复制过的新的对象，而不是原有的被引用的对象
v 深克隆：让已实现 Clonable 接口的类中的属性也实现 Clonable 接口
v 基本数据类型能够自动实现深克隆（值的复制）

java 复制代码 
import java.util.ArrayList;
import java.util.List;

// 可克隆接口
interface CloneablePrototype {
    CloneablePrototype clone() throws CloneNotSupportedException;
}

// 具体原型类
class Prototype implements CloneablePrototype {
    private int id;
    private List<String> list;

    public Prototype(int id, List<String> list) {
        this.id = id;
        this.list = list;
    }

    @Override
    public Prototype clone() throws CloneNotSupportedException {
        // 使用默认的浅克隆方式，直接调用Object类的clone方法
        return (Prototype) super.clone();
    }

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

    public void addToList(String item) {
        this.list.add(item);
    }

    public void displayInfo() {
        System.out.println("ID: " + id);
        System.out.println("List: " + list);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建原型对象
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        Prototype original = new Prototype(1, list);

        try {
            // 进行浅克隆
            Prototype shallowClone = original.clone();
            // 修改克隆对象的属性
            shallowClone.setId(2);
            shallowClone.addToList("C");

            // 显示原型对象和克隆对象的信息
            System.out.println("Original:");
            original.displayInfo();
            System.out.println("Clone:");
            shallowClone.displayInfo();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，Prototype 类实现了 CloneablePrototype 接口，并提供了 clone() 方法来实现浅克隆。在 clone() 方法中，我们直接调用了 Object 类的 clone() 方法，这是默认的浅拷贝实现，它会创建一个新对象，但不会复制对象内部的引用类型属性。
原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需知道其具体的实现细节。

浅克隆和深克隆的区别在于克隆对象内部包含的引用类型属性的处理方式：

浅克隆（Shallow Clone）：
  • 在浅克隆中，被克隆的对象和克隆产生的新对象共享内部的引用类型属性。
  • 克隆产生的新对象拥有原对象内部引用类型属性的引用，而不是拷贝这些引用类型属性的内容。
  • 如果原对象或克隆对象修改了共享的引用类型属性，那么另一个对象也会受到影响。
深克隆（Deep Clone）：
  • 在深克隆中，被克隆的对象和克隆产生的新对象拥有各自独立的内部引用类型属性。
  • 克隆产生的新对象会复制原对象内部引用类型属性的内容，而不是共享这些引用类型属性的引用。
  • 即使原对象或克隆对象修改了自己的引用类型属性，另一个对象也不会受到影响。

在实际应用中，根据具体需求和对象的结构，选择合适的克隆方式非常重要。通常情况下，如果对象的引用类型属性是不可变的（如 String 类型），那么使用浅克隆是安全的；但如果对象的引用类型属性是可变的，那么通常会选择深克隆来确保对象之间的独立性。

原型模式的优点和缺点如下：

优点：
  1. 简化对象创建：原型模式允许通过复制现有对象来创建新对象，避免了复杂对象的初始化过程，使得对象的创建过程更加简单和灵活。
  2. 提高性能：与通过调用构造函数创建对象相比，原型模式的性能通常更高，因为它避免了初始化过程中可能涉及的大量计算和I/O操作。
  3. 保护现有对象：原型模式在创建新对象时不会影响现有对象的状态，从而保护了现有对象的完整性。
  4. 动态配置对象：通过修改现有对象的属性，可以动态地配置新对象的属性，而无需修改创建新对象的代码。
  5. 减少子类数量：原型模式可以用来创建具有相同属性但不同行为的对象，从而减少了子类的数量，使得代码更加简洁和易于维护。
缺点：
  1. 深拷贝问题：当对象的属性包含复杂对象（例如集合或引用类型）时，需要进行深拷贝，否则新对象和原型对象之间可能会共享相同的引用，导致意外修改原型对象或新对象的属性。
  2. 循环引用问题：如果对象之间存在循环引用关系，那么复制对象时可能会导致无限递归，使得程序陷入死循环。
  3. 破坏封装性：原型模式可能会破坏对象的封装性，因为复制对象时通常需要访问对象的内部属性和方法，这使得对象的实现细节暴露给了外部。
  4. 复杂度增加：在处理深拷贝、循环引用等问题时，原型模式的实现可能会变得复杂，增加了代码的复杂度和维护成本。

综上所述，原型模式在适当的场景下可以带来很多优点，但也需要谨慎使用，特别是在处理对象的属性复杂或存在循环引用等情况时需要特别注意。

示例:

复制代码 
import java.util.ArrayList;
import java.util.List;

// 可克隆接口
interface CloneablePrototype {
    CloneablePrototype clone() throws CloneNotSupportedException;
}

// 具体原型类
class Prototype implements CloneablePrototype {
    private int id;
    private List<String> list;

    public Prototype(int id, List<String> list) {
        this.id = id;
        this.list = list;
    }

    @Override
    public Prototype clone() throws CloneNotSupportedException {
        // 浅克隆
        // return new Prototype(id, list);
        
        // 深克隆
        List<String> newList = new ArrayList<>();
        for (String item : list) {
            newList.add(item);
        }
        return new Prototype(id, newList);
    }

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

    public void addToList(String item) {
        this.list.add(item);
    }

    public void displayInfo() {
        System.out.println("ID: " + id);
        System.out.println("List: " + list);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建原型对象
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        Prototype original = new Prototype(1, list);

        try {
            // 浅克隆
            // Prototype shallowClone = original.clone();
            // shallowClone.setId(2);
            // shallowClone.addToList("C");

            // 深克隆
            Prototype deepClone = original.clone();
            deepClone.setId(2);
            deepClone.addToList("C");

            // 显示原型对象和克隆对象的信息
            System.out.println("Original:");
            original.displayInfo();
            System.out.println("Clone:");
            deepClone.displayInfo();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

运行结果:

在这个例子中，我们仍然使用了接口 CloneablePrototype 来表示可克隆对象，但没有使用继承关系。在 Prototype 类中，我们实现了 CloneablePrototype 接口，提供了深克隆和浅克隆两种克隆方法。在深克隆中，我们手动复制了原型对象中的列表属性，从而实现了深度克隆。

相关推荐
朵朵zeng2 小时前
ETL背景介绍_1:数据孤岛仓库的介绍
数据仓库·etl·原型模式
enyp804 小时前
Qt原型模式实现与应用
开发语言·qt·原型模式
敲代码的 蜡笔小新4 小时前
【行为型之策略模式】游戏开发实战——Unity灵活算法架构的核心实现策略
unity·设计模式·c#·策略模式
_yingty_4 小时前
Java设计模式-策略模式（行为型）
java·设计模式·策略模式
炎芯随笔14 小时前
【C++】【设计模式】生产者-消费者模型
开发语言·c++·设计模式
workflower21 小时前
使用谱聚类将相似度矩阵分为2类
人工智能·深度学习·算法·机器学习·设计模式·软件工程·软件需求
枣伊吕波1 天前
第六节第二部分：抽象类的应用-模板方法设计模式
android·java·设计模式
lalajh1 天前
论软件设计模式及其应用
设计模式
lgily-12251 天前
常用的设计模式详解
java·后端·python·设计模式
周努力.2 天前
设计模式之中介者模式
设计模式·中介者模式
热门推荐
01YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04【解决】Android Gradle Sync 报错 Could not read workspace metadata05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06DeepSeek各版本说明与优缺点分析07苍穹外卖面试总结08Coze扣子平台完整体验和实践（附国内和国际版对比）09西电B测-计算机网络综合实验(含验收问题)10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）