设计模式之原型模式（浅拷贝与深拷贝）

最新推荐文章于 2023-08-13 22:56:22 发布
最新推荐文章于 2023-08-13 22:56:22 发布
阅读量279 收藏 1
点赞数
分类专栏： 设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yfyh2021/article/details/120717280
版权
  • 模式定义

指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

  • 知识点

1.Cloneable接口/Object#clone方法 详解
2.浅拷贝/深拷贝
3.序列化机制实现深拷贝

  • 应用场景

当代码不应该依赖于需要复制的对象的具体类时，请使用Prototype模式。

  • 有点

1.可以不耦合具体类的情况下克隆对象
2.避免重复的初始化代码
3.更方便的构建复杂对象

  • 示例：

我们有一个类Product

class Product{
    private String part1;
    private String part2;
    private Integer part3;
    private Integer part4;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public Integer getPart3() {
        return part3;
    }

    public void setPart3(Integer part3) {
        this.part3 = part3;
    }

    public Integer getPart4() {
        return part4;
    }

    public void setPart4(Integer part4) {
        this.part4 = part4;
    }

    public Product(String part1, String part2, Integer part3, Integer part4) {
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3=" + part3 +
                ", part4=" + part4 +
                '}';
    }
}

我们在创建一群比较类似的对象时，以往就是不停的new

public class ProtoTypeTest {
    public static void main(String[] args) {
        Product product = new Product("part1","part2",3,4);
        //...new
    }
}

现在我们需要通过拷贝来实现

  1. 实现Cloneable接口。
  2. 实现Cloneable接口的clone方法。
class Product implements Cloneable{
    private String part1;
    private String part2;
    private Integer part3;
    private Integer part4;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public Integer getPart3() {
        return part3;
    }

    public void setPart3(Integer part3) {
        this.part3 = part3;
    }

    public Integer getPart4() {
        return part4;
    }

    public void setPart4(Integer part4) {
        this.part4 = part4;
    }

    public Product(String part1, String part2, Integer part3, Integer part4) {
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }

    @Override
    protected Product clone() throws CloneNotSupportedException {
        return ((Product) super.clone());
    }

    @Override
    public String toString() {
        return "hashcode:"+super.hashCode()+"|Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3=" + part3 +
                ", part4=" + part4 +
                '}';
    }
}

我们来看一下clone的对象

public class ProtoTypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Product product = new Product("part1","part2",3,4);
        //...new
        Product clone = product.clone();

        System.out.println("original: "+product);
        System.out.println("clone:    "+clone);
    }
}

通过hashcode我们发现这是clone出来的对象是与原对象不相关的新对象（没有依赖关系），clone的底层实现是native修饰的，说明是虚拟机帮我们来做的。

现在我们对象中全部是八中原生类型及其包装类型，string，bigInteger等都是属于不可变类型（immutable），所以我们可以用上面的方式进行实现，没有问题。但是如果对象中有引用类型就会有问题，如下：

class BaseInfo{
    private String companyName;

    public BaseInfo(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @Override
    public String toString() {
        return super.hashCode()+"|BaseInfo{" +
                "companyName='" + companyName + '\'' +
                '}';
    }
}

class Product implements Cloneable{
    private String part1;
    private String part2;
    private Integer part3;
    private Integer part4;
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public Integer getPart3() {
        return part3;
    }

    public void setPart3(Integer part3) {
        this.part3 = part3;
    }

    public Integer getPart4() {
        return part4;
    }

