【设计模式】Java设计模式 - 原型模式

不断学习才是王道

继续踏上学习之路,学之分享笔记

总有一天我也能像各位大佬一样

原创作品,更多关注我CSDN: 一个有梦有戏的人

准备将博客园、CSDN一起记录分享自己的学习心得!!!

分享学习心得,欢迎指正,大家一起学习成长!

简介

原型模式(Prototype Pattern)是用于创建重复的对象,同时又能保证性能。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。

克隆

原型模式对某个对象进行克隆,在最原始的古老方法就是通过new出实例,使用与之相同的参数,但是每次创建新的对象时候需要重新获取一下属性,效率不佳。

例子如下:

①、古老办法

本次使用lombok,省的还需要写get,set,toString;坐标导入如下:

<dependencies>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
</dependencies>

实体类,使用lombok的@Data注解

package com.lyd.demo.entity;
import lombok.Data;
/**
* @Author: lyd
* @Description:
* @Date: 2022-08-25
*/
@Data
public class Car {
private String type;
private String color;
public Car(String type, String color) {
this.type = type;
this.color = color;
}
}

使用古老办法,使用new一个一个赋值,很明显有些缺点,每次都需要调用对象去获取属性

package com.lyd.demo.ancient;
import com.lyd.demo.entity.Car;
/**
* @Author: lyd
* @Description:
* @Date: 2022-08-25
*/
public class Test {
public static void main(String[] args) {
Car car = new Car("奔驰", "black");
// 复制更多对象
Car c1 = new Car(car.getType(), car.getColor());
Car c2 = new Car(car.getType(), car.getColor());
Car c3 = new Car(car.getType(), car.getColor());
System.out.println("car: " + car + " hashcode: " + car.hashCode());
System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode());
System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode());
System.out.println("c3: " + c3 + " hashcode: " + c3.hashCode());
}
}

运行结果:可见虽然是复制成功了,但是效率明显很低。

②、原型模式

用原型实例指定创建对象的种类,通过拷贝实例创建新的对象。

例子如下代码:

需要让car实现Cloneable并且实现clone方法。

package com.lyd.demo.entity;
import lombok.Data;
/**
* @Author: lyd
* @Description:
* @Date: 2022-08-25
*/
@Data
public class Car implements Cloneable {
private String type;
private String color;
public Car(String type, String color) {
this.type = type;
this.color = color;
}
// 克隆实例
@Override
protected Object clone() throws CloneNotSupportedException {
Car car = null;
car = (Car) super.clone();
return car;
}
}

测试:

package com.lyd.demo.entity;
/**
* @Author: lyd
* @Description:
* @Date: 2022-08-25
*/
public class PrototypeTest {
public static void main(String[] args) throws CloneNotSupportedException {
Car car = new Car("红旗", "red");
Car c1 = (Car) car.clone();
Car c2 = (Car) car.clone();
Car c3 = (Car) car.clone();
System.out.println("car: " + car + " hashcode: " + car.hashCode());
System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode());
System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode());
System.out.println("c3: " + c3 + " hashcode: " + c3.hashCode());
}
}

运行结果:

定义一个原型类,声明出克隆自己的接口。克隆的时候只要调用clone方法就可以实现对象克隆。

浅拷贝

对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性复制一份给新的对象。因为是两份不同的数据,所以对其中一的对象的成员变量值进行修改,不会影响另一个对象拷贝得到的数据。

对于数据类型是引用类型的成员变量,比如说成员变量是某个数组,某个类的对象等,那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用指(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。



在Car类中加一个属性

public Car NewEnergy;

编写测试浅拷贝类

package com.lyd.demo.entity;
/**
* @Author: lyd
* @Description: 浅拷贝
* @Date: 2022-08-25
*/
public class ShallowCopyTest {
public static void main(String[] args) throws CloneNotSupportedException {
Car car = new Car("红旗", "red");
car.NewEnergy = new Car("奔驰", "blue");
// 克隆
Car c1 = (Car) car.clone();
Car c2 = (Car) car.clone();
Car c3 = (Car) car.clone();
System.out.println("car: " + car + " hashcode: " + car.hashCode() + " NewEnergy: " + car.NewEnergy + " hashcode: " + car.NewEnergy.hashCode());
System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode() + " NewEnergy: " + c1.NewEnergy + " hashcode: " + c1.NewEnergy.hashCode());
System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode() + " NewEnergy: " + c2.NewEnergy + " hashcode: " + c2.NewEnergy.hashCode());
System.out.println("c3: " + c3 + " hashcode: " + c3.hashCode() + " NewEnergy: " + c3.NewEnergy + " hashcode: " + c3.NewEnergy.hashCode());
}
}

测试结果

可见,如果是基本数据类型,那就会传递值,将值赋给新的对象;对于对象,则只是进行引用传递。这种就是浅拷贝。这样会导致只要修改其中一个变量,就会导致所有都修改,例如 c2.NewEnergy.setColor("red"); 之后在打印一次数据。

