Java大话设计模式学习总结（九）---原型模式

最新推荐文章于 2023-03-20 10:03:01 发布
最新推荐文章于 2023-03-20 10:03:01 发布
阅读量180 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式 原型模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a770794164/article/details/90605747
版权

原型模式（Prototype），用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
来自大话设计模式
Java当中，提供了Cloneable接口，实现了这个接口表示这个类支持被复制。如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常。

举例：
有一份简历，需要被复制成多份，发给不同的人，并且需要对简历的部分内容进行调整。

// 简历类
public class Resume implements Cloneable {
    private String name;
    private String sex;
    private int age;
    private String timeArea;
    private String company;
    
    public Resume(String name) {
        this.name = name;
    }
    
    // 设置个人信息
    public void setPersonalInfo(String sex,int age){
        this.sex = sex;
        this.age = age;
    }
    
    // 设置工作经历
    public void setWorkExperience(String timeArea,String  company){
        this.timeArea = timeArea;
        this.company= company;
    }
    
    // 展示
    public void show(){
        System.out.printf("%s %s %s", name, sex, age);
        System.out.println();
        System.out.printf("工作经历 %s %s", timeArea, company);
        System.out.println();
    }
    
    // 调用super.clone()方法，可以实现对该类的复制
    public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return new Resume("not support clone");
        }
    }
}

下面是主程序：

public class Test {

    public static void main(String[] args) {
        Resume a = new Resume("大鸟");
        a.setPersonalInfo("男", 24);
        a.setWorkExperience("1998-2000", "XX公司");
        
        Resume b = (Resume) a.clone();
        b.setWorkExperience("2000-2006", "YY公司");
        
        Resume c = (Resume) a.clone();
        c.setPersonalInfo("男", 29);
        
        a.show();
        b.show();
        c.show();
    }
}

运行结果如下：

大鸟 男 24
工作经历 1998-2000 XX公司
大鸟 男 24
工作经历 2000-2006 YY公司
大鸟 男 29
工作经历 1998-2000 XX公司

现在对工作经历进行调整，转化成一个工作经历类，包含工作时间和工作公司：

public class WorkExperience {
    private String timeArea;
    private String company;

    public String getTimeArea() {
        return timeArea;
    }

    public void setTimeArea(String timeArea) {
        this.timeArea = timeArea;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }
}

此时的简历类也做了调整，工作经历部分引用WorkExperience对象

public class Resume implements Cloneable {
    private String name;
    private String sex;
    private int age;
    
    // 调用workExperience对象
    private WorkExperience workExperience;
    
    public Resume(String name) {
        this.name = name;
        workExperience = new WorkExperience();
    }
    
    public void setPersonalInfo(String sex,int age){
        this.sex = sex;
        this.age = age;
    }
    
    // 设置工作经历
    public void setWorkExperience(String timeArea,String  company){
        workExperience.setTimeArea(timeArea);
        workExperience.setCompany(company);
    }
    
    public void show(){
        System.out.printf("%s %s %s", name, sex, age);
        System.out.printf("   工作经历 %s %s", workExperience.getTimeArea(), workExperience.getCompany());
        System.out.println();
    }
    
    public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return new Resume("not support clone");
        }
    }
}

主程序没有任何变化，为了方便展示结果，显示的时候将个人信息和工作经历显示在了一行，下面是运行结果：

public class Test {

    public static void main(String[] args) {
        Resume a = new Resume("大鸟");
        a.setPersonalInfo("男", 24);
        a.setWorkExperience("1998-2000", "XX公司");
        
        Resume b = (Resume) a.clone();
        b.setWorkExperience("2000-2006", "YY公司");
        
        Resume c = (Resume) a.clone();
        c.setPersonalInfo("男", 29);
        c.setWorkExperience("2006-2010", "ZZ公司");
        
        a.show();
        b.show();
        c.show();
    }
}
// 运行结果
大鸟 男 24   工作经历 2006-2010 ZZ公司
大鸟 男 24   工作经历 2006-2010 ZZ公司
大鸟 男 29   工作经历 2006-2010 ZZ公司

