原型模式与深浅拷贝

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

1. 原型模式

原型模式：用于创建重复的对象同时又能保证性能。属于创建型设计模式的范畴，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

2. 克隆羊问题

2.1、传统创建克隆对象
class Sheep{
    private String name;
    private int age;
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

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

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

    @Override
    public String toString() {
        return "Sheep{" + "name=" + name + ", age=" + age + "}";
    }
}
public class ProtoType01 {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("亨利",2);
        Sheep sheep2 = new Sheep(sheep1.getName(),sheep1.getAge());
        Sheep sheep3 = new Sheep(sheep1.getName(),sheep1.getAge());
        Sheep sheep4 = new Sheep(sheep1.getName(),sheep1.getAge());
        Sheep sheep5 = new Sheep(sheep1.getName(),sheep1.getAge());


        System.out.println("sheep1 = " + sheep1.toString());
        System.out.println("sheep2 = " + sheep2.toString());
        System.out.println("sheep3 = " + sheep3.toString());
        System.out.println("sheep4 = " + sheep4.toString());
        System.out.println("sheep5 = " + sheep5.toString());

    }
}

  1. 优点：简单易操作、容易理解。

  2. 缺点：

    1. 在创建新的对象时、需要重新获取原始对象的属性，如果创建的对象比较复杂时效率较低，因为需要不断地get方法调用获取属性值

    2. 需要重新初始化对象，而且不能动态的获得对象的运行状态，灵活读低。


2.2、原型模式创建

通过实现Cloneable接口，并且重写clone方法；最后调用.clone完成克隆。

class Sheep implements Cloneable{
    private String name;
    private int age;
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

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

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

    @Override
    protected Object clone(){
        Sheep sheep = null;
        try{
            sheep = (Sheep) super.clone();
        } catch(Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }

    @Override
    public String toString() {
        return "Sheep{" + "name=" + name + ", age=" + age + "}";
    }
}
public class ProtoType02 {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("亨利",2);

        Sheep sheep2 = (Sheep) sheep1.clone();
        Sheep sheep3 = (Sheep) sheep1.clone();
        Sheep sheep4 = (Sheep) sheep1.clone();
        Sheep sheep5 = (Sheep) sheep1.clone();
        
        System.out.println("sheep1 = " + sheep1.toString());
        System.out.println("sheep2 = " + sheep2.toString());
        System.out.println("sheep3 = " + sheep3.toString());
        System.out.println("sheep4 = " + sheep4.toString());
        System.out.println("sheep5 = " + sheep5.toString());

    }
}

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

  2. 缺点：需要对类的功能进行全局的考虑，必须实现Cloneable接口。


3. 浅拷贝

  1. 对于基本数据类型的成员变量，浅拷贝会直接进行值的传递，换句话说就是将值复制一份然后给新的对象。

  2. 对于引用类型的成员变量，例如：数组、类对象…浅拷贝会进行引用的传递，知识简单的将成员变量的内存地址（引用值）复制一份给新的对象。最后二者都指向同一个内存地址，当一个对象中修改了这个成员变量，另一个对象也会受到影响。

class Cow{
    public String name;
    public int age;

    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

class Sheep implements Cloneable{
    public String name;
    public int age;
    public Cow friend;

    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone(){
        Sheep sheep = null;
        try{
            sheep = (Sheep) super.clone();
        } catch(Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }

    @Override
    public String toString() {
        return "Sheep{" + "name='" + name + '\'' + ", age=" + age + ", friend=" + friend + '}';
    }
}
public class Shallow {

    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("亨利",2);
        Cow cow = new Cow("玛丽",5);
        sheep1.friend = cow;
        Sheep sheep2 = (Sheep) sheep1.clone();
        Sheep sheep3 = (Sheep) sheep1.clone();


        System.out.println("sheep1.hashCode(): " + sheep1.hashCode() + ",  sheep1 -> friend: " + sheep1.friend.hashCode());
        System.out.println(sheep1.toString());
        System.out.println("-------------------------------------------------------------------");
        System.out.println("sheep2.hashCode(): " + sheep2.hashCode() + ",  sheep2 -> friend: " + sheep2.friend.hashCode());
        System.out.println(sheep2.toString());
        System.out.println("-------------------------------------------------------------------");
        System.out.println("sheep3.hashCode(): " + sheep3.hashCode() + ",  sheep3 -> friend: " + sheep3.friend.hashCode());
        System.out.println(sheep3.toString());

