设计模式——原型模式

最新推荐文章于 2022-10-12 16:11:54 发布
最新推荐文章于 2022-10-12 16:11:54 发布
阅读量69 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stonney/article/details/110912418
版权

场景：
写好多份简历

初步实现：
工作经历类：

package Prototype;

import java.io.Serializable;

public class workExperience implements Serializable {
    private String workdate;
    private String workCompany;
    public String getWorkdate() {
        return workdate;
    }
    public workExperience setWorkdate(String workdate) {
        this.workdate = workdate;
        return this;
    }
    public String getWorkCompany() {
        return workCompany;
    }
    public workExperience setWorkCompany(String workCompany) {
        this.workCompany = workCompany;
        return this;
    }
}

Resume类：

package Prototype;

import java.io.*;
import java.nio.file.Watchable;

public class Resume implements Cloneable, Serializable {
    private String name;
    private String gender;
    private int age;
    private workExperience we;
    public Resume(){
        we = new workExperience();
    }
    public void display(){
        System.out.println(this.getName()+this.getGender()+this.getAge()+this.getWorkExperience().getWorkdate()+this.getWorkExperience().getWorkCompany());
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public workExperience getWorkExperience(){
        return we;
    }

    public void setWorkExperience(String workDate,String workCompany){
        we.setWorkdate(workDate);
        we.setWorkCompany(workCompany);
    }

    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);

        return ois.readObject();
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

客户端：

package Prototype;
public class MainTest {
    public static void main(String[] args) {
        Resume a= new Resume();
        a.setName("a");
        a.setAge(18);
        a.setGender("女");
        a.setWorkExperience("2008-2015","xx");

        Resume b = new Resume();
        b.setName("a");
        b.setAge(18);
        b.setGender("女");
        b.setWorkExperience("2008-2015","xx");
        a.display();
        b.display();
    }
}

在这里插入图片描述
但这样的客户端是很麻烦的，每次都需要实例化，如果写错一个字，每次都需要改
如果改成下面这种：在这里插入图片描述
这是在传引用，而不是传值，这样做就如同在b纸张和c纸张上写着：简历在a处一样，没有实际内容。所以应该用clone的方法

clone分为深拷贝和浅拷贝，其实现方式是通过调用Object类的clone方法来完成。在Obiect.class类中，源码为：
protected native Object clone() throws CloneNotSupportedException;

Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。
在这里插入图片描述
上图定义的 a 和 b 都是基本类型，其值是直接存放在栈中的；而 c 和 d 是 String 声明的，这是一个引用类型，引用地址是存放在 栈中，然后指向堆的内存空间。
在这里插入图片描述
d = c；这条语句表示将 c 的引用赋值给 d，那么 c 和 d 将指向同一块堆内存空间。

浅拷贝：

package Clone;

import java.io.*;

public class Person implements Cloneable , Serializable {
    public String name;
    public int page;
    public Address address;

    public Person(String name, int page) {
        this.name = name;
        this.page = page;
        this.address = new Address();
    }

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

    public String getName() {
        return name;
    }

    public int getPage() {
        return page;
    }

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

    public void setPage(int page) {
        this.page = page;
    }

    public void setAddress(String provices,String city) {
        address.setAddress(provices,city);
    }

    public void display(String displayname){
        System.out.println(displayname+"name"+name+",page"+page+",address"+address);
    }

  
}


package Clone;
import java.io.Serializable;
public class Address implements Serializable {
    private String provices;
    private String city;
    public void setAddress(String provices,String city){
        this.provices = provices;
        this.city = city;
    }
    @Override
    public String toString() {
        return "Address{" +
                "provices='" + provices + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

客户端：

package Clone;

public class shallowClone {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person("yan",23);
        p1.setAddress("山西省","汾阳市");
        Person p2 =(Person) p1.clone();
        System.out.println("p1"+p1);
        System.out.println("p1.getname"+p1.getName().hashCode());
        System.out.println("p2"+p2);
        System.out.println("p2.getname"+p2.getName().hashCode());

        p1.display("p1");
        p2.display("p2");
        p2.setAddress("北京","北京");
        System.out.println("只修改p2");
        p1.display("p1");
        p2.display("p2");
    }
}

在这里插入图片描述
调用对象的 clone 方法，必须要让类实现 Cloneable 接口，并且覆写 clone 方法。
但是只修改了p2，却将p1也修改了，也就是说对象 Person 的属性 Address，经过 clone 之后，其实只是复制了其引用，他们指向的还是同一块堆内存空间，当修改其中一个对象的属性 Address，另一个也会跟着变化。

浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。

深拷贝：
利用序列化：注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

//深度拷贝
public Object deepClone() throws Exception{
    // 序列化
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);

