原型模式（Prototype Pattern）

拜见老天師2023-12-11 9:04

1 基本概念

1.1 大佬文章

设计模式是什么鬼（原型）

详解设计模式：原型模式-腾讯云开发者社区-腾讯云

1.2 知识汇总

（1）原型模式：先 new 一个实例，该实例符合需求，之后再根据这个实例为原型，重复构建新的对象；

（2）所属类型：创建型模式

（3）作用：重复创建对象；

（4）优点：可以重复获得对象的同时保持较高的性能；

1.3 基本构成

（1）抽象原型类：抽象原型类是定义具有克隆自己的方法接口，是所有具体原型类的公共父类，可以是抽象类，也可以是接口；在 Java 中 Cloneable 接口可以看作是抽象原型类；

（2）具体原型类：根据这个类可以获得一个原型对象，并且这个类中需要重现 clone 方法，可以根据这个 clone 方法复制对象；

（3）访问类：使用具体原型类中的 clone 方法，可以不断重复的复制对象；

2 Java 中的克隆

根据现有的对象复制一个新的对象的操作就是克隆，Java 中克隆分为浅克隆和深克隆（我个人更喜欢说浅拷贝和深拷贝）；浅拷贝和深拷贝的区别主要在重写 clone 方法上有所区别；但是，虽然之前有了解过拷贝的相关问题，但是发今天发现其实这里面还是有一些细节需要注意的。

2.1 拷贝的必要条件

（1）实现 Cloneable 接口：这个接口其实是一个标记接口，想要使用 clone 方法，就必须先实现这个接口，否则该类的 clone 方法是不可用的。

（2）重写 clone 方法：仅仅实现 Cloneable 接口还不能达到要求，还需要重写这个方法，否则依然不能使用 clone 方法；

2.2 浅拷贝

浅拷贝是将某个对象的所有成员属性都赋值给 clone 得到的对象；

（1）简单数据类型，如 int 等等的数据类型，直接将值拷贝过去；

（2）非简单数据类型，如引用类型的数据，是将引用的地址赋值给拷贝得到的对象，也就是说并没有新建一个成员对象，而是简单的将引用复制一遍；

java 复制代码 
package se.wangs.clonedemo.pojo;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 9:07
 * @description 演示浅拷贝
 */
public class Teacher {
    private String name;
    private String idNo;

    public String getName() {
        return name;
    }

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

    public String getIdNo() {
        return idNo;
    }

    public void setIdNo(String idNo) {
        this.idNo = idNo;
    }
}
java 复制代码 
package se.wangs.clonedemo.pojo;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 9:08
 * @description 演示clone
 */
public class Student implements Cloneable{
    private String idNo;
    private String name;
    private Teacher teacher;

    public String getIdNo() {
        return idNo;
    }

    public void setIdNo(String idNo) {
        this.idNo = idNo;
    }