        System.out.println("\n\n\n\n");

        sheep1.friend.name = "杰克";         //改变friend的属性
        sheep1.friend.age = 1;
        System.out.println("sheep1.hashCode(): " + sheep1.hashCode() + ",  sheep1 -> friend: " + sheep1.friend.hashCode());
        System.out.println(sheep1.toString());
        System.out.println("-------------------------------------------------------------------");
        System.out.println("sheep2.hashCode(): " + sheep2.hashCode() + ",  sheep2 -> friend: " + sheep2.friend.hashCode());
        System.out.println(sheep2.toString());
        System.out.println("-------------------------------------------------------------------");
        System.out.println("sheep3.hashCode(): " + sheep3.hashCode() + ",  sheep3 -> friend: " + sheep3.friend.hashCode());
        System.out.println(sheep3.toString());

    }
}

在这里插入图片描述

在这里插入图片描述


4. 深拷贝

  1. 基本数据类型：复制对象的所有基本数据类型的成员变量值

  2. 引用类型：为所有的引用类型的成员变量申请空间，同时将引用对象的数据赋值到新的空间中。

  3. 深拷贝的两种实现：重写clone方法 或者 通过序列化。

4.1、重写clone方法

  1. 先创建一个sheep变量，并且调用super. clone方法对基本数据类型进行拷贝

  2. 创建引用类型的成员变量，该成员变量调用sheep.成员.clone进行对引用类型的变量深拷贝。

  3. 需要注意的是，如果引用类型内部也有引用类型，引用类型也需要进行深拷贝；例如：A 有 引用B，B有引用C。C必须进行深拷贝、然后B进行深拷贝、最后A进行深拷贝。

  4. 自身类也需要实现Cloneable接口，所有的引用类型都需要实现Cloneable接口，这里的所有也包括引用中的引用。

class Cow implements Cloneable{
    public String name;
    public int age;

    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() {
        //只有基本数据类型 和 String, 直接浅拷贝即可。
        Cow cow = null;
        try{
            cow = (Cow) super.clone();
        } catch (Exception e){
            e.printStackTrace();
        }
        return cow;
    }
}

class Sheep implements Cloneable{
    public String name;
    public int age;
    public Cow friend;

    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone(){
        Sheep sheep = null;
        try{
            sheep = (Sheep) super.clone();          //浅拷贝基本数据类型
            Cow cow = (Cow) sheep.friend.clone();   //调用引用类型的成员变量的clone方法进行拷贝
            sheep.friend = cow;                     //替换
        } catch(Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }

}
public class Deep {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("山羊", 2);
        sheep1.friend = new Cow("奶牛",2);
        
        Sheep sheep2 = (Sheep) sheep1.clone();

        System.out.println("sheep1.hashCode = " + sheep1.hashCode() + ", sheep1.friend.hashCode =  " + sheep1.friend.hashCode());
        System.out.println("sheep2.hashCode = " + sheep2.hashCode() + ", sheep2.friend.hashCode =  " + sheep2.friend.hashCode());
    }
}

在这里插入图片描述

注意：需要注意的就是引用类型内部如果也有引用类型，也需要进行深拷贝！


4.2、通过序列化（推荐使用）

  1. 序列化：将数据对象转为字节序列的过程

  2. 反序列化：将字节序列重新转化为对象的过程。

  3. 序列化需要使用的两个类：ObjectOutputStream类用于序列化、ObjectInputStream用于反序列化。

  4. 由于序列化（反序列化）不一定需要将对象写入到磁盘（读入），因此可以使用ByteArrayInputStream 和 ByteArrayOutputStream。

