（二）Java架构师成长之路-设计模式：原型模式，浅克隆和深克隆

最新推荐文章于 2024-09-12 23:58:52 发布
最新推荐文章于 2024-09-12 23:58:52 发布
阅读量163 收藏
点赞数
分类专栏： java架构 文章标签： java 设计模式 软件架构师
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35528312/article/details/108431009
版权

一.什么是原型模式

原型模式是指原型对象指定创建对象的种类，并通过拷贝这些原型的方式创建新的对象。

调用者不需要知道创建对象的细节，不调用构造函数就能创建对象。

属于创建型模式。

目的是为了减少创建对象的复杂度，提升系统性能，一般是基于二进制流的拷贝。

二.原型模式的通用写法

我们先来看一下原型模式的通用写法

先创建一个顶层接口

public interface IProtoType<T> {

    // 第一种方法
    T clone();

    // 第二种方法
    T clone(T object);
}

再创建一个类来实现这个接口

public class CommonProtoType implements IProtoType{

    private Integer id;

    private String name;

    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    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 CommonProtoType clone() {
        CommonProtoType commonProtoType = new CommonProtoType();
        commonProtoType.setId(this.getId());
        commonProtoType.setAge(this.getAge());
        commonProtoType.setName(this.getName());
        return commonProtoType;
    }