深拷贝

深拷贝复制变量值,对于引用数据,则递归至基本类型后,再复制。深拷贝后的对象与原来的对象是完全隔离的,互不影响,对一个对象的修改并不会影响另一个对象。深拷贝相比于浅拷贝速度较慢并且花销较大。

重新定义两个实体类,其中一个只有基本数据类型,另一个包含引用数据类型

方式一:通过重写clone()方法

Car: 在克隆的时候直接调用super.clone()来完成对基本数据类型的克隆,通过引用数据类的clone方法在进行类型强制装换即可。

package com.lyd.demo.deep;
import lombok.Data;
import java.io.Serializable;
/**
* @Author: lyd
* @Description: 汽车类
* @Date: 2022-08-25
*/
@Data
public class Car implements Cloneable, Serializable {
private String type;
private String color;
public NewEnergy newEnergy; // 引用数据类型
public Car(String type, String color) {
this.type = type;
this.color = color;
}
// 克隆实例
@Override
protected Object clone() throws CloneNotSupportedException {
Object object = null;
// 完成基本数据的装换
object = super.clone();
// 对引用数据类型的属性,单独处理
Car car = (Car) object;
car.newEnergy = (NewEnergy) newEnergy.clone();
return car;
}
}

NewEnergy:

package com.lyd.demo.deep;
import lombok.Data;
import java.io.Serializable;
/**
* @Author: lyd
* @Description: 新能源类
* @Date: 2022-08-25
*/
@Data
public class NewEnergy implements Serializable, Cloneable {
private String type;
private String color;
public NewEnergy(String type, String color) {
this.type = type;
this.color = color;
}
/**
* 该类都是基本数据类型,直接返回即可
* @return
* @throws CloneNotSupportedException
*/
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

测试:

package com.lyd.demo.deep;
/**
* @Author: lyd
* @Description: 深拷贝
* @Date: 2022-08-25
*/
public class DeepCopyTest {
public static void main(String[] args) throws CloneNotSupportedException {
Car car = new Car("路虎", "green");
car.newEnergy = new NewEnergy("路虎新能源", "blue");
Car c1 = (Car) car.clone();
Car c2 = (Car) car.clone();
System.out.println("car: " + car + " hashcode: " + car.hashCode() + " NewEnergy: " + car.newEnergy + " hashcode: " + car.newEnergy.hashCode());
System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode() + " NewEnergy: " + c1.newEnergy + " hashcode: " + c1.newEnergy.hashCode());
System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode() + " NewEnergy: " + c2.newEnergy + " hashcode: " + c2.newEnergy.hashCode());
System.out.println("==============================================================================================================================");
c1.newEnergy.setColor("red"); // 修改
System.out.println("car: " + car + " hashcode: " + car.hashCode() + " NewEnergy: " + car.newEnergy + " hashcode: " + car.newEnergy.hashCode());
System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode() + " NewEnergy: " + c1.newEnergy + " hashcode: " + c1.newEnergy.hashCode());
System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode() + " NewEnergy: " + c2.newEnergy + " hashcode: " + c2.newEnergy.hashCode());
}
}

运行结果:

可见,不但完成了把引用对象进行拷贝,修改c1的属性时,不会影响其他的对象,这就是深拷贝

关于深拷贝、浅拷贝查看参考资料:CSDNhttps://blog.csdn.net/qq_34748010/article/details/124917704

方式二:通过对象序列化

通过对象流的方式将对象进行序列化之后在进行反序列化完成深拷贝。这样的效果会更好。

只要在Car类中添加一个deepClone方法