  5. 首先使用ObjectOutputStream类将对象写入到ByteArrayOutputStream中，然后将ByteArrayOutputStream中的字节序列递交给ByteArrayInputStream，最后使用ObjectInputStream将ByteArrayInputStream中的字节序列重新反转为一个对象。

在这里插入图片描述

import java.io.*;

class Cow implements Serializable {
    public String name;
    public int age;

    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Sheep implements Serializable{
    public String name;
    public int age;
    public Cow friend;

    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Sheep deepCopy(){
        Sheep sheep = null;
        ObjectOutputStream oos = null;
        ByteArrayOutputStream bos = null;

        ObjectInputStream ois = null;
        ByteArrayInputStream bis = null;
        try{
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            sheep = (Sheep)ois.readObject();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sheep;
    }
}
public class Serial {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("小羊",2);
        sheep1.friend = new Cow("奶牛",2);

        Sheep sheep2 = sheep1.deepCopy();

        System.out.println("sheep1.hashCode = " + sheep1.hashCode() + ", sheep1.friend.hashCode =  " + sheep1.friend.hashCode());
        System.out.println("sheep2.hashCode = " + sheep2.hashCode() + ", sheep2.friend.hashCode =  " + sheep2.friend.hashCode());
    }
}

在这里插入图片描述

注意：实现序列化的对象，包括引用类都需要实现Serializable接口！

其他的注意事项点击这里：点我


5. 总结

优点：

  • 创建对象比较复杂时，利用原型模型简化对象的创建过程，提高开发效率。

  • 不用重新初始化对象，而是动态获取；当原始对象增加或者减少属性时，其克隆对象也会发生相应的变化，无需修改代码。

缺点：

  • 需要为每一个类都实现克隆接口，并且重写克隆方法！