    // 第二种方式，利用反射为属性赋值，适合字段较多的情况
    @Override
    public Object clone(Object object) {
        try {
            Class clazz = object.getClass();
            Object returnValue = clazz.newInstance();
            Field[] fileds = clazz.getDeclaredFields();
            for (Field filed : fileds) {
                filed.setAccessible(true);
                filed.set(returnValue, filed.get(object));
            }
            return returnValue;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

三.原型模式的使用场景

1.new一个对象并且给属性赋值的过程非常繁琐

2.构造方法比较复杂

3.循环体内大量创建具有相同属性的对象

4.类初始化消耗资源较多

注意：克隆和new的区别：克隆不会走构造方法

四.浅克隆和深克隆

1.浅克隆

在拷贝引用数据类型的时候会拷贝引用的内存地址，而不拷贝具体的值（String除外，因为它的value是final的）。

先来看一个案例

创建一个浅克隆的类实现Cloneable接口，实现clone方法，直接调用父类的clone方法。Object类实现了Cloneable接口，是一个本地方法，默认是浅克隆

public class ShallowProtoType implements Cloneable {

    private Integer id;

    private String name;

    private Integer age;

    private List<String> hobbies;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    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 List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    @Override
    public ShallowProtoType clone() {
        try {
            return (ShallowProtoType) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

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

创建测试类 

public class Test {

    public static void main(String[] args) {
        ShallowProtoType shallowProtoType = new ShallowProtoType();
        shallowProtoType.setId(1);
        List<String> hobbies = new LinkedList<String>() {
            {
                this.add("打篮球");
                this.add("打游戏");
            }
        };
        shallowProtoType.setHobbies(hobbies);
        shallowProtoType.setAge(18);
        shallowProtoType.setName("周杰伦");

        ShallowProtoType cloneType = shallowProtoType.clone();
        System.out.println("改变克隆对象的爱好前：");
        System.out.println("原型对象" + shallowProtoType);
        System.out.println("克隆对象" + cloneType);
        System.out.println("改变克隆对象的爱好后：");
        cloneType.getHobbies().add("唱歌");
        System.out.println("原型对象" + shallowProtoType);
        System.out.println("克隆对象" + cloneType);
    }
}

输出结果

可以看出，克隆对象的引用类型的属性改变之后，原型对象也跟着改变了。

2.深克隆

为了避免浅克隆带来的问题，由此引入深克隆的方式。

还记得我们之前讲过的序列化和反序列会破坏单例吗？这里就要利用这一点，在序列化和反序列的时候，不实现自己的readResolve方法，那么每次就会返回一个不同的实例。

创建一个深克隆的类，实现Serializable接口。

public class DeepProtoType implements Serializable {

    private Integer id;

    private String name;

    private Integer age;

    private List<String> hobbies;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    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 List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public DeepProtoType deepClone() {
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(this);

            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            return (DeepProtoType) objectInputStream.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

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

创建测试类

public class Test {

    public static void main(String[] args) {
        DeepProtoType deepProtoType = new DeepProtoType();
        deepProtoType.setId(1);
        List<String> hobbies = new LinkedList<String>() {
            {
                this.add("打篮球");
                this.add("打游戏");
            }
        };
        deepProtoType.setHobbies(hobbies);
        deepProtoType.setAge(18);
        deepProtoType.setName("周杰伦");

        DeepProtoType cloneType = deepProtoType.deepClone();
        System.out.println("改变克隆对象的爱好前：");
        System.out.println("原型对象" + deepProtoType);
        System.out.println("克隆对象" + cloneType);
        System.out.println("改变克隆对象的爱好后：");
        cloneType.getHobbies().add("唱歌");
        System.out.println("原型对象" + deepProtoType);
        System.out.println("克隆对象" + cloneType);
    }
}

输出结果

可以看出，深克隆完美解决了浅克隆带来的问题

除了序列化和反序列的方式外，可以利用json来实现深克隆，阿里和谷歌的json库都可以。

五.原型模式在源码中的应用

ArrayList、HashMap

这两个都是浅克隆，只要是通过实现Cloneable接口来实现克隆的都是浅克隆，深克隆一般要自己去实现。

小鲁班跑慢点
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【系统架构设计师】原型模式详解
Programming Talk
09-12 119
原型模式是一种通过克隆来创建对象的设计模式，它适合于创建复杂、耗时对象的场景。通过浅拷贝和深拷贝的方式，原型模式可以在不同程度上复制已有对象。对于复杂对象结构，深拷贝提供了独立的对象副本，而浅拷贝则提供了效率更高但共享引用的副本。
创建型模式：工厂/原型/建造者模式
略
07-11 617
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。
设计模式——原型模式
sunshine
11-22 298
一、原型模式概述 原型模式是一种特殊的创建型模式，它通过复制一个已有对象来获取更多相同或者相似的对象。原型模式可以提高相同类型对象的创建效率，简化创建过程。 二、原型模式克隆机制 浅克隆（Shallow Clone） 浅克隆：如果原型对象的成员变量是值类型（如 int、double、byte、boolean、char等基本数据类型），将复制一份给克隆对象；如果...
JavaScript中深克隆（深拷贝）的三种实现方式
热门推荐
qq_39410252的博客
11-26 1万+
由于Object类型与Array类型是引用类型，而引用类型在变量间的相互赋值是将指向内存的指针赋予过去，这样就会导致，当改变b的数据会将a的数据一同改变。 而在实际的开发过程中，有很多时候需要将两个变量间的关联断开，所以需要用到深克隆断开这个联系。 1、使用延展操作符（…）实现深克隆 这种方式是最简单且便捷的一种方式，但是只能深克隆一层，第二层的引用依然指向原来的位置。 2、使用JSON实现深克隆 这种方式也比较简便，并且可以实现多层的深克隆，但是无法复制function，无法适用全部场景。 3、使用
深拷贝的写法
fishegg07的博客
04-22 479
最简单版本，适用于大多数场景： JSON.parse(JSON.stringify(target)); 手写简单版： const deepClone = (target) => { if(typeof target === 'object' && target !== null){ const cloneTarget...
java设计模式学习笔记--原型模式(浅克隆和深克隆)
一叶知秋_11的博客
11-28 2291
1. 什么是原型模式原型模式属于对象的创建模式。。原型模式允许你通过复制现有的实例来创建新的实例。 这个模式的重点在于，客户端的代码在不知道要实例化何种特定类的情况下，可以制造出新的实例。在java中，一般使用clone()的方法，或者序列化。2. 原型模式的实现在java中，由于Object类中有一个clone()方法，所以要使用原型模式非常简单，只要实现Cloneable的接口就可以了。 J
架构师成长之路-设计模式-07.原型模式、克隆模式、java属性复制
愿你的微笑化成风的专栏
02-19 166
原型模式 原型模式解决的是大量属性复制问题。 本文将介绍几种深度属性复制方式、几种浅度属性复制方式。 本文源码地址将在文末给出。 未使用原型模式之前的代码 public static void testCloneStupid() { PrototypePerson person = new PrototypePerson() .setId("10001") .setAge(18) .setName
JAVA架构师之路四：设计模式之原型模式
cuixhao110的博客
11-19 415
原型模式
架构师之路：设计模式-原型模式
小小的人儿的博客
05-26 104
原型模式其实就是复制，从一个现有的对象直接复制一个对象出来，这就是原型模式。直接复制额优势就是不用去重新执行new的过程，更高效。复制专业点就是克隆，克隆有两种方式，深克隆和浅克隆。这里就不多描述克隆。 Java中的clone java为我们实现了clone，我们来研究下java中的克隆。 static class IObj1 implements Cloneable{ private IObj2 obj2; public IObj2 getObj2() {
软件设计模式复习
endzero00的博客
11-23 1597
软件设计模式复习 一、面向对象思想 二、面向对象设计 一句话总结软件设计七大原则 设计原则 一句话归纳 目的 开闭原则 对扩展开放，对修改关闭 降低维护带来的新风险 依赖倒置原则 高层不应该依赖低层，要面向接口编程 更利于代码结构的升级扩展 单一职责原则 一个类只干一件事，实现类要单一 便于理解，提高代码的可读性 接口隔离原则 一个接口只干一件事，接口要精简单一 功能解耦，高聚合、低耦合 迪米特法则 不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度 只和朋
“大话”设计模式
欢迎来到技术宅的博客
04-03 466
导语：设计模式是无数码农前人在实际的生产项目中经过不断的踩坑、爬坑、修坑的经历总结出来的经验教训，经过抽象之后表达成的概念。能够帮助后来的设计者避免重复同样的错误或者弯路。我也抽空整理了一下设计模式，用自己的话总结了一下，自认为通俗易懂。简单工厂模式：包括三种角色，抽象产品、具体产品和工厂角色。其中在工厂直接完成对具体产品的创建。工厂模式的好处是需要创建对象的时候只需要输入一个正确的参数就可以获得...
深拷贝简单的写法
大左的博客
04-18 318
let obj2 = JSON.parse(JSON.stringify(obj)) 原理：将obj对象转换成字符串 再将字符串重新变成一个对象 开辟内存空间 注意弊端：JSON.stringify（obj）在处理obj对象时 如果对象里面的值有正则的话 处理后正则值变成空字符串，还有函数与日期格式的对象在用JSON.stringify处理时都会出现bug ...
Java设计模式-7、原型模式-克隆对象（深浅克隆）
qq_43349162的博客
11-04 625
第7章：原型模式-克隆对象 定义： 在使用原型模式时，我们需要首先创建一个原型对象，再通过复制这个原型对象来创建更多同类型的对象。 通过克隆方法所创建的对象是全新的对象，它们在内存中拥有新的地址， 在Java中可以直接使用Object提供的**clone()**方法来实现对象的克隆， 能够实现克隆的Java类必须实现一个标识接口Cloneable，表示这个Java类支持被复制。如果一个类没实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异
spring事务详细讲解-深入浅出
小电玩
09-08 479
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1468
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 536
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
【学习笔记】手写 Tomcat 三
最新发布
LearnTech_123的博客
09-12 598
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值