原型模式

最新推荐文章于 2024-06-27 11:09:56 发布
最新推荐文章于 2024-06-27 11:09:56 发布
阅读量132 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47382783/article/details/108801230
版权

 

目录

一、原型模式的介绍

1、定义

2、使用场景

3、优缺点

二、原型模式的实现

1、浅拷贝

2、深拷贝

一、原型模式的介绍

1、定义

       原型模式用来创建重复的对象，即从一个对象再创建另一个对象，而且不需要知道任何创建的细节。这种模式就像克隆一样，以某个给定的对象为原型，复制出新的对象。就像动画片西游记的主题曲里唱的一样：拔一根毫毛，吹出猴万个。

       在原型模式的结构中，主要包含以下角色：

  • 抽象原型类：规定了具体原型对象必须实现的接口。
  • 具体原型类：实现抽象原型类的clone()方法，它是可被复制的对象。
  • 访问类（客户端）：使用具体原型类中的clone()方法来复制新的对象。

2、使用场景

  • 资源优化。
  • 类初始化需要消耗很多的资源，包括数据资源、硬件资源等。
  • 对性能和安全有要求的场景。
  • 通过new创建一个对象需要非常繁琐的数据准备或访问权限。
  • 一个对象多个修改者的场景。
  • 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用

3、优缺点

优点：提高性能；逃避了构造函数的约束。

缺点：需要为每一个类配备一个克隆方法，如果要对已有类进行修改，就需要修改源代码，违背了OCP原则。

二、原型模式的实现

        Java语言的Object类中提供了一个clone()方法，对于任何实现了Cloneable接口的类，都可以通过clone()方法完成对象的克隆。由于clone方法是由虚拟机直接复制内存块执行，所以在速度上比使用new的方式创建对象要快。

       原型模式的UML类图如下：

1、浅拷贝

（1）数据类型的介绍：

  • 如果数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，即把该属性值复制一份给新的对象。
  • 如果数据类型是引用类型的成员变量，例如：数组、自定义类对象等，那么浅拷贝会进行引用传递，也就是只将该成员变量的引用值赋值给新的对象，从而使用两个对象的成员变量都指向同一个实例。
  • String类型通过常量赋值时相当于基本数据类型，通过new关键字创建对象时便是引用数据类型。

（2）实现过程

       如果要对一个Person类进行复制，可以让Person实现Cloneable接口，然后重写clone()方法，具体如下：

class Person implements Cloneable{
    private String name;
    private Integer age;
    private String address;

    public Person() {
    }