    public void setPart4(Integer part4) {
        this.part4 = part4;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    public Product(String part1, String part2, Integer part3, Integer part4, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
        this.baseInfo = baseInfo;
    }

    @Override
    protected Product clone() throws CloneNotSupportedException {
        return ((Product) super.clone());
    }

    @Override
    public String toString() {
        return super.hashCode()+"Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3=" + part3 +
                ", part4=" + part4 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

我们来测试一下：

public class ProtoTypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo baseInfo = new BaseInfo("xxx");
        Product product = new Product("part1","part2",3,4,baseInfo);
        //...new
        Product clone = product.clone();

        System.out.println("original: "+product);
        System.out.println("clone:    "+clone);

        product.getBaseInfo().setCompanyName("yyyy");
        System.out.println("original: "+product);
        System.out.println("clone:    "+clone);
    }
}

可以看到clone对象和原始对象中的baseInfo用的是同一个对象，当我们对原始对象的baseInfo进行修改后，发现clone对象和原始对象的baseInfo都修改了，这个时候说明我们的拷贝出问题了，原始对象和拷贝对象有了关系，产生了依赖，怎么解决呢？

我们有两种方式进行解决：

一是我们对被引用对象也实现Cloneable接口，然后修改引用对象的clone方法，直接在引用对象中的clone方法中实现对引用对象的拷贝，如下

 

class BaseInfo implements Cloneable{
    private String companyName;

    public BaseInfo(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @Override
    protected BaseInfo clone() throws CloneNotSupportedException {
        return ((BaseInfo) super.clone());
    }

    @Override
    public String toString() {
        return super.hashCode()+"|BaseInfo{" +
                "companyName='" + companyName + '\'' +
                '}';
    }
}

class Product implements Cloneable{
    private String part1;
    private String part2;
    private Integer part3;
    private Integer part4;
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public Integer getPart3() {
        return part3;
    }

    public void setPart3(Integer part3) {
        this.part3 = part3;
    }

    public Integer getPart4() {
        return part4;
    }

