原型模式

最新推荐文章于 2024-11-01 23:13:43 发布
最新推荐文章于 2024-11-01 23:13:43 发布
阅读量126 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 原型模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_41817666/article/details/130859107
版权
文章介绍了Java中的原型模式，用于高效地创建重复但内容基本相同的复杂对象。通过实现Cloneable接口，可以实现对象的浅拷贝和深拷贝，分别对应引用类型和整个对象结构的复制。文章还提供了示例代码，展示了如何实现深拷贝以及如何通过原型管理器进行对象的预创建和克隆，以提高程序性能。
摘要由CSDN通过智能技术生成

原型模式

创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，

应用场景

创建复杂的对象而且创建过程特别长，且内容基本都相同，
比如json的解析还原对象的过程，先将对象转化成json形式的字符串，然后再将字符串转化成对象，如果采用构造方法的方式进行创建，则需要了解每个函数的构造方法进行创建或者进行setter

优点

可以快速的相同的对象，性能比重新创建对象高

缺点

需要实现Cloneable接口，对于已经存在的类来说，改造成本会增大，会影响原来的逻辑

浅拷贝

浅拷贝是指在复制对象过程中，只将基础类型还包括String 以及基本类型的包装类型的对象复制过来，但是引用类型的还是指向原来对象的内存 ，因此两种对象中如果任意改变引用类型的对象的值，两边的值都会被改变，如果用== 或者equal来进行整个对象的比较地址值是不相同的

深拷贝

深拷贝是指在复制对象过程中，将新的对象完全开辟一个新的内存去存储新的对象，原来或者克隆对象的改变都不会引起双方值的变化，在java中使用流的方式来实现这种深拷贝

测试代码

公共对象

user类
package com.example.demo.study.prototype;

import java.io.*;

/**
 * @Author zhanpeng
 * @Date 2023/5/23 9:11
 */

public class User implements Cloneable, Serializable {

    private String name;

    private int age ;

    private Integer high;

    private Phone phone;

    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 Integer getHigh() {
        return high;
    }

    public void setHigh(Integer high) {
        this.high = high;
    }

    public Phone getPhone() {
        return phone;
    }

    public void setPhone(Phone phone) {
        this.phone = phone;
    }

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