    oos.writeObject(this);

    // 反序列化
    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);

    return ois.readObject();
}

address类改为如下：

package Clone;

import java.io.*;

public class Person implements Cloneable , Serializable {
    public String name;
    public int page;
    public Address address;

    public Person(String name, int page) {
        this.name = name;
        this.page = page;
        this.address = new Address();
    }

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

    public String getName() {
        return name;
    }

    public int getPage() {
        return page;
    }

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

    public void setPage(int page) {
        this.page = page;
    }

    public void setAddress(String provices,String city) {
        address.setAddress(provices,city);
    }

    public void display(String displayname){
        System.out.println(displayname+"name"+name+",page"+page+",address"+address);
    }

    //深度拷贝
    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);

        return ois.readObject();
    }
}

客户端：

package Clone;

public class Clone {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person("yan",23);
        p1.setAddress("山西省","汾阳市");
        Person p2 =(Person) p1.deepClone();
        System.out.println("p1"+p1);
        System.out.println("p1.getname"+p1.getName().hashCode());
        System.out.println("p2"+p2);
        System.out.println("p2.getname"+p2.getName().hashCode());

        p1.display("p1");
        p2.display("p2");
        p2.setAddress("北京","北京");
        System.out.println("只修改p2");
        p1.display("p1");
        p2.display("p2");
    }
}

在这里插入图片描述
原型模式：
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象
在这里插入图片描述
简历类：

package Prototype;

import java.io.*;
import java.nio.file.Watchable;

public class Resume implements Cloneable, Serializable {
    private String name;
    private String gender;
    private int age;
    private workExperience we;
    public Resume(){
        we = new workExperience();
    }
    public void display(){
        System.out.println(this.getName()+this.getGender()+this.getAge()+this.getWorkExperience().getWorkdate()+this.getWorkExperience().getWorkCompany());
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public workExperience getWorkExperience(){
        return we;
    }

    public void setWorkExperience(String workDate,String workCompany){
        we.setWorkdate(workDate);
        we.setWorkCompany(workCompany);
    }

    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);

        return ois.readObject();
    }


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


package Prototype;

import java.io.*;
import java.nio.file.Watchable;

public class Resume implements Cloneable, Serializable {
    private String name;
    private String gender;
    private int age;
    private workExperience we;
    public Resume(){
        we = new workExperience();
    }
    public void display(){
        System.out.println(this.getName()+this.getGender()+this.getAge()+this.getWorkExperience().getWorkdate()+this.getWorkExperience().getWorkCompany());
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public workExperience getWorkExperience(){
        return we;
    }

    public void setWorkExperience(String workDate,String workCompany){
        we.setWorkdate(workDate);
        we.setWorkCompany(workCompany);
    }

    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);

        return ois.readObject();
    }


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

工作经历类：

package Prototype;

import java.io.Serializable;

public class workExperience implements Serializable {
    private String workdate;
    private String workCompany;

    public String getWorkdate() {
        return workdate;
    }

    public workExperience setWorkdate(String workdate) {
        this.workdate = workdate;
        return this;
    }

    public String getWorkCompany() {
        return workCompany;
    }

    public workExperience setWorkCompany(String workCompany) {
        this.workCompany = workCompany;
        return this;
    }
}

客户端：

package Prototype;
public class Client {
    public static void main(String[] args) throws Exception {
        System.out.println("浅度拷贝");
        Resume r1 = new Resume();
        r1.setName("a");
        r1.setAge(25);
        r1.setGender("男");
        r1.setWorkExperience("2000-2009","xx");
        r1.display();
        Resume r2 = (Resume)r1.clone();
        System.out.println("仅修改r2");
        r2.setWorkExperience("2000-2009","YY");

        r1.display();
        r2.display();
        System.out.println("深度拷贝");
        Resume r3 = (Resume)r1.deepClone();
        r3.setWorkExperience("2018-2020","ww");
        r1.display();
        r3.display();
    }
}

在这里插入图片描述
浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象；
深拷贝：把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象