    public void setPart4(Integer part4) {
        this.part4 = part4;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    public Product(String part1, String part2, Integer part3, Integer part4, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
        this.baseInfo = baseInfo;
    }

    @Override
    protected Product clone() throws CloneNotSupportedException {
        Product clone = (Product) super.clone();
        BaseInfo clone1 = this.baseInfo.clone();
        clone.setBaseInfo(clone1);
        return clone;
    }

    @Override
    public String toString() {
        return super.hashCode()+"Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3=" + part3 +
                ", part4=" + part4 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

这时候我们再看一下运行结果，就发现clone出来的对象和原始对象已经没有依赖关系：

 如果我们的baseInfo中还有引用对象，那我们必须对改对象也实现cloneable接口。这就是深拷贝。

注意数组类型已实现cloneable接口，但是数组类型clone出来的是浅拷贝而不是深拷贝。

我们在拷贝的时候要注意浅拷贝和深拷贝，如果类中有引用类型时我们就要进行递归式的实现cloneable接口。

对于引用对象比较复杂的情况我们还有另一种方式来实现：序列化方式实现深拷贝，首先原始对象和其包含的引用对象都要实现序列化接口，然后通过流进行序列化操作，这种操作不推荐使用，会非常耗性能，具体如下：

class BaseInfo implements Cloneable,Serializable{
    private static final long serialVersionUID = 42L;
    private String companyName;

    public BaseInfo(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @Override
    protected BaseInfo clone() throws CloneNotSupportedException {
        return ((BaseInfo) super.clone());
    }

    @Override
    public String toString() {
        return super.hashCode()+"|BaseInfo{" +
                "companyName='" + companyName + '\'' +
                '}';
    }
}

class Product implements Cloneable,Serializable{
    private static final long serialVersionUID = 42L;
    private String part1;
    private String part2;
    private Integer part3;
    private Integer part4;
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public Integer getPart3() {
        return part3;
    }

    public void setPart3(Integer part3) {
        this.part3 = part3;
    }

    public Integer getPart4() {
        return part4;
    }

    public void setPart4(Integer part4) {
        this.part4 = part4;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    public Product(String part1, String part2, Integer part3, Integer part4, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
        this.baseInfo = baseInfo;
    }

    @Override
    protected Product clone() throws CloneNotSupportedException {
        /*Product clone = (Product) super.clone();
        BaseInfo clone1 = this.baseInfo.clone();
        clone.setBaseInfo(clone1);*/
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(bos)){
            oos.writeObject(this);
        } catch (IOException e) {
            e.printStackTrace();
        }
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        try (ObjectInputStream ois = new ObjectInputStream(bis);){
                Product object =(Product) ois.readObject();
                return object;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e){
            e.printStackTrace();;
        }
        return null;
    }

    @Override
    public String toString() {
        return super.hashCode()+"Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3=" + part3 +
                ", part4=" + part4 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

我们看一下运行结果：也是可以的 

  • 源码中的应用

org.springframework.beans.factory.support.AbstractBeanDefinition

java.util.Arrays

 

yfyh2021
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式-值类型与引用类型、深拷贝与浅拷贝、原型模式详解
Linuxhus的博客
02-11 696
(1). 分类值类型包括：布尔类型、浮点类型(float、double、decimal、byte)、字符类型(char)、整型（int、long、short等）、枚举(entum)、结构体(struct)。引用类型：数组、字符串(string)、类、接口、委托(delegate)。(2).内存存储值类型数据存放在栈stack中， 引用类型地址存放栈stack中，数据存放在堆heap中。值类型变量声明后，不管是否赋值，都会在在栈中分配内存空间。
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】
03-31
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】 * 原型模式(Prototype) * 实现方式： * 需要被克隆的 class类， 重写Object中的clone()方法，并实现Cloneable接口（否则报错 ...
设计模式之原型模式（对象深拷贝与浅拷贝）
weixin_63834061的博客
04-25 460
用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象，通俗点说就是对象的拷贝，而这种拷贝又可以分为深拷贝与浅拷贝，往后我们会深入叙述。
设计模式——原型设计模式（浅拷贝+深拷贝）
zjcoming
03-08 459
什么是原型设计模式 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 说白了原型模式就是通过拷贝的方式创建你要的对象，要拷贝得有个前提就是得先有一个模型。 案例引出（为什么需要原型模式？& 什么时候需要？） 举个例子，比如有一天，周杰伦到奶茶店点了一份不加冰的原味奶茶，你说我是周杰伦的忠实粉，我也要一份跟周杰伦一样的。用程序表示如下： 奶茶类： public class MilkTea { public String type; public bo..
原型模式 --- 深拷贝&浅拷贝
m0_73302761的博客
08-13 60
**不复制引用类型指向的对象本身。**浅拷贝可以用于一些简单的场景，例如对象的基本属性不包含其他对象的引用类型，或者不需要修改对象引用类型所指向的对象。注意跟下面的set()做好区分，因为涉及到扩容，所以原型模式是用不了的，在set()方法里面是用的原型设计模式。然而，在需要快速创建具有相似属性的新对象时，原型设计模式提供。深拷贝的实现，通常有两个思路，一个是递归克隆，一个是使用序列化的手段，我们分别对以下两种方式进行讲解。在Java编程中，浅拷贝是指在复制对象时，
使用Java实现克隆模式（原型模式）
m0_59996263的博客
02-21 371
复制一份代码，也就是把构造函数的参数设置一份一模一样的创建一个新的实例。这个是最简单实现。但是有一个缺点，实际开发中，对象的参数很多，然后买同样一款手机的人也很多，这样我们就要手动复制很多份代码设置超级多的参数，会让代码看着很臃肿。做为一个优雅的程序员，这种重复性的脏话，我们是要想办法避免的。下面我们使用浅克隆来实现自动复制属性。
原型模式中浅克隆和深克隆
HELLOW，文浩
04-26 371
原型模式 所谓的原型模式，无非就是从一个对象再创建另一个可定制的对象，而且不需要知道任何创建的细节。所谓的原型模式，其实质就是编程需要中的克隆技术，以某个对象为原型，复制出新的对象。只是需要注意深复制与浅复制的问题。 其实关于原型模式，大话设计模式这本书中的相关实例已经说明的比较通俗了，这里只是重新梳理深复制与浅复制的区别和实例 浅复制 Java中针对基本数据类型的成员变量，在浅复制的时候...
设计模式之原型模式
01-08
总之，原型模式通过提供一种复制现有对象而非新建对象的方式来简化对象的创建过程，它可以是浅拷贝或深拷贝，具体取决于实际需求。在Java等支持对象拷贝的语言中，原型模式是一种常用的设计模式，特别是在需要高效...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...
C++设计模式之原型模式
09-04
原型模式是一种创建型设计模式，它提供了一种创建对象的新方式，通过复制现有的对象来创建新对象，而不是通过传统的构造函数。在C++中，原型模式通常涉及到对象的深拷贝或浅拷贝，用于避免复杂的初始化过程或者当...
ava常用设计模式-原型模式
最新发布
08-26
* 在需要实现浅拷贝或深拷贝时，使用原型模式可以根据需要选择合适的拷贝方式。 * 在运行时动态地创建对象时，使用原型模式可以在不需要在编译时确定对象的数量和类型的情况下创建对象。 原型模式是一种非常有用的...
设计模式——原型模式（浅拷贝和深拷贝）
Strine的博客
05-04 645
当类需要通过原型模式进行拷贝的时候，如果原型类里面的属性没有引用类型，或者引用类型较少，且该类的属性不会频繁修改的情况下，我们可以使用浅拷贝； 但如果引用类型较多，或者后期需要添加或者修改里面的引用类型的属性时，我们选择深拷贝；
原型模式（深克隆、浅克隆）
weixin_51201930的博客
04-23 2324
文章目录前言一、原型模式定义二、原型模式的结构与实现三、案例 前言 一、原型模式定义 原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。 二、原型模式的结构与实现 原型模式有以下三种角色： 1.抽象原型类：规定了具体原型对象必须实现的接口。 2.具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对
23模式---原型模式（浅拷贝和深拷贝）
u011863822的博客
10-27 644
本篇主要聊的就是原型模式，同时通过java代码进行了简单的演示。
设计模式之原型模式（深拷贝&浅拷贝）
weixin_64366370的博客
05-01 667
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式之一。
原型模式之深拷贝
二月鸟
04-24 550
原型模式基本介紹 原型模式(Prototype模式)是指: 用原型实力指定创建对象的种类，并且通过拷贝这些原型，创建新的対象 2)原型模式是一神创建型设计模式，允许一个対象再创建另外一个可定制的対象，无需知道如何创建的细节 3)工作原理是:通过将一个原型対象传给那个要发动创建的対象，这个要发动创建的対象通过请求原型対象拷贝他们自己来实施创建，即対象.clone() 4)形象的理解:孙猴子拔猴毛，...
设计模式之【原型模式】，深入理解深拷贝与浅拷贝
秃了也弱了
12-16 753
原型模式： 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。对于熟悉 JavaScript 语言的前端程序员来说，原型模式是一种比较常用的开发模式。这是因为，有别于 Java、C++ 等基于类的面向对象编程语言，JavaScript 是一种基于原型的面向对象编程语言。即便 JavaScript 现在也引入了类的概念，但它也只是基于原型的语法糖而已。不过，如果你熟悉的是 Java、C++ 等这些编程语言，那在实际的开发中，就很少用到原型模式了。
原型模式--深拷贝和浅拷贝
gangxuec的博客
05-04 1042
Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype. （使用原型实例指定将要创建的对象类型，通过复制这个实例创建新的对象。从定义中我们我们可以发现，该模式的前提是首先需要有一个对象，然后基于已有的对象复制生成新的对象，新生成的对象状态和原对象是一样的，不一样的是内存地址。
常用设计模式系列（五）—原型模式（深拷贝和浅拷贝）
Java之路艰难，要以高内聚低耦合的目标去设计
12-27 493
讲解原型模式的深拷贝与浅拷贝，完成快速搞笑的拷贝对象，真假悟空
为什么spring的原型模式使用浅拷贝
07-12
Spring框架选择使用浅拷贝的原因主要有两个...因此，对于Spring框架而言，使用浅拷贝是一种合理的设计选择。需要注意的是，在使用原型模式时，开发者需要根据具体需求考虑对象关联性和性能因素，选择适合的拷贝方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值