  • 当对已经存在的类进行改变时需要修改源代码，违背了开闭原则（OCP）；

Splaying
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之原型模式以及深浅拷贝的区别
weixin_62421895的博客
08-06 160
原型设计模式（Prototype Design Pattern）指用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在Java语言中就存在克隆的方式，比如浅拷贝和深拷贝。对于一般的对象创建，本身不会花费太多的资源，但是对于负责的对象，比如对象的数据需要经过复杂的计算才能得到（比如排序、计算哈希值），抑或是需要从 RPC、网络、数据库、文件系统等非常慢速的IO中读取，这个时候就可以利用原型模式从其他对象直接拷贝，从而减少资源的消耗。...
C#深浅拷贝的深入解析
12-25
前面我们学习完了设计模式，在其中我们有了解到原型模式。这里涉及到了克隆自身对象。那么也就是对对象进行拷贝。这里就涉及到了这么一个概念。深浅拷贝、何为深拷贝何为浅拷贝呢？我们一起来看看吧。 浅拷贝 首先...
设计模式之原型模式与深浅拷贝
玄霄
05-28 444
原型模式原型模式背景克隆问题改进代码应用场景浅拷贝深拷贝注意事项与细节 原型模式 背景 克隆问题 类似过程： //原始对象 User user=new User(); user.setName("..."); //...对象属性的操作； //如果需要克隆三个对象； User user1=new User(); user1.setName(user.getName()); //...user1设置属性 User user2=new User(); user2.setName(user.getName())
原型模式与深浅拷贝（克隆）
尽人事，听天命
04-14 149
原型模式简述 先简单的说一下原型模式，原型模式属于创建型模式，和单例模式属于同一个大类，都是用来生成的对象的，与 java 中的 new 不同，原型模式会把一个对象的属性值拷贝一份复制给另外一个对象。而 new 需要传入需要的参数，不如原型模式方便。 示例代码 //需要实现 Cloneable 接口 class Test implements Cloneable{ public int t...
Java设计模式之原型模式与深浅拷贝
李阳阳的博客
01-31 218
概述 原型模式是一种创建型模式,允许用户从一个样板实例中复制出一个内部属性一致的对象,俗称为克隆.被复制出来的实例就是我们所称的原型. 多用在创建实例比较复杂或者耗时的情况下,因为复制一个已经存在的实例可以使程序运行更高效. 定义 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 使用场景 类初始化需要消化非常多的资源，通过原型拷贝避免这些消耗通过 new 产
原型模式，深浅拷贝
baidu_28196435的博客
02-03 164
原型模式 原型模式是一个比较简单的创建模式，在java中当需要创建大量对象的时候，为了提升效率和性能，我们可以使用原型模式 原型模式一般和工厂模式配合使用，用来创建对象 下面介绍java的原型模式实现过程 Java的Object类中具有clone方法，这表示任何对象都可以实现克隆，如下所示 package com.natsuki; import java.util.Date; /** * ...
设计模式-原型模式的深浅拷贝
weixin_46564011的博客
09-13 108
【代码】设计模式-原型模式的深浅拷贝。
原型模式 java 深浅_java常用设计模式之原型模式及深浅拷贝
weixin_42127783的博客
02-25 94
原型模式(Prototype Pattern)是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。Prototype类需要具备以下两个条件：1、实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的...
设计模式之原型模式（深浅拷贝的差别和写法）
android_seven的博客
11-10 225
设计模式之原型模式，以及深浅拷贝的写法和差别
原型模式 java 深浅_java常用设计模式原型模式及深浅拷贝
weixin_39535287的博客
02-25 58
原型模式(Prototype Pattern)是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。Prototype类需要具备以下两个条件：1、实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的...
设计模式：创建型之原型（深浅拷贝）、单例（饿汉式与懒汉式），三大工厂模式 结构型之适配器模式，代理模式（三大代理）
最新发布
04-25
原型模式用来解决对象的创建问题，它是指用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的对象 工厂模式将目的将创建对象的具体过程屏蔽隔离起来、解耦：将对象的创建和使用的过程...
前端 二阶段 js 复习总纲规划
03-27
包含了js 的所有的知识点，包括 js 基础知识，es6，正则，promise,事件轮询，定时器，跨域，继承，深浅拷贝，闭包，设计模式，前后端交互等等，复习总纲。方便大家查询与复习，对于初学JS学员来说可以少走很多弯路...
lanius-assessment:后端开发面试评估
03-16
3. 设计模式：理解常见的设计模式，如工厂模式、单例模式、观察者模式等，及其在JavaScript中的应用。 4. 测试驱动开发：TDD（Test-Driven Development）的基本理念，以及Mocha、Chai等测试框架的使用。 5. 开发流程...
UML类图
weixin_43808717的博客
05-02 1481
1. UML简介 UML：统一建模语言，是一种用于软件系统分析和设计的语言工具，它用于帮助软件开发人员进行思考和记录思路的结果。 UML本身是一套符号的规定，就像数学符号一样，这些符号用于描述软件模型中的各个元素和他们之间的关系。比如类、接口、实现、泛化、依赖、组合、聚合… 2. UML基本符号含义 2.1、类、抽象类、接口的表示 普通类：直接写类名，属性、方法。 抽象类：类名是斜体，属性，方法。 接口：在接口名上方加入<< interface >>，再写
C++设计模式：TemplateMethod模式（一）
weixin_43808717的博客
04-03 1363
定义一个操作中的算法的骨架结构（稳定），而将一些步骤延迟（变化）到子类中。Template Method使得子类可以不改变（复用）一个算法的骨架结构即可重定义（override重写）该算法的某些特定步骤在软件构建过程中，对于某一项任务，它常常有稳定的整体操作结构，但是各个子步骤却有很多改变的需求，或者由于固有的原因（比如框架与应用之间的关系）而无法和任务的整体结构同时实现如何在确定稳定操作结构的前提下，来罗应对各种各个子步骤的变化或者晚期实现需求？
C++设计模式：策略模式（二）
weixin_43808717的博客
04-05 1253
定义一系列算法，把它们一个个封装起来，并且使它们可互相替换（变化），该模式使得算法可独立于使用它的客户程序（稳定）而变化（扩展，子类化）在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都硬编码到对象中，将会使对象变得异常复杂；而且有时候支持不适用的算法也是一个性能负担（代码段过长）如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免上述问题？Strategy及其子类为组件提供了一系列的可重用的算法，从而可以使得类型在运行时。
C++设计模式：装饰器模式（四）
weixin_43808717的博客
04-06 1145
装饰器模式定义：动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码 & 减少子类个数）。在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？
原型Prototype模式解析与应用
"原型Prototype模式的由来-设计模式PPT" 设计模式是一种在软件设计中被广泛应用的，解决常见问题的可复用方案。原型（Prototype）模式作为创建型设计模式之一，其主要目的是通过复制已有对象来创建新对象，而不是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值