    public String getName() {
        return name;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public Student clone() {
        try {
            Student clone = (Student) super.clone();
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
java 复制代码 
package se.wangs.clonedemo;

import se.wangs.clonedemo.pojo.Student;
import se.wangs.clonedemo.pojo.Teacher;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/4 16:37
 * @description 浅拷贝
 */
public class ShallowClone {
    public static void main(String[] args) {
        Teacher teacher1 = new Teacher();
        teacher1.setIdNo("001");
        teacher1.setName("teacher_001");

        Student student1 = new Student();
        student1.setIdNo("101");
        student1.setName("student_101");
        student1.setTeacher(teacher1);

        Student cloneStudent = student1.clone();

        System.out.println("---------------------------");
        System.out.println(student1);
        System.out.println("idNo = " + student1.getIdNo());
        System.out.println("name = " + student1.getName());
        System.out.println("teacher = " + student1.getTeacher());

        System.out.println("---------------------------");
        System.out.println(cloneStudent);
        System.out.println("idNo = " + cloneStudent.getIdNo());
        System.out.println("name = " + cloneStudent.getName());
        System.out.println("teacher = " + cloneStudent.getTeacher());
    }
}

运行测试类得到的结果如下：

---------------------------
se.wangs.clonedemo.pojo.Student@41629346
idNo = 101
name = student_101
teacher = se.wangs.clonedemo.pojo.Teacher@214c265e
---------------------------
se.wangs.clonedemo.pojo.Student@448139f0
idNo = 101
name = student_101
teacher = se.wangs.clonedemo.pojo.Teacher@214c265e

说明：

  • student1：原对象
  • cloneStudent：浅拷贝得到的对象

可以看到，student 中有一个引用类型的成员变量 teacher，浅拷贝得到的 cloneStudent 中的 teacher 变量与 student1 指向的对象相同；

2.3 深拷贝

深拷贝就是会将引用类型的变量做进一步处理，clone 出的对象的引用数据类型的成员变量，会指向一个新的变量

java 复制代码 
package se.wangs.clonedemo.pojo;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 9:07
 * @description 演示浅拷贝
 */
public class Teacher implements Cloneable{
    private String name;
    private String idNo;

    public String getName() {
        return name;
    }

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

    public String getIdNo() {
        return idNo;
    }

    public void setIdNo(String idNo) {
        this.idNo = idNo;
    }

    @Override
    public Teacher clone() {
        try {
            Teacher clone = (Teacher) super.clone();
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
java 复制代码 
package se.wangs.clonedemo.pojo;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 9:08
 * @description 演示clone
 */
public class Student implements Cloneable{
    private String idNo;
    private String name;
    private Teacher teacher;

    public String getIdNo() {
        return idNo;
    }

    public void setIdNo(String idNo) {
        this.idNo = idNo;
    }

    public String getName() {
        return name;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public Student clone() {
        try {
            Student clone = (Student) super.clone();
            // 获得原来的 teacher 对象，并clone出一个新的teacher对象
            Teacher newTeacher = clone.getTeacher().clone();
            // 重新设置teacher
            clone.setTeacher(newTeacher);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
java 复制代码 
package se.wangs.clonedemo;

import se.wangs.clonedemo.pojo.Student;
import se.wangs.clonedemo.pojo.Teacher;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 10:09
 * @description 深拷贝
 */
public class DeepClone {
    public static void main(String[] args) {
        Teacher teacher1 = new Teacher();
        teacher1.setIdNo("001");
        teacher1.setName("teacher_001");

        Student student1 = new Student();
        student1.setIdNo("101");
        student1.setName("student_101");
        student1.setTeacher(teacher1);

        Student cloneStudent = student1.clone();

        System.out.println("---------------------------");
        System.out.println(student1);
        System.out.println("idNo = " + student1.getIdNo());
        System.out.println("name = " + student1.getName());
        System.out.println("teacher = " + student1.getTeacher());

        System.out.println("---------------------------");
        System.out.println(cloneStudent);
        System.out.println("idNo = " + cloneStudent.getIdNo());
        System.out.println("name = " + cloneStudent.getName());
        System.out.println("teacher = " + cloneStudent.getTeacher());
    }
}

运行得到

---------------------------
se.wangs.clonedemo.pojo.Student@41629346
idNo = 101
name = student_101
teacher = se.wangs.clonedemo.pojo.Teacher@214c265e
---------------------------
se.wangs.clonedemo.pojo.Student@448139f0
idNo = 101
name = student_101
teacher = se.wangs.clonedemo.pojo.Teacher@7cca494b

可以看到，得到的 teacher 对象的地址变了；

2.4 总结

浅拷贝和深拷贝的主要区别就是对引用类型的变量的处理

（1）浅拷贝：引用类型的变量拷贝前后指向同一个对象；

（2）深拷贝：引用类型的变量拷贝后指向新的对象；

（3）核心：重写 clone 方法时对引用类型变量的处理不同；

参考资料：
Java深入理解深拷贝和浅拷贝区别_java深拷贝浅拷贝-CSDN博客

3 原型设计模式

3.1 设计模式体验

（1）抽象原型类：Cloneable 接口

（2）具体原型类：可以 new 原型实例，实现 Cloneable 接口，重写了 clone() 方法；

java 复制代码 
package se.wangs.prototype;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 9:07
 * @description
 */
public class Teacher implements Cloneable{
    private String name;
    private String idNo;

    public String getName() {
        return name;
    }

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

    public String getIdNo() {
        return idNo;
    }

    public void setIdNo(String idNo) {
        this.idNo = idNo;
    }

    @Override
    public Teacher clone() {
        try {
            Teacher clone = (Teacher) super.clone();
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
java 复制代码 
package se.wangs.prototype;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 9:08
 * @description 具体原型类
 */
public class Student implements Cloneable{
    private String idNo;
    private String name;
    private Teacher teacher;

    public String getIdNo() {
        return idNo;
    }

    public void setIdNo(String idNo) {
        this.idNo = idNo;
    }

    public String getName() {
        return name;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public Student clone() {
        try {
            Student clone = (Student) super.clone();
            // 获得原来的 teacher 对象，并clone出一个新的teacher对象
            Teacher newTeacher = clone.getTeacher().clone();
            // 重新设置teacher
            clone.setTeacher(newTeacher);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

（3）访问类：实例化原型，通过 clone 复制原型对象；

java 复制代码 
package se.wangs.prototype;

/**
 * -- coding: UTF-8 -- *
 *
 * @author wangs
 * @date 2023/12/6 10:30
 * @description 访问类
 */
public class Client {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.setName("okay");
        teacher.setIdNo("0001");

        Student student = new Student();
        student.setIdNo("stu_001");
        student.setName("onesun");
        student.setTeacher(teacher);

        System.out.println("---------------------------");
        System.out.println(student);
        System.out.println("idNo = " + student.getIdNo());
        System.out.println("name = " + student.getName());
        System.out.println("teacher = " + student.getTeacher());

        for (int i = 0; i < 10; i++) {
            System.out.println("---------------------------");
            Student cloneStudent = student.clone();
            System.out.println(cloneStudent);
            System.out.println("idNo = " + cloneStudent.getIdNo());
            System.out.println("name = " + cloneStudent.getName());
            System.out.println("teacher = " + cloneStudent.getTeacher());
        }
    }
}

3.2 总结

（1）原型设计模式的思想就是拿到一个对象，将该对象当作一个标准，然后使用 clone 方法不断重复的去复制这个标准（原型对象），从而得到大量同类型的对象，在游戏等等场景中应用广泛。

（2）使用原型模式而不是 new 对象的优点是，节约 new 需要消耗的资源，提高系统的性能。

（3）原型模式的应用

Spring 框架对 bean 对象进行管理，而默认的 bean 对象是单例模式的，也可以使用 scope 属性指定为非单例模式，当 scope 属性为"socpe=prototype"时，就是非单例模式，其实这里使用的就是原型模式；

相关推荐
WaaTong1 小时前
《重学Java设计模式》之 单例模式
java·单例模式·设计模式
WaaTong3 小时前
《重学Java设计模式》之 原型模式
java·设计模式·原型模式
霁月风3 小时前
设计模式——观察者模式
c++·观察者模式·设计模式
暗黑起源喵6 小时前
设计模式-工厂设计模式
java·开发语言·设计模式
wrx繁星点点13 小时前
状态模式（State Pattern）详解
java·开发语言·ui·设计模式·状态模式
金池尽干15 小时前
设计模式之——观察者模式
观察者模式·设计模式
也无晴也无风雨15 小时前
代码中的设计模式-策略模式
设计模式·bash·策略模式
捕鲸叉1 天前
MVC（Model-View-Controller）模式概述
开发语言·c++·设计模式
wrx繁星点点1 天前
享元模式：高效管理共享对象的设计模式
java·开发语言·spring·设计模式·maven·intellij-idea·享元模式
凉辰1 天前
设计模式 策略模式 场景Vue （技术提升）
vue.js·设计模式·策略模式
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解