stonney
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity设计模式——原型模式
问渠哪得清如许，为有源头活水来
01-31 378
原型模式是一种创造性模式，它通过复制一个已有对象来获取更多相同或者相似地对象。原型模式可以提高相同类型对象的创造效率，简化创建流程。让我们来看看Unity里怎么使用原型模式。
Java 设计模式——原型模式
代码星辰的博客
07-22 1346
本文介绍了原型模式的相关知识。
Python设计模式——原型模式
钟灵毓秀的博客
10-12 883
设计模式之原型模式，python代码实现与总结
C++设计模式——原型模式
嵌入式与人工智能
03-07 762
原型模式1.原型模式2.代码实现 1.原型模式 什么是原型模式？ 在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这这个定义中，最重要的一个词是“拷贝”，也就是口头上的复制，而这个拷贝，也就是原型模式的精髓所在。 举一个最简单的例子来说明原型模式：记得上小学的时候，老师把需要做的课外习题写到黑板上，而下面的我们都要把这些题抄写到自己的本子上，回家做好，第二天交上来，也就是每道题，全班50个人，每个人都要抄写一遍。按照现在的时间理论
C++设计模式——原型模式(Prototype Pattern)
leonardohaig的博客
06-02 1316
C++设计模式——原型模式(Prototype Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——原型模式(Prototype Pattern)目录定义代码示例普通指针方式实现智能指针方式实现总结为什么需要原型模式优缺点 定义 Specify the kinds of Objects to create using a prototypical instance, and create new objects by copying this prototype. 用原型实例指
23种设计模式——原型模式
万里顾一程的博客
11-14 2452
文章目录23种设计模式——原型模式1、原型模式概述2、原型模式的结构图3、原型模式的实现3.1、浅拷贝和深拷贝3.2、实现浅拷贝3.2、实现深拷贝 23种设计模式——原型模式 1、原型模式概述 原型模式介绍 1、原型模式(Prototype模式)是指：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。 2、原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节，因此用这种方式创建对象非常高效
Java设计模式——原型模式
01-20
Java设计模式——原型模式 原型模式Java设计模式——原型模式概念使用场景Java里的克隆代码理解prototype(原型)问题总结优缺点模型优点模型缺点 概念 ​ 原型模式是创建型模式的最后一种，讲到原型模式就不得不提到...
中国石油大学(北京)克拉玛依校区在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
浙江越秀外国语学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
网站模板源代码（组件划分规范，二改省力）
最新发布
09-08
组件划分规范，二改省力！！！
华中科技大学 Java课程设计实验.zip
09-08
华中科技大学 Java课程设计实验.zip
4G语音质差参数优化调整建议.xlsx
09-08
4G语音质差参数优化调整建议
仲恺农业工程学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
《Java语言程序设计（基础篇）》课后编程练习题.zip
09-08
《Java语言程序设计（基础篇）》课后编程练习题
电影订票后台系统（系分课程设计）.zip
09-08
电影订票后台系统（系分课程设计）.zip
基于SVM方法的步态识别
09-08
对采集到的陀螺仪数据进行处理与识别，判断出三种姿态：走 ，跑，静止 数据处理： 对数据进行初步处理： 均值滤波 对数据进行加窗的特征提取，提取特征为 均值与方差 采用特征提取后的数据，用classify learning APP 训练一个识别模型 识别 走 跑 静止 之后对一段走，跑，静止的混杂数据进行识别验证，准确率95%以上
宿迁学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
C#设计模式——原型模式(Prototype Pattern)
06-01
原型模式是一种创建型设计模式，它允许通过复制已有对象来创建新对象，而不是通过实例化类并设置其属性来创建新对象。这样可以避免重复创建相同的对象，从而提高了创建对象的效率。 在原型模式中，原型对象是被复制的对象，而新对象是根据原型对象创建的。原型对象必须实现一个克隆方法，以便能够复制自身。新对象可以是浅复制或深复制，具体取决于实现克隆方法的方式。 原型模式的优点是可以避免重复创建相同的对象，提高了创建对象的效率。同时，它也可以简化对象的创建过程，因为不需要实例化一个类并设置其属性。另外，原型模式可以通过修改原型对象来影响所有克隆出的新对象。 然而，原型模式也有一些缺点。首先，原型对象必须实现克隆方法，这可能会增加代码复杂性。其次，如果原型对象包含循环引用或其他复杂结构，那么克隆出的新对象可能会出现意外的行为。因此，在实现原型模式时需要谨慎考虑这些问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值