当前位置： 首页 > news >正文

原型模式（Prototype Pattern）

news 来源：原创 2025/5/11 5:51:07

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

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;
    }
}


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();
        }
    }
}


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 出的对象的引用数据类型的成员变量，会指向一个新的变量

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();
        }
    }
}


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();
        }
    }
}


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() 方法；

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();
        }
    }
}


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 复制原型对象；

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"时，就是非单例模式，其实这里使用的就是原型模式；

相关文章：

  • 2023-12-04 AIGC-Stable Diffusion和SadTalker-搭建及使用
  • HarmonyOS Developer——鸿蒙【构建第一个JS应用（FA模型）】
  • MySQL之数据库及表操作
  • 微信小程序适配方案：rpx（responsive pixel响应式像素单位）
  • Jmeter分布式压力测试详解
  • Flink State 状态原理解析 | 京东物流技术团队
  • C++基础
  • 解决 IIS HTTP 403 错误问题
  • Halcon联合winform显示以及处理
  • 浙政钉SDK安装
  • [架构之路-260]：目标系统 - 设计方法 - 软件工程 - 软件设计 - 架构设计 - 基于Web的软件架构（REST与RESTful）
  • mac苹果笔记本电脑如何强力删除卸载app软件？
  • 【数据结构】顺序表的定义和运算
  • 数据结构：单链表——定义、插入、删除
  • NoSuchColumnFamilyException: org.apache.hadoop.hbase.regionserv
  • 单节点hadoop搭建
  • zookeeper笔记
  • MySQL生成UUID并去除-
  • 智能优化算法应用：基于广义正态分布算法无线传感器网络(WSN)覆盖优化 - 附代码
  • Python-炸弹人【附完整源码】
  • 贵州省总工会正厅级副主席梁伟被查，曾任贵州省纪委副书记
  • 阚吉林任重庆市民政局党组书记，原任市委组织部主持日常工作的副部长
  • 秦洪看盘｜重估叙事主题卷土重来，给A股注入新活力
  • 如此城市|上海老邬：《爱情神话》就是我生活的一部分
  • 中美“第二阶段”贸易协定是否会在会谈中提出？商务部回应
  • 视频｜漫画家寂地：古老丝路上的文化与交流留下的独特印记