是不是很奇怪，为什么三份简历的工作经历都变成了最后一份简历的？但是个人信息却和之前clone的结果一样？
继续修改测试类：

public class Test {

    public static void main(String[] args) {
        Resume a = new Resume("大鸟");
        a.setPersonalInfo("男", 24);
        a.setWorkExperience("1998-2000", "XX公司");

        Resume b = (Resume) a.clone();
        b.setWorkExperience("2000-2006", "YY公司");

        Resume c = (Resume) a.clone();
        c.setPersonalInfo("男", 29);
        c.setWorkExperience("2006-2010", "ZZ公司");

        a.show();
        b.show();
        c.show();

        System.out.println("a简历和b简历的内存地址一样吗：" + (a == b));
        System.out.println("b简历和c简历的内存地址一样吗：" + (b == c));
        System.out.println("a简历和c简历的内存地址一样吗：" + (a == c));

        System.out.println("a工作经历和b工作经历的内存地址一样吗：" + (a.workExperience == b.workExperience));
        System.out.println("b工作经历和c工作经历的内存地址一样吗：" + (b.workExperience == c.workExperience));
        System.out.println("a工作经历和c工作经历的内存地址一样吗：" + (a.workExperience == c.workExperience));
    }
}

// 结果如下
大鸟 男 24   工作经历 2006-2010 ZZ公司
大鸟 男 24   工作经历 2006-2010 ZZ公司
大鸟 男 29   工作经历 2006-2010 ZZ公司
a简历和b简历的内存地址一样吗：false
b简历和c简历的内存地址一样吗：false
a简历和c简历的内存地址一样吗：false
a工作经历和b工作经历的内存地址一样吗：true
b工作经历和c工作经历的内存地址一样吗：true
a工作经历和c工作经历的内存地址一样吗：true

发现每一个clone出来的简历对象都是一个新的对象，但是每一份的工作经历对象，都采用的是同一个对象。
这就涉及到了浅复制与深复制的概念：

  1. 浅复制：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。
    就是说，每份简历操作的workExperience对象其实都是第一个简历对象中的工作经历对象。
  2. 深复制：把引用对象的变量指向复制过来的新对象，而不是原有的被引用对象。

怎么实现深复制呢？看代码：

// 工作经历类实现Cloneable接口
public class WorkExperience implements Cloneable{
    private String timeArea;
    private String company;

  // 采用clone方法复制，将生成新的对象
    public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println("clone error:" + e.getMessage());
            return new WorkExperience();
        }
    }
    
    // get/set方法省略
}

public class Resume implements Cloneable {
    private String name;
    private String sex;
    private int age;

    protected WorkExperience workExperience;

    public Resume(String name) {
        this.name = name;
        this.workExperience = new WorkExperience();
    }

    public void setPersonalInfo(String sex, int age) {
        this.sex = sex;
        this.age = age;
    }

    public void setWorkExperience(String timeArea, String company) {
        workExperience.setTimeArea(timeArea);
        workExperience.setCompany(company);
    }

    public void show() {
        System.out.printf("%s %s %s", name, sex, age);
        System.out.printf("   工作经历 %s %s", workExperience.getTimeArea(), workExperience.getCompany());
        System.out.println();
    }

   // 调整原先的clone方法，将workExperience属性也进行复制操作
    public Object clone() {
        try {
            Resume obj = (Resume) super.clone();
            obj.workExperience = (WorkExperience) this.workExperience.clone();
            return obj;
        } catch (CloneNotSupportedException e) {
            System.out.println("clone error:" + e.getMessage());
            return new Resume("error");
        }
    }
}

下面看主程序运行结果：

public class Test {