    public Person(String name, Integer age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getAddress() {
        return address;
    }

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

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

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

public class ProtoMode {
    public static void main(String[] args) {
        Person person = new Person("老大哥", 20, "陕西");
        System.out.println(person);
        System.out.println("==========");
        Person clonePerson = person.clone();
        System.out.println(clonePerson);
        System.out.println(person == clonePerson);//false
    }
}

      上面的代码已经达到了克隆的目的。如果对比person和clonePerson的内存地址可以发现它们是不一样的。 

（3）存在的问题

       就像上面介绍的一样，如果成员变量是引用类型，那么复制后对象和原对象都指向同一个实例，那么其中一个对该内存地址中的数据进行修改会导致另外一个对象发生变化。这里我们可以简单验证一下：

       场景描述：在Teacher类里面有一个自定义类对象Student，测试两种情况：

  • 复制之后两个对象的Student是否指向同一个对象？
  • 如果修改clonePerson的Student，是否引起person中数据变化？

class Student{
    private String name;
    private Integer age;

    public Student() {}

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

class Teacher implements Cloneable{
    private String name;
    private String address;
    private Student student;

    public Teacher() {
    }

    public Teacher(String name, String address, Student student) {
        this.name = name;
        this.address = address;
        this.student = student;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

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

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

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

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

public class Test {
    public static void main(String[] args) {
        Student student = new Student("张三", 18);
        Teacher teacher = new Teacher("李明", "江苏", student);
        System.out.println(teacher);
        Teacher cloneTeacher = teacher.clone();
        System.out.println(cloneTeacher);
        //验证复制前后的student是否指向同一地址
        System.out.println(teacher.getStudent() == cloneTeacher.getStudent());//true
        cloneTeacher.getStudent().setName("李四");
        System.out.println(teacher.getStudent().getName());//李四
        System.out.println(cloneTeacher.getStudent().getName());//李四
    }
}

 通过测试可以发现确实存在数据被修改的情况，那么如何解决呢？接下来就来介绍深拷贝，能够避免这种情况的发生。

（4）构造函数的说明

       在进行对象拷贝的时候构造函数是不会执行的，其原因在于拷贝是在堆中进行。因为在new的时候，JVM要进行类加载流程，此时会调用构造函数，最后生成的对象会放到堆中，而拷贝就是直接拷贝堆中的现成的二进制对象，然后重新一个分配内存块。来看下面的实例：

package mode;

class Person implements Cloneable{
    private String name;
    private Integer age;
    private String address;

    public Person() {
        System.out.println("Person的构造函数");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }

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

public class ProtoMode {
    public static void main(String[] args) {
        Person person = new Person();
        Person clonePerson = person.clone();
    }
}

结果输出：Person的构造函数。

这就证明了构造函数在对象Clone的时候不会被执行。

2、深拷贝

       深拷贝不仅复制对象的所有基本数据类型的成员变量值，而且会为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象（包括对象的引用类型）进行拷贝。

（1）实现方式一：重写clone()方法实现深拷贝

      对于浅拷贝中测试的代码场景，解决引用类型的拷贝问题，代码如下：


class Student implements Cloneable{
    private String name;
    private Integer age;

    public Student() {}

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

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

class Teacher implements Cloneable{
    private String name;
    private String address;
    private Student student;

    public Teacher() {
    }

    public Teacher(String name, String address, Student student) {
        this.name = name;
        this.address = address;
        this.student = student;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

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

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

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

    @Override
    protected Teacher clone(){
        Object obj = null;
        try {
            obj = super.clone();
            this.student = student.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return (Teacher) obj;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("张三", 18);
        Teacher teacher = new Teacher("李明", "江苏", student);
        System.out.println(teacher);
        Teacher cloneTeacher = teacher.clone();
        System.out.println(cloneTeacher);
        //验证复制前后的student是否指向同一地址
        System.out.println("person和clonePerson的Student地址相同?\t\t" + (teacher.getStudent() == cloneTeacher.getStudent()));//false
        System.out.println("修改学生数据：");
        cloneTeacher.getStudent().setName("李四");
        System.out.println("person中学生的姓名：" + teacher.getStudent().getName());//张三
        System.out.println("clonePerson中学生的姓名：" + cloneTeacher.getStudent().getName());//李四
    }
}

 执行结果如下：

（2）实现方式二：通过序列化实现深拷贝

代码如下：

import java.io.*;

class Student implements Serializable {
    private String name;
    private Integer age;

    public Student() {}

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

}

class Teacher implements Serializable{
    private String name;
    private String address;
    private Student student;

    public Teacher() {
    }

    public Teacher(String name, String address, Student student) {
        this.name = name;
        this.address = address;
        this.student = student;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

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

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

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

    public Object deepClone() throws Exception{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

public class Test {
    public static void main(String[] args) throws Exception{
        Student student = new Student("张三", 18);
        Teacher teacher = new Teacher("李明", "江苏", student);
        System.out.println(teacher);
        Teacher cloneTeacher = (Teacher) teacher.deepClone();
        System.out.println(cloneTeacher);
        //验证复制前后的student是否指向同一地址
        System.out.println("person和clonePerson的Student地址相同?\t\t" + (teacher.getStudent() == cloneTeacher.getStudent()));//false
        System.out.println("修改学生数据：");
        cloneTeacher.getStudent().setName("李四");
        System.out.println("person中学生的姓名：" + teacher.getStudent().getName());//张三
        System.out.println("clonePerson中学生的姓名：" + cloneTeacher.getStudent().getName());//李四
    }
}

测试结果如下：

 说明：Serializable和Cloneable都是标识性接口，里面没有任何定义。

姚舜禹_12140
关注
专栏目录
Java创建型设计模式-原型模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-11 870
原型模式是一种创建型设计模式，‌它允许通过复制一个已经存在的对象来创建一个新的对象，‌而无需重新实例化。‌这种模式特别适用于那些需要创建类似对象的情况，‌可以避免重复的代码和资源浪费。‌原型模式的核心在于提供一个原型对象，‌通过这个原型对象来生成其他对象，‌而不需要知道这些对象的类结构。‌在本文，我们学习了Java的一种创建型设计模式原型模式，知道它拥有原型接口具体原型类客户端和克隆方法四个角色，还阐述了原型模式的使用场景，以及呈现了原型模式的代码示例，相信大家应该对原型模式不陌生了！！
C++设计模式之原型模式
12-25
在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这这个定义中，最重要的一个词是“拷贝”，也就是口头上的复制，而这个拷贝，也...
23种设计模式（5）：原型模式
java开发指南博客 【转载】
03-26 1235
定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 类型：创建类模式 类图： 原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件： 实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在jav...
设计模式之原型模式
yihaoa的博客
12-01 542
文章目录一、克隆羊问题1.1 传统方式解决克隆羊问题1.2 代码1.3 传统方式的缺点二、原型模式2.1 原型模式基本介绍2.2 原型模式原理结构uml类图2.3 原型模式解决克隆羊问题的应用实例2.4 原型模式在Spring框架中源码分析三、深入讨论-浅拷贝和深拷贝3.1 浅拷贝介绍3.2 深拷贝基本介绍3.3 深拷贝应用实例四、原型模式的注意事项和细节 一、克隆羊问题 现在有一只羊 tom，姓...
设计模式之：原型模式
Blossom
11-20 557
目录 原型模式概述 原型模式的结构与实现 原型模式的应用实例 原型管理器 原型模式的优缺点与适用环境 原型模式概述 孙悟空“拔毛变小猴”实现自我复制： 孙悟空：根据自己的形状复制（克隆）出多个身外身 软件开发：通过复制一个原型对象得到多个与原型对象一模一样的新对象 原型模式的定义： 原型模式：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。 Prototy...
原型 模式
最新发布
zxf347085420的博客
06-27 99
原文链接：https://blog.csdn.net/h8062651/article/details/136289765原型模式（Prototype Pattern）是一种创建型：通过来。
设计模式之原型模式.docx
09-28
【设计模式之原型模式】 设计模式是软件工程中的一种最佳实践，是对在特定上下文中反复出现的软件设计问题的解决方案。原型模式属于对象创建型模式，它的主要思想是通过复制已有对象来创建新对象，降低了类的实例化...
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
Android编程设计模式之原型模式实例详解
01-20
【Android编程设计模式之原型模式实例详解】 原型模式是一种创建型设计模式，它允许通过复制现有的对象来创建新对象，从而提高程序的性能。在Android开发中，原型模式尤其适用于那些初始化过程复杂或耗时的对象，...
学习php设计模式 php实现原型模式(prototype)
10-23
### 五、原型模式与其他设计模式的关系 原型模式与抽象工厂模式在某些情况下可以相互补充，但它们的主要区别在于，抽象工厂模式专注于创建对象族，而原型模式关注单个对象的复制。 ### 六、PHP中的原型模式实现 ...
Java设计模式：PROTOTYPE原型模式详解
"本文主要介绍了Java设计模式中的原型模式(Prototype模式)，并与其他几种常见的设计模式进行了比较。" 设计模式是软件开发中的一种最佳实践，它提供了在特定场景下解决问题的模板，使得开发者能够重用这些经过验证...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值