// 方式二:实现序列化
public Object deepClone() {
// 创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
// 序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this); // 把当前对象以对象流的方式输出
//反序列
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
Car car = (Car) ois.readObject();
return car;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
// 关闭流
try {
ois.close();
bis.close();
oos.close();
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

测试:只要调用deepClone方法就可以

Car c1 = (Car) car.deepClone();
Car c2 = (Car) car.deepClone();

最后实验结果:



今天的内容不少!创作不易,如有错误请指正,感谢观看!记得一键三连哦!

德德小建议:

理解设计模式不是一件简单的事情,需要不断的学习和动手去练习,才能理解。只有掌握好设计模式,才能够真正的理解SpringAOP和Mybatis的底层原理。各位读者可以和我一样,动手敲一敲代码,甚至用不同的例子来做,通过debug一步一步调试,还有就是多看看别人的例子。能够有助于理解!谢谢各位观看指点!️ ️ ️

【设计模式】Java设计模式 - 原型模式的更多相关文章

  1. java23种设计模式——四、原型模式

    源码在我的github和gitee中获取 目录 java23种设计模式-- 一.设计模式介绍 java23种设计模式-- 二.单例模式 java23种设计模式--三.工厂模式 java23种设计模式- ...

  2. Java设计模式5:原型模式

    原型模式 原型模式属于对象的创建模式,通过给出一个原型对象来指明所有创建的对象的类型,然后用复制这个原型对象的办法创建出更多同类型的对象,这就是原型模式的用意. 原型模式结构 原型模式要求对象实现一个 ...

  3. java 之 原型模式(大话设计模式)

    原型模式,在笔者理解看来就是克隆,当我们在创建第一个对象时,已经给对象赋值完毕,此时我们需要一个当前对象的副本,如果没有原型模式,我们会再次创建一个对象,然后后二次赋值,保证两个对象完全一致, 这样我 ...

  4. 重学 Java 设计模式:实战原型模式

    作者:小傅哥 博客:https://bugstack.cn 沉淀.分享.成长,让自己和他人都能有所收获! 一.前言 老板你加钱我的代码能飞 程序员这份工作里有两种人:一类是热爱喜欢的.一类是仅当成工作 ...

  5. 深度分析:java设计模式中的原型模式,看完就没有说不懂的

    前言 原型模式(Prototype模式)是指:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象 原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需知道如何创建的 ...

  6. java常用设计模式三:原型模式

    在说原型模式之前先说一下浅拷贝和深拷贝的概念 一.浅拷贝和深拷贝 1.浅拷贝 在java中,对象创建后需要有一个引用变量来指向该对象实际的地址空间,也就是说引用变量与对象实体是两个不同的数据体.在Ob ...

  7. java设计模式-----5、原型模式

    原型(Prototype)模式是一种对象创建型模式,他采取复制原型对象的方法来创建对象的实例.使用原型模式创建的实例,具有与原型一样的数据. 原型模式的特点: 1.由原型对象自身创建目标对象.也就是说 ...

  8. Java描述设计模式(05):原型模式

    本文源码:GitHub·点这里 || GitEE·点这里 一.原型模式简介 1.基础概念 原型模式属于对象的创建模式.通过给出一个原型对象来指明所有创建的对象的类型,然后用复制这个原型对象的办法创建出 ...

  9. 【java设计模式】-06原型模式

    原型模式简述 定义: 使用原型实例指定待创建对象的类型,并且通过复制这个原型来创建新的对象 ,也就是通过复制现有对象实例产生新的对象,也就是所谓的"克隆" 实现方式: 1.实现Cl ...

  10. 《JAVA设计模式》之原型模式(Prototype)

    在阎宏博士的<JAVA与模式>一书中开头是这样描述原型(Prototype)模式的: 原型模式属于对象的创建模式.通过给出一个原型对象来指明所有创建的对象的类型,然后用复制这个原型对象的办 ...

随机推荐

  1. SAP OOALV- 合计

    TYPES: BEGIN OF ty_mara, srno LIKE adrc-name1, " Storing the total text matnr LIKE mara-matnr, ...

  2. SAP 文本框多行输入

    REPORT zjw_test01. CONSTANTS: gc_text_line_length TYPE i VALUE 72. TYPES: text_table_type(gc_text_li ...

  3. 【python基础】第05回 数据类型,交互,格式化输出,运算符

    上节内容回顾 1.python的注释 # 单行注释 pycharm快捷键:ctrl+? '''多行注释''' """多行注释""" 2.py ...

  4. Day02 HTML语法

    有两种类型的标签 双标记<标记名>内容</标记名> 单标记<标记名/> 属性: 对标签的描述--属性,由属性名和属性值组成 <标记名 属性名 = " ...

  5. Linux 无法启动vmmon的问题[主要出现于Arch系]

    Vmmon module not loaded 使用如下命令加载模块 # modprobe -a vmw_vmci vmmon 可能会出现modprobe: WARNING: Module vmmon ...

  6. net core天马行空系列-各大数据库快速批量插入数据方法汇总

    1.前言 hi,大家好,我是三合.我是怎么想起写一篇关于数据库快速批量插入的博客的呢?事情起源于我们工作中的一个需求,简单来说,就是有一个定时任务,从数据库里获取大量数据,在应用层面经过处理后再把结果 ...

  7. mysql Insert强化

    INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [(col_name,...)] VALUES ({e ...

  8. iOS自动化打包 Jenkins+Gitlab+Fastlane+蒲公英+钉钉

    前言 这两天花时间整理一下自动化打包的整套流程,现在iOS端的整套流程是没有问题了,这个过程中踩得坑也的确是特别多,所以这周末把整个流程整理一下,总结出来这篇文章,希望能对有需要的小伙伴有点点帮助. ...

  9. 用户认证(Authentication)进化之路:由Basic Auth到Oauth2再到jwt

    原文转载自「刘悦的技术博客」https://v3u.cn/a_id_98 用户认证是一个在web开发中亘古不变的话题,因为无论是什么系统,什么架构,什么平台,安全性是一个永远也绕不开的问题 在HTTP ...

  10. V8中的快慢数组(附源码、图文更易理解😃)

    接上一篇掘金 V8 中的快慢属性,本篇分析V8 中的快慢数组,了解数组全填充还是带孔.快慢数组.快慢转化.动态扩缩容等等.其实很多语言底层都采用类似的处理方式,比如:Golang中切片的append操 ...