    public static void main(String[] args) {
        Resume a = new Resume("大鸟");
        a.setPersonalInfo("男", 24);
        a.setWorkExperience("1998-2000", "XX公司");

        Resume b = (Resume) a.clone();
        b.setWorkExperience("2000-2006", "YY公司");

        Resume c = (Resume) a.clone();
        c.setPersonalInfo("男", 29);
       //  c.setWorkExperience("2006-2010", "ZZ公司");

        a.show();
        b.show();
        c.show();

        System.out.println("a工作经历和b工作经历的内存地址一样吗：" + (a.workExperience == b.workExperience));
        System.out.println("b工作经历和c工作经历的内存地址一样吗：" + (b.workExperience == c.workExperience));
        System.out.println("a工作经历和c工作经历的内存地址一样吗：" + (a.workExperience == c.workExperience));
    }
}

// 运行结果
大鸟 男 24   工作经历 1998-2000 XX公司
大鸟 男 24   工作经历 2000-2006 YY公司
大鸟 男 29   工作经历 1998-2000 XX公司
a工作经历和b工作经历的内存地址一样吗：false
b工作经历和c工作经历的内存地址一样吗：false
a工作经历和c工作经历的内存地址一样吗：false

专门注释掉修改c简历的工作经历方法，就是为了更直观的查看工作经历是否都指向相同的内存地址，可以看到，现在各个简历中的工作经历已经和预期一致，而且a简历和c简历中，虽然工作经历相同，但是该对象已经是clone出来的一个新的对象。