    @Override
    public User clone() {
        try {
            User clone = (User) super.clone();
            /*// 这一部分是将对象进行深拷贝，当调用clone的方法时默认返回的是深拷贝后的对象
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(this);
            objectOutputStream.flush();
            ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
            clone = (User)objectInputStream.readObject();
            objectInputStream.close();
            objectOutputStream.close();*/
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

}
phone 类
package com.example.demo.study.prototype;

import java.io.Serializable;

/**
 * @Author zhanpeng
 * @Date 2023/5/24 8:50
 */

public class Phone implements/* Cloneable*/ Serializable {

    private String name;

    public String getName() {
        return name;
    }

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

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

   /* @Override
    public Phone clone() {
        try {
            Phone clone = (Phone) 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();
        }
    }*/
}

测试代码

拷贝测试类，如果只需要浅拷贝，就使用上述代码即可，如果需要深拷贝 放开user类中在clone方法中注释的代码

    public static  void main(String[] args){

        //浅克隆
        User user = new User();
        user.setAge(3);
        user.setName("333");
        user.setHigh(130);
        Phone phone = new Phone();
        phone.setName("苹果");
        user.setPhone(phone);

        User clone = user.clone();
        clone.setAge(2);
        clone.setName("222");
        clone.setHigh(120);
        clone.getPhone().setName("安卓");
        /*Phone phone2 = new Phone();
        phone2.setName("安卓");
        clone.setPhone(phone2);*/

        System.out.println("clone.equals(user) = " + clone.equals(user));
        System.out.println(clone == user);

        System.out.println("user = " + user);
        System.out.println("clone = " + clone);
    }

测试结果

浅拷贝的测试结果，可以看到 引用类型的对象被变得完全一样了，但是其他的类型的都正常的改变了

clone.equals(user) = false
false
user = User{name='333', age=3, high=130, phone=Phone{name='安卓'}}
clone = User{name='222', age=2, high=120, phone=Phone{name='安卓'}}

深拷贝的测试结果，可以看到双方任意对象的改变都不会影响彼此

#深拷贝的测试结果
clone.equals(user) = false
false
user = User{name='333', age=3, high=130, phone=Phone{name='苹果'}}
clone = User{name='222', age=2, high=120, phone=Phone{name='安卓'}}

原型管理

简单原型管理

比如我需要创建一个User类，但是我不想在运行时在去创建，那样可能会很耗时，我想在加载的时候就创建成功，然后提供一个克隆方法来实现管理

package com.example.demo.study.prototype;

/**
 * @Author zhanpeng
 * @Date 2023/5/25 7:57
 */

public enum PrototypeManager {
    //一个单例模式的原型工厂，来控制克隆对象
    INSTANCE;

    private static final User user =  new User();

    //默认初始化一个user对象，用于提供复制
    static {
        user.setAge(3);
        user.setName("333");
        user.setHigh(130);
        Phone phone = new Phone();
        phone.setName("苹果");
        user.setPhone(phone);
    }

    //输出复制的对象的方法
    public  User getCloneUser() {
        return user.clone();
    }


}
测试
@Test
    public void test1 () {
        User cloneUser = PrototypeManager.INSTANCE.getCloneUser();
        System.out.println("cloneUser = " + cloneUser);
    }
测试结果
cloneUser = User{name='333', age=3, high=130, phone=Phone{name='苹果'}}

通用管理

这个管理器我想更通用一点，比如定义一个PEOPLE的接口，然后继承Cloneable,只要实现了POEPLE的类我都可以进行管理，这里我定义了一个Student 和一个Teacher老师类来实现PEOPLE这个接口然后进行原型管理

people接口
package com.example.demo.study.prototype;

/**
 * @Author zhanpeng
 * @Date 2023/5/25 8:07
 */

public interface People extends Cloneable{

    //定义一个 克隆people接口
    People clone() throws CloneNotSupportedException;
}
学生类
package com.example.demo.study.prototype;

/**
 * @Author zhanpeng
 * @Date 2023/5/25 8:15
 */

public class Student implements People{

    private String name;

    private int age ;

    private Integer high;

    private Phone phone;

    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 Integer getHigh() {
        return high;
    }

    public void setHigh(Integer high) {
        this.high = high;
    }

    public Phone getPhone() {
        return phone;
    }

    public void setPhone(Phone phone) {
        this.phone = phone;
    }

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

    @Override
    public Student clone(){
        try {
            Student clone = (Student) super.clone();
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
老师类
package com.example.demo.study.prototype;

/**
 * @Author zhanpeng
 * @Date 2023/5/25 8:19
 */

public class Teacher implements People{

   private String name;

   private int age ;

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

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

   @Override
   public Teacher clone() throws CloneNotSupportedException {
      try {
         Teacher clone = (Teacher) super.clone();
         return clone;
      } catch (CloneNotSupportedException e) {
         throw new AssertionError();
      }
   }
}
原型管理器
package com.example.demo.study.prototype;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author zhanpeng
 * @Date 2023/5/25 7:57
 */

public enum PrototypeManager2 {
    INSTANCE;

    public enum PeopleType {
        STU,TEA;
    }
    //一个单例模式的原型工厂，来控制克隆对象

    private static final Map<String, People> clones =  new HashMap<String, People>();

    //初始化需要克隆的对象，此处展示的是简单对象，如果项目上有复制对象可以再启动环节就进行创建好，然后后续直接克隆使用
    static {
        Student student = new Student();
        student.setAge(8);
        student.setName("狗蛋");
        student.setHigh(130);
        Phone phone = new Phone();
        phone.setName("小苹果手机");
        student.setPhone(phone);
        clones.put(PeopleType.STU.name(), student);
        Teacher teacher = new Teacher();
        teacher.setAge(33);
        teacher.setName("小王老师");
        clones.put(PeopleType.TEA.name(), teacher);
    }

    //输出复制的对象的方法
    public People getClonePeople(PeopleType type) {
        try {
            return clones.get(type.name()).clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

}
测试类
@Test
    public void test2 () {
        People cloneStudent = PrototypeManager2.INSTANCE.getClonePeople(PrototypeManager2.PeopleType.STU);
        People cloneTeacher = PrototypeManager2.INSTANCE.getClonePeople(PrototypeManager2.PeopleType.TEA);
        System.out.println("cloneStudent = " + cloneStudent);
        System.out.println("cloneTeacher = " + cloneTeacher);
    }
测试结果
cloneStudent = Student{name='狗蛋', age=8, high=130, phone=Phone{name='小苹果手机'}}
cloneTeacher = Teacher{name='小王老师', age=33}
jayden_zp
关注
专栏目录
c++20设计模式-第4章-原型模式代码
02-05
原型模式（Prototype Pattern）是其中一种行为设计模式，它允许我们通过复制现有对象来创建新对象，而不是通过传统方式实例化新对象。这一模式尤其适用于创建复杂或昂贵的对象，因为它提供了对象克隆的能力，从而...
C++设计模式之原型模式
12-25
在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这这个定义中，最重要的一个词是“拷贝”，也就是口头上的复制，而这个拷贝，也...
设计模式之原型模式
道可道非常道
08-08 694
原型设计模式（Prototype Design Pattern）是一种创建型设计模式，其核心思想是通过复制（克隆）现有对象来创建新对象，而不是通过传统的实例化方式。这个模式在系统中需要创建大量相似对象时非常有用，可以避免反复创建同一类对象，并且在某些情况下还能提高性能。在原型模式中，对象实现一个原型接口，该接口规定了一个clone方法，用于返回对象自身的副本。这样，客户端就可以通过克隆的方式来创建对象，而不需要直接依赖具体类的构造函数。Prototype（原型接口）：定义一个用于克隆自身的接口。
C# 设计模式之原型模式
鲤籽鲲的博客
08-01 1053
C# 设计模式之原型模式
C++设计模式：原型模式
ajbb093的博客
04-07 1199
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
java设计模式之原型模式
m0_47944994的博客
11-16 3859
java设计模式之原型模式
设计模式——原型模式
学无止境，站在巨人的肩上，实现弯道超车
06-30 262
原型模式顾名思义，就是指以某个实例为原型，copy出一个新的实例，该实例属性与原型相同或者是类似。 很多时候，我们需要创建大量的相同或者相似的对象，如果一个个用new 构造函数的形式去创建的话比较繁琐，就像孙悟空要想变出成千上万个猴子猴孙总不能一个个去生吧，拔一根猴毛一吹就copy出了成千上万个猴子猴孙，我们原型模式原理也是如此，那就是clone克隆。 我们都知道JAVA中有个祖宗级别的类Object，每个类都默认继承它，它提供了一个本地方法clone()，代码如下： 可以看
Java设计模式: 原型模式
卷王: 乌-鸦的博客
04-21 428
个人理解： 原型模式是一种比较简单的设计模式，在项目中使用的场景非常多。 原型模式实现了对Java中某个对象的克隆功能，即该对象的类必须implements实现Cloneable接口来标识为可被克隆，然后需要覆写Object类的clone( )方法。 简单点说就是：实现一个接口重写一个方法就可以实现原型模式。 定义： 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 通用类图如下所示： 原型模式的核心是一个clone方法，通过该方法进行对象的拷贝，Java提供了一个Cloneable
详解设计模式：原型模式
栗筝i的博客
11-28 3739
原型模式（Prototype Pattern） ，是 GoF 的 23 种设计模式的一种，是用于创建重复的对象，同时又能保证性能。属于创建型模式，提供创建对象的最佳方式。 原型（Prototype），在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。 本篇内容包括：关于原型模式、原型模式-浅拷贝实现、原型模式-深拷贝实现
软件设计模式系列之七——原型模式
cooldream2009的博客
09-17 369
原型模式（Prototype Pattern）是一种创建型设计模式，其主要目的是通过复制现有对象来创建新对象，而不是使用构造函数。原型模式将对象的创建委托给原型对象，通过克隆（复制）来生成新对象，这种方式可以避免对象的重复初始化，提高性能，并使对象的创建更加灵活和动态。
设计模式：单例模式—工厂模式—原型模式
Liu_wen_wen的博客
09-19 1633
设计模式：单例模式—工厂模式—原型模式
Java设计模式之原型模式（复制模式）
qq_38642731的博客
05-09 529
概要 原型模式是一种特殊的创建型模式，它通过复制一个已有对象来创建更多相同或者相似的对象。 浅拷贝 在浅拷贝中，如果原型对象的成员变量是基本数据类型，如int,float,String(这里的String也属于基本数据类型，暂时不知道原因)，则复制一份给克隆对象，如果原型对象的成员变量是引用数据类型，则原型对象和克隆对象的成员变量指向相同的地址。 深拷贝 在深拷贝中，无论原型对象的成员变量是基本数据类型还是引用数据类型，都将复制一份给克隆对象。 Java中提供了Clone接口来...
设计模式之原型模式.docx
09-28
【设计模式之原型模式】 设计模式是软件工程中的一种最佳实践，是对在特定上下文中反复出现的软件设计问题的解决方案。原型模式属于对象创建型模式，它的主要思想是通过复制已有对象来创建新对象，降低了类的实例化...
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
Java学习路线：JUL日志系统（一）日志框架介绍
最新发布
LUwantAC的博客
11-01 597
首先，为什么要使用日志系统？如果单纯地用System.out.println打印信息，如果项目比较大，存在大量的信息就会显得非常凌乱。而且，当我们希望在debug的时候打印某些信息，而运行的时候不打印，使用直接输出的方法就行不通了。因此，我们需要使用日志框架来规范日志的输出。
原型模式：高效的对象克隆解决方案
wrxfxdd的博客
10-30 788
原型模式：高效的对象克隆解决方案
C++设计模式创建型模式———原型模式
无敌岩雀的博客
10-30 745
原型模式与工厂方法模式在创建对象时的主要区别在于它们如何处理对象的创建过程和状态复制。原型模式通过复制现有对象（原型）来创建新对象，新对象的初始状态与原型对象相同，这避免了复杂的设置过程。当对象的内部数据复杂且多变时，原型模式比工厂方法模式更合适，因为它可以直接克隆当前状态，无需额外的设置代码。例如，在游戏中创建一个具有特定状态的怪物分身，使用原型模式可以快速复制这些状态。工厂方法模式和原型模式在创建对象时都不需要知道具体的类名，但它们的工作方式不同。
JavaScript 判断数据类型有哪些方法？
JLY19970726的博客
10-30 599
在没有显式使用构造函数的情况下，创建的对象（例如对象和数组文本）将具有 constructor 属性，这个属性指向该对象的基本对象构造函数类型。链接：https://leetcode.cn/leetbook/read/javascript-interview-2/7mduie/// 获取构造函数的 prototype 对象。instanceof 运算符用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。// 判断构造函数的 prototype 对象是否在对象的原型链上。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 445
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
Java设计模式：PROTOTYPE原型模式详解
"本文主要介绍了Java设计模式中的原型模式(Prototype模式)，并与其他几种常见的设计模式进行了比较。" 设计模式是软件开发中的一种最佳实践，它提供了在特定场景下解决问题的模板，使得开发者能够重用这些经过验证...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值