设计模式之原型模式

已于 2023-08-27 12:33:13 修改
阅读量55 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 原型模式
于 2023-08-26 22:27:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72454762/article/details/132515950
版权

目录

1. 定义

2. 使用场景

3. 实现方式

3.1 通用的原型模式

3.2 基于Java实现原型模式

3.2.1 基于Cloneable接口实现原型模式

3.2.1.1 浅克隆

3.2.1.2 深克隆

3.2.2 基于Serializable接口实现原型模式

4. 参考资料

1. 定义

通过原型对象实例高效地克隆出新对象实例，新对象实例拥有全部或部分和原型对象实例相同的属性。

原型模式有以下角色：

Prototype：接口，定义了克隆方法。

ConcretePrototype：实现Prototype接口的原型对象，拥有克隆能力。

克隆有以下分类：

浅克隆：克隆得到的新对象实例的基本数据类型的属性和原型对象实例的基础数据类型的属性值完全一样，且互不干扰；但是，引用类型的属性和原型对象实例的引用类型的属性具有相同的指向。

深克隆：克隆得到的新对象实例的基本数据类型的属性、引用类型的属性，和原型对象实例的基础数据类型的属性值、引用类型的属性值完全一样，且互不干扰。

2. 使用场景

基于已有的原型对象实例，创建拥有相同属性值的新对象。

3. 实现方式

3.1 通用的原型模式

interface IClone {
    IClone clone();
}
class Achievement {

    private int chinese;
    private int math;

    public Achievement(int chinese, int math) {
        this.chinese = chinese;
        this.math = math;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    @Override
    public String toString() {
        return "Achievement{" +
                "chinese=" + chinese +
                ", math=" + math +
                '}';
    }
}
class Student implements IClone {

    private String name;

    private int age;

    private Achievement achievement;

    public Student(String name, int age, Achievement achievement) {
        this.name = name;
        this.age = age;
        this.achievement = achievement;
    }

    @Override
    public IClone clone() {
        // 直接使用原型对象实例的achievement赋值给克隆得到的新对象实例，是浅克隆
        return new Student(this.name, this.age, this.achievement);

        // 通过原型对象实例的achievement的属性值新建Achievement对象，再将Achievement对象赋值给克隆得到的新对象实例的achievement属性，就是深克隆
        // return new Student(this.name, this.age, new Achievement(this.achievement.getChinese(), this.achievement.getMath()));
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Achievement getAchievement() {
        return achievement;
    }

    public void setAchievement(Achievement achievement) {
        this.achievement = achievement;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", achievement=" + achievement +
                '}';
    }
}
public class Test{

    public static void main(String[] args) {

        Student student1 = new Student("AAA", 20, new Achievement(90, 90));
        Student student2 = (Student) student1.clone();
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}
        System.out.println(student2); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}
        
        System.out.println(student1.getAchievement() == student2.getAchievement()); // true

        student2.setName("BBB");
        student2.setAge(22);
        // 浅克隆，修改克隆得到的新对象实例的引用类型属性achievement，会同步修改原型实例对象的引用类型属性achievement
        student2.getAchievement().setChinese(100);
        student2.getAchievement().setMath(100);
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=100, math=100}}
        System.out.println(student2); // Student{name='BBB', age=22, achievement=Achievement{chinese=100, math=100}}
    }

}

3.2 基于Java实现原型模式

3.2.1 基于Cloneable接口实现原型模式

JDK提供了克隆标记接口Cloneable（无抽象方法），某类实现Cloneable接口且重写Object类的clone方法，此类便具有克隆能力。

3.2.1.1 浅克隆
class Achievement {

    private int chinese;
    private int math;

    public Achievement(int chinese, int math) {
        this.chinese = chinese;
        this.math = math;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    @Override
    public String toString() {
        return "Achievement{" +
                "chinese=" + chinese +
                ", math=" + math +
                '}';
    }
}
class Student implements Cloneable {

    private String name;

    private int age;

    private Achievement achievement;

    public Student(String name, int age, Achievement achievement) {
        this.name = name;
        this.age = age;
        this.achievement = achievement;
    }

    @Override
    public Object clone() {
        Object obj = null;
        try {
            // 此处是浅克隆，因为未处理引用类型Achievement
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        return obj;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Achievement getAchievement() {
        return achievement;
    }

    public void setAchievement(Achievement achievement) {
        this.achievement = achievement;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", achievement=" + achievement +
                '}';
    }
}
public class Test{

    public static void main(String[] args) {

        Student student1 = new Student("AAA", 20, new Achievement(90, 90));
        Student student2 = (Student) student1.clone();
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}
        System.out.println(student2); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}

        System.out.println(student1.getAchievement() == student2.getAchievement()); // true

        student2.setName("BBB");
        student2.setAge(22);
        // 浅克隆，修改克隆得到的新对象实例的引用类型属性achievement，会同步修改原型实例对象的引用类型属性achievement
        student2.getAchievement().setChinese(100);
        student2.getAchievement().setMath(100);
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=100, math=100}}
        System.out.println(student2); // Student{name='BBB', age=22, achievement=Achievement{chinese=100, math=100}}
    }

}
3.2.1.2 深克隆

修改上述代码，便可达到Student类的深克隆，修改点如下：

1. Achievement类实现Cloneable接口且重写Object类的clone方法。

2. 在Student类的clone方法中，使用Achievement的clone方法克隆achievement。

class Achievement implements Cloneable {

    private int chinese;
    private int math;

    public Achievement(int chinese, int math) {
        this.chinese = chinese;
        this.math = math;
    }

    @Override
    protected Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        return obj;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    @Override
    public String toString() {
        return "Achievement{" +
                "chinese=" + chinese +
                ", math=" + math +
                '}';
    }
}
class Student implements Cloneable {

    private String name;

    private int age;

    private Achievement achievement;

    public Student(String name, int age, Achievement achievement) {
        this.name = name;
        this.age = age;
        this.achievement = achievement;
    }

    @Override
    public Object clone() {
        Student newStudent = null;
        try {
            // 此处是深克隆
            newStudent = (Student) super.clone();
            newStudent.setAchievement((Achievement) this.achievement.clone());
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        return newStudent;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Achievement getAchievement() {
        return achievement;
    }

    public void setAchievement(Achievement achievement) {
        this.achievement = achievement;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", achievement=" + achievement +
                '}';
    }
}
public class Test{

    public static void main(String[] args) {

        Student student1 = new Student("AAA", 20, new Achievement(90, 90));
        Student student2 = (Student) student1.clone();
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}
        System.out.println(student2); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}

        System.out.println(student1.getAchievement() == student2.getAchievement()); // false

        student2.setName("BBB");
        student2.setAge(22);
        student2.getAchievement().setChinese(100);
        student2.getAchievement().setMath(100);
        // 深克隆，克隆得到的新对象实例和原型对象实例互不干扰
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}
        System.out.println(student2); // Student{name='BBB', age=22, achievement=Achievement{chinese=100, math=100}}
    }

}

3.2.2 基于Serializable接口实现原型模式

基于序列化实现的克隆是深克隆，代码如下所示：

class Achievement implements Serializable {

    private int chinese;
    private int math;

    public Achievement(int chinese, int math) {
        this.chinese = chinese;
        this.math = math;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    @Override
    public String toString() {
        return "Achievement{" +
                "chinese=" + chinese +
                ", math=" + math +
                '}';
    }
}
class Student implements Serializable {

    private String name;

    private int age;

    private Achievement achievement;

    public Student(String name, int age, Achievement achievement) {
        this.name = name;
        this.age = age;
        this.achievement = achievement;
    }
     
    // 反序列化得到的是新对象，因此序列化/反序列化方式的克隆是深克隆
    public Student deepClone() {
        try {
            // 序列化
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            // 反序列化
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Student) ois.readObject();
        } catch (Exception e) {
            return null;
        }
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Achievement getAchievement() {
        return achievement;
    }

    public void setAchievement(Achievement achievement) {
        this.achievement = achievement;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", achievement=" + achievement +
                '}';
    }
}
public class Test{

    public static void main(String[] args) {

        Student student1 = new Student("AAA", 20, new Achievement(90, 90));
        Student student2 = student1.deepClone();
        System.out.println(student1);
        System.out.println(student2);

        System.out.println(student1.getAchievement() == student2.getAchievement()); // false

        student2.setName("BBB");
        student2.setAge(22);
        student2.getAchievement().setChinese(100);
        student2.getAchievement().setMath(100);
        // 深克隆，克隆得到的新对象实例和原型对象实例互不干扰
        System.out.println(student1); // Student{name='AAA', age=20, achievement=Achievement{chinese=90, math=90}}
        System.out.println(student2); // Student{name='BBB', age=22, achievement=Achievement{chinese=100, math=100}}
    }

}

4. 参考资料

秒懂设计模式之原型模式（Prototype Pattern）

原型模式详解

YYDS程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式之原型模式
12-25
在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这这个定义中，最重要的一个词是“拷贝”，也就是口头上的复制，而这个拷贝，也...
C++设计模式：原型模式
ajbb093的博客
04-07 1078
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
JAVA设计模式之原型模式
孔子说
11-19 1181
转自http://www.kongzid.com/archives/design4，原型（Prototype）模式是一种对象创建型模式，他采取复制原型对象的方法来创建对象的实例。使用原型模式创建的实例，具有与原型一样的数据。 　　原型模式的特点： 　　1、由原型对象自身创建目标对象。也就是说，对象创建这一动作发自原型对象本身。 　　2、目标对象是原型对象的一个克隆。也就是说，通过原型模式创建的对象，不仅仅与原型对象具有相同的结构，还与...
设计模式之原型模式（深拷贝&浅拷贝）
weixin_64366370的博客
05-01 836
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式之一。
23种设计模式之原型模式
m0_61801103的博客
02-15 753
原型模式是一种创建型设计模式，该模式的核心思想是基于现有的对象创建新的对象，而不是从头开始创建。在原型模式中，通常有一个原型对象，它被用作创建新对象的末班。新对象通过复制原型对象的属性和状态来创建，而无需知道具体的创建细节。
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
Dart设计模式之原型模式
大模型学习路线
11-23 904
在这里为了方便大家系统的学习Flutter，这里特意联合了阿里P7架构师和谷歌技术团队共同整理了一份Flutter全家桶学习资料。内容概要：Flutter技术解析与实战、Flutter进阶学习笔记、Flutter入门与实战和Flutter完整开发实战详解。内容特点：条理清晰，含图像化表示更加易懂。由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要 Flutter技术解析与实战 完整文档的可扫描下方卡片免费获取！
软件设计模式之原型模式
qq_45726327的博客
06-19 1222
原型模式(Prototype Pattern)的简单程度仅次于单例模式和迭代器模式。正是由于简单，使用的场景才非常地多，其定义如下:Specify the kinds of objects to create using a prototypical instance, and create new objects by copyingthis prototype.(用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
Android编程设计模式之原型模式实例详解
01-20
【Android编程设计模式之原型模式实例详解】 原型模式是一种创建型设计模式，它允许通过复制现有的对象来创建新对象，从而提高程序的性能。在Android开发中，原型模式尤其适用于那些初始化过程复杂或耗时的对象，...
设计模式-建造者模式
m0_72703340的博客
08-28 535
​ 当一个类的构造函数参数有多个时，比如超过四个，而且这些参数有些是可选时，我们通常有两种方法来构建它的对象。例如我们现在有一个如下类Computer，其中CPU和ram​ 那么这两种方式有什么弊端呢？
设计模式 18 备忘录模式
最新发布
小小程序猿
09-02 699
备忘录模式的核心思想是将对象的状态保存在一个备忘录对象中，并允许在未来的某个时刻恢复该状态。备忘录模式保证了状态的封装性，外部对象无法直接访问备忘录中的内容，从而保护了原发器对象的内部细节。备忘录模式通过保存对象的状态，提供了恢复该状态的机制。它通过封装状态，确保了对象内部细节的保护，同时又允许状态的恢复。该模式非常适合用于实现“撤销/恢复”功能，并在需要管理复杂状态变更的场景中提供了很好的解决方案。
java设计模式day01--（类之间的关系、软件设计原则、单例设计模式）
m0_62388400的博客
08-29 1083
用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。
设计模式之简单工厂模式
2301_76862031的博客
08-28 947
简单工厂模式（Simple Factory Pattern）是一种常用的创建型设计模式，它提供了一个创建对象的静态方法，而不必将客户端代码与对象创建代码耦合在一起。简单工厂的核心在于存在一个拥有创建多种产品能力的工厂类，客户端只需要知道所需产品的名称或即可通过工厂获取到相应的产品实例。 对象使用者通过工厂获取对象实例，对象使用者不参与对象的创建
创建型设计模式-原型模式（prototype）- python实现
linkedin_21843693的博客
08-28 873
原型模式在处理复杂对象的复制时非常有用，它简化了对象的创建过程，并允许动态地改变对象的状态。不过，使用原型模式时，需要注意深复制和浅复制的区别，以及可能出现的循环引用问题。
设计模式结构型模式之适配器模式
针线犹存未忍开
08-29 1656
适配器模式是一种结构型设计模式，它允许不兼容的接口之间进行适配，使得原本无法一起工作的类可以协同工作。适配器模式通过引入一个适配器类，将一个类的接口转换成客户端所期待的接口，从而使原本由于接口不兼容而不能一起工作的两个类能够协同工作。适配器模式（Adapter Pattern）是一种结构型设计模式，它允许现有的类与其他类或接口进行协作，解决了类之间接口不兼容的问题。
行为型设计模式-迭代器（Iterator）模式-python实现
linkedin_21843693的博客
09-02 612
迭代器模式通过引入迭代器对象，实现了对聚合对象的遍历操作与聚合对象内部结构的解耦，提高了代码的灵活性和可维护性。它广泛应用于各种需要遍历数据集合的场景，比如数据库查询结果的遍历、文件系统的目录遍历等。
LeetCode第65题 有效数字 结合设计模式：状态模式
m0_63246220的博客
08-27 363
用设计模式则非常清楚。但是设计模式是为了给人理解的，对机器而言也可能稍微影响性能；注意：这样写出来的代码经测试用时2ms，不如直接面向过程的if-else大法。单纯用状态机会有大量的if-else，非常不好看，思路不清晰。思路：有限状态机，结合Java的设计模式：状态模式。
设计模式之禅：深入解析原型模式
"设计模式之禅之 原型模式" 设计模式是软件工程中的一种经验总结，用于解决常见的设计问题。原型模式是其中的一种，它允许通过复制已有对象来创建新对象，而不是每次都去创建一个新的实例。这种模式在需要大量创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值