一个胖子IT男
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大话模式源代码-02策略模式
07-22
大话模式源代码-02策略模式 多个案例源代码，均可直接使用
大话设计模式（Java代码）
qq_40460454的博客
03-10 2337
第一章 简单工厂模式 ​ 代码无错便是优？非也，想要达到高质量代码的水平，不止要满足当前的需求，程序不容易扩展， 不容易维护，不容易复用，也谈不上高质量。 ​ 为什么四大发明里是活字印刷而不是印刷术，因为活字印刷是思想上的胜利，可维护、可复用、可修改、可扩展。 ​ 面向对象的思维，使用封装继承多态把程序的耦合性降低，使用设计模式使得程序更加的灵活。 三种类型的设计模式： 序号 模式 & 描述 包括 1 创建型模式 这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是
大话设计模式（更新ing...）
qq_45599754的博客
10-17 1373
Java设计模式
java 原型模式
阿顾的博客
01-02 236
原型模式就是，我们需要对一个对象复制出一个新的对象，而且不知道任何创建的细节，并且复制出的新的对象我们可以定制化修改，不会影响原来的对象。本文通过简历的复制来分享原型模式，我们先看下初步代码 一 简历代码初步实现 1.1 简历类 /** * 简历类 */ public class Resume { private String name; private Strin...
设计模式之原型模式
laotou99的专栏
05-18 733
 public class PrototypeTest1{ public static void main(String[] args) throws CloneNotSupportedException { Resume a = new Resume("大鸟"); a.SetPersonalInfo("男","29"); a.SetWorkExpeie
原型模式（六）
nisen6477的博客
05-09 125
原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何的创建细节。 原型模式需要一个原型类，在Java中的Object类中有clone()方法，只需要实现Cloneable接口即可完成原型模式。 下面以写简历的例子来说明原型模式： 简历包含姓名，年龄以及工作经验信息 简历对象： public c...
读《大话设计模式》－代理模式(proxy)
02-03
代理模式(proxy)为其他对象提供一个代理以控制对这个对象的访问。结构图//Subject类，定义了RealSubjext和Proxy的公共接口，这样就在任何使用RealSubject的地方可以使用ProxyclassSubject{public:virtualvoidRequest...
大话设计模式-完整设计模式介绍
10-23
大话设计模式 完整设计模式介绍
Design-Pattern:Java实现的设计模式概念-阅读大话设计模式的注释
03-17
Java实现的设计模式-阅读大话设计模式的注释 创作模式 工厂方法 抽象工厂 建造者 原型 辛格尔顿 结构模式 适配器 桥 合成的 装潢师 正面 轻量级 代理人 行为模式 观察者 模板方法 命令 状态 责任链 口译员 调解员 ...
大话设计模式总结.pdf
03-29
大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf
《大话设计模式》java实现之状态模式
linlinxie的博客
11-17 1407
状态模式、策略模式、责任链模式三者非常像，今天花了很多时间查找他们之间的不同，博客https://www.cnblogs.com/xibei666/p/6858145.html总结得很好，这里简单总结一下。现在总结如下： UML图状态模式和策略模式基本一致 状态模式 策略模式 从UML图可以看出，状态模式和策略模式完全一样，细微的区别主要是状态模式各状态子类知道下一状态是谁，且要把逻
让你跟看小说一样有趣！大话设计模式【Java溢彩加强版】（2023）
老男孩的架构路
03-20 703
大话设计这本书我的观点不是掌握某个设计模式，而是从设计模式里去寻找OOP，解耦等思想，如何写出高可扩的程序，这才是最重要的。
java语言之Cloneable接口
runhwguo的专栏
11-04 684
在我们学习过程中，会发现java很多非常重要的接口，比如Cloneable，Serializable，Comparable等等之类的，今天我就总结一下Cloneable接口。 我学习到现在觉得最好的学习资源就是源码以及源码的注释，任何其他的都是对源码的翻译和解读，现在我就说说我对源码及注释的理解，如何大家想从源头上获取，建议大家看Cloneable接口和Object中的clone()方法。
Cloneable接口的作用与深入理解深度克隆与浅度克隆
热门推荐
qq_37113604的博客
07-23 5万+
cloneable接口的作用 cloneable其实就是一个标记接口，只有实现这个接口后，然后在类中重写Object中的clone方法，然后通过类调用clone方法才能克隆成功，如果不实现这个接口，则会抛出CloneNotSupportedException(克隆不被支持)异常。Object中clone方法： 这里有一个疑问，Object中的clone方法是一个空的方法，那么他是如何判断类...
《大话设计模式》-策略模式(Java)
One_Piece111的博客
07-26 303
策略模式是一种定义一系列算法的方法，从概念上来看，所有算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间耦合。另一个方面的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。设计模式回顾策略模式、代理模式、装饰者模式的区别。...
大话设计模式
chajinglong的专栏
12-01 2万+
真正意义上北京了三年零四个月了，有时候很无助，有时候很快乐，但大部分时间都是平淡无奇的，一起住了几年的大学室友回家了，怀踹着梦想，怀揣着希望，而我依旧孤独的在战斗，来也匆匆，去也匆匆，没有来的急好好说再见，也没有来得及......                               山居秋暝          唐·王维                               ...
大话设计模式-Java实现（16）-状态模式
qq_44458489的博客
03-30 155
状态模式（State），当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列当中，可以把复杂的判断逻辑简化。当然，如果这个状态判断很简单，那就没必要使用“状态模式”了。 举例： 在公司工作工作一天，每个阶段的工作状态都不同，比如上午会比较精神，中午困了需要休息，下...
大话设计模式之原型模式总结-java实现
勤劳的搬运工
09-03 446
注：示例来自《大话设计模式》 现有需求如下 要求有一个简历类 必须要有姓名 可以设置性别和年龄 可以设置工作经历 最终我需要写三份简历 代码初步实现如下 简历类 package Test09; //简历 public class Resume { private String name; private String sex; private String a...
大话设计模式java溢彩加强版pDF
最新发布
03-27
很抱歉，我无法提供或介绍任何版权受限的材料，包括大话设计模式java溢彩加强版PDF。但是，我可以为您提供一些关于设计模式的基本知识和相关资源。设计模式是一种解决软件设计问题的经验总结，它提供了一套可重用的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值