我的Java设计模式-原型模式
“不好意思,我是卧底!哇哈哈哈~”额......自从写了上一篇的观察者模式,就一直沉浸在这个角色当中,无法自拨。昨晚在看《使徒行者2》,有一集说到啊炮仗哥印钞票,我去,这就是想印多少就印多少的节奏。
但是我觉得他们印钞票的方法太low了,就用那“哧咔,哧咔~”的老机器没日没夜的印,看着都着急。
这里我们可以用原型模式优化印钞票的致富之路,为什么,继续往下看......
一、原型模式
定义
用原型实例指定所有创建对象的类型,并且通过复制这个拷贝创建新的对象。
特点
1)必须存在一个现有的对象,也就是原型实例,通过原型实例创建新对象。
2)在Java中,实现Cloneable,并且因为所有的类都继承Object类,重写clone()方法来实现拷贝。
使用场景
大量的对象,并且类初始化时消耗的资源多。没人会嫌钱多的吧,除了某云。
这些钞票的信息属性基本一致,可以调整个别的属性。
印钞票的工序非常复杂,需要进行繁琐的数据处理。
UML图
从上面的UML图可以看出,原型模式涉及到的角色有如下三个:
- 客户端角色:负责创建对象的请求。
- 抽象原型角色:该角色是一个抽象类或者是接口,提供拷贝的方法。
- 具体原型角色:该角色是拷贝的对象,需要重写抽象原型的拷贝方法,实现浅拷贝或者深拷贝。
二、实战
一起来印钞票,钞票实例必须实现Cloneable接口,该接口只充当一个标记,然后重写clone方法,具体原型角色代码如下:
public class Money implements Cloneable {
private int faceValue;
private Area area;
public int getFaceValue() {
return faceValue;
}
public void setFaceValue(int faceValue) {
this.faceValue = faceValue;
}
public Money(int faceValue, Area area) {
this.faceValue = faceValue;
this.area = area;
}
public Area getArea() {
return area;
}
public void setArea(Area area) {
this.area = area;
}
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
@Override
protected Money clone() throws CloneNotSupportedException {
return (Money) super.clone();
}
}
Area类代码如下:
public class Area {
// 钞票单位
private String unit;
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
}
看看客户端如何实现钞票的拷贝,代码如下:
public class Client {
public static void main(String[] args) {
Area area = new Area();
area.setUnit("RMB");
// 原型实例,100RMB的钞票
Money money = new Money(100, area);
for (int i = 1; i <= 3; i++) {
try {
Money cloneMoney = money.clone();
cloneMoney.setFaceValue(i * 100);
System.out.println("这张是" + cloneMoney.getFaceValue() + cloneMoney.getArea().getUnit() + "的钞票");
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
}
大把大把的钞票出来了
这张是100RMB的钞票
这张是200RMB的钞票
这张是300RMB的钞票
从上面并没有看到抽象原型角色的代码,那该角色在哪?Object就是这个抽象原型角色,因为Java中所有的类都默认继承Objet,在这提供clone方法。
三、浅拷贝和深拷贝
在使用原型模式的时候,常常需要注意用的到底是浅拷贝还是深拷贝,当然这必须结合实际的项目需求。下面来了解学习这两种拷贝的用法和区别:
首先我们来看一个例子,只改变客户端代码:
public class Client {
public static void main(String[] args) {
Area area = new Area();
area.setUnit("RMB");
// 原型实例,100RMB的钞票
Money money = new Money(100, area);
try {
Money cloneMoney = money.clone();
cloneMoney.setFaceValue(200);
area.setUnit("美元");
System.out.println("原型实例的面值:" + money.getFaceValue() +money.getArea().getUnit());
System.out.println("拷贝实例的面值:" + cloneMoney.getFaceValue() + cloneMoney.getArea().getUnit());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
运行结果如下:
原型实例的面值:100美元
拷贝实例的面值:200美元
浅拷贝
见鬼了,明明就把原型实例的单位改成了美元而已,拷贝实例怎么也会跟着改变的。哪里有鬼?其实是Java在搞鬼。我们用的是Object的clone方法,而该方法只拷贝按值传递的数据,比如String类型和基本类型,但对象内的数组、引用对象都不拷贝,也就是说内存中原型实例和拷贝实例指向同一个引用对象的地址,这就是浅拷贝。浅拷贝的内存变化如下图:
从上图可以看出,浅拷贝前后的两个实例对象共同指向同一个内存地址,即它们共有拥有area1实例,同时也存在着数据被修改的风险。注意,这里不可拷贝的引用对象是指可变的类成员变量。
深拷贝
同样的看例子,客户端代码如下:
public class Client {
public static void main(String[] args) {
Area area = new Area();
area.setUnit("RMB");
// 原型实例,100RMB的钞票
Money money = new Money(100, area);
try {
Money cloneMoney = money.clone();
cloneMoney.setFaceValue(200);
area.setUnit("美元");
System.out.println("原型实例的面值:" + money.getFaceValue() + money.getArea().getUnit());
System.out.println("拷贝实例的面值:" + cloneMoney.getFaceValue() + cloneMoney.getArea().getUnit());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
运行结果如下:
原型实例的面值:100美元
拷贝实例的面值:200RMB
咦~这客户端代码不是跟浅拷贝的一样吗,但是运行结果却又不一样了。关键就在,实现深拷贝就需要完全的拷贝,包括引用对象,数组的拷贝。所以Area类也实现了Cloneable接口,重写了clone方法,代码如下:
public class Area implements Cloneable{
// 钞票单位
private String unit;
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
@Override
protected Area clone() throws CloneNotSupportedException {
Area cloneArea;
cloneArea = (Area) super.clone();
return cloneArea;
}
}
另外,在Money钞票类的clone方法增加拷贝Area的代码:
public class Money implements Cloneable, Serializable {
private int faceValue;
private Area area;
public int getFaceValue() {
return faceValue;
}
public void setFaceValue(int faceValue) {
this.faceValue = faceValue;
}
public Money(int faceValue, Area area) {
this.faceValue = faceValue;
this.area = area;
}
public Area getArea() {
return area;
}
public void setArea(Area area) {
this.area = area;
}
@Override
protected Money clone() throws CloneNotSupportedException {
Money cloneMoney = (Money) super.clone();
cloneMoney.area = this.area.clone(); // 增加Area的拷贝
return cloneMoney;
}
}
深拷贝的内存变化如下图:
深拷贝除了需要拷贝值传递的数据,还需要拷贝引用对象、数组,即把所有引用的对象都拷贝。需要注意的是拷贝的引用对象是否还有可变的类成员对象,如果有就继续对该成员对象进行拷贝,如此类推。所以使用深拷贝是注意分析拷贝有多深,以免影响性能。
序列化实现深拷贝
这是实现深拷贝的另一种方式,通过二进制流操作对象,从而达到深拷贝的效果。把对象写到流里的过程是序列化过程,而把对象从流中读出来的过程则叫反序列化过程。深拷贝的过程就是把对象序列化(写成二进制流),然后再反序列化(从流里读出来)。注意,在Java中,常常可以先使对象实现Serializable接口,包括引用对象也要实现Serializable接口,不然会抛NotSerializableException。
只要修改Money,代码如下:
public class Money implements Serializable {
private int faceValue;
private Area area;
public int getFaceValue() {
return faceValue;
}
public void setFaceValue(int faceValue) {
this.faceValue = faceValue;
}
public Money(int faceValue, Area area) {
this.faceValue = faceValue;
this.area = area;
}
public Area getArea() {
return area;
}
public void setArea(Area area) {
this.area = area;
}
@Override
protected Money clone() throws CloneNotSupportedException {
Money money = null;
try {
// 调用deepClone,而不是Object的clone方法
cloneMoney = (Money) deepClone();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return cloneMoney;
}
// 通过序列化深拷贝
public Object deepClone() throws IOException, ClassNotFoundException {
//将对象写到流里
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();
}
}
同样运行客户端代码,最后来看看结果:
原型实例的面值:100美元
拷贝实例的面值:200RMB
四、原型模式的优缺点
优点
1)提高性能。不用new对象,消耗的资源少。
缺点
1)浅拷贝时需要实现Cloneable接口,深拷贝则要特别留意是否有引用对象的拷贝。
总结
原型模式本身比较简单,重写Object的clone方法,实现浅拷贝还是深拷贝。重点在理解浅拷贝和深拷贝,这是比较细但又重要,却往往被忽略的知识点。好啦,原型模式就到这了,下一篇是策略模式,敬请关注,拜拜!
设计模式Java源码GitHub下载:https://github.com/jetLee92/DesignPattern
我的Java设计模式-原型模式的更多相关文章
- 【设计模式】Java设计模式 - 原型模式
[设计模式]Java设计模式 - 原型模式 不断学习才是王道 继续踏上学习之路,学之分享笔记 总有一天我也能像各位大佬一样 原创作品,更多关注我CSDN: 一个有梦有戏的人 准备将博客园.CSDN一起 ...
- Java设计模式—原型模式
原型设计模式是一种比较简单的设计模式,在项目中使用的场景非常多. 个人理解: 原型模式实现了对Java中某个对象的克隆功能,即该对象的类必须implements实现Cloneable接口来标识为可被克 ...
- Java设计模式-原型模式(Prototype)
原型模式属于对象的创建模式.通过给出一个原型对象来指明所有创建的对象的类型,然后用复制这个原型对象的办法创建出更多同类型的对象.这就是选型模式的用意. 原型模式的结构 原型模式要求对象实现一个可以“克 ...
- java设计模式---原型模式
原型模式(Prototype):用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 原型模式结构图 通俗来说:原型模式就是深拷贝和浅拷贝的实现. 浅拷贝 只实现了值拷贝,对于引用对象还是 ...
- 4.java设计模式-原型模式(prototype)
在<JAVA与模式>一书中开头是这样描述原型(Prototype)模式的: 原型模式属于对象的创建模式.通过给出一个原型对象来指明所有创建的对象的类型,然后用复制这个原型对象的办法创建出更 ...
- Java设计模式原型模式
原型模式: – 通过new产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式. – 就是java中的克隆技术,以某个对象为原型,复制出新的对象.显然,新的对象具备原型对象的特点 – 优势 ...
- java设计模式——原型模式
一. 定义与类型 定义:指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.不需要知道任何创建的细节,不调用构造函数 类型:创建型 二.使用场景 类初始化消耗较多资源 new 产生的一个对 ...
- PHP 设计模式 原型模式(Prototype)之深/浅拷贝
看PHP 设计模式 原型模式(Prototype)时,衍生出一个扩展问题之 原型拷贝的浅拷贝和深拷贝问题(不管写Java还是写PHP还是写JS时都多多少少遇到过对象拷贝问题) 比如写前端页面时 ...
- 10. 星际争霸之php设计模式--原型模式
题记==============================================================================本php设计模式专辑来源于博客(jymo ...
随机推荐
- 小谈ConcurrentHashMap
面试的时候被面试官问了点相关知识,再次记录一些自己的总结 一. 1.HashTable也可实现线程安全,但是它是用synchronized实现的,所以其他线程访问HashTable的同步方法时,可能会 ...
- TCP那些事儿(下)
这篇文章是下篇,所以如果你对TCP不熟悉的话,还请你先看看上篇<TCP的那些事儿(上)> 上篇中,我们介绍了TCP的协议头.状态机.数据重传中的东西.但是TCP要解决一个很大的事,那就是要 ...
- 【PHP】 PHPqrCode二维码类库使用方法
1.首先去官网下载PHPqrCode库文件,只需要里面的phpqrcode.php文件,下载地址:http://phpqrcode.sourceforge.net 2.二维码生成实例代码: <? ...
- JAVA关键字Volatile的特性
一.简述: 关键字Volatile是JAVA虚拟机提供的最轻量级的同步机制,但是它并不容易完全被正确.完整的理解,以致于许多程序员在遇到需要处理多线程数据竞争的时候一律使用synchronized来进 ...
- 05_Python Format Operation
Python格式化输出 print('name: %s,version: %s,code: %d' %('Python',3.6,3)) print('name: {name},version: {v ...
- Java文件上传细讲
什么是文件上传? 文件上传就是把用户的信息保存起来. 为什么需要文件上传? 在用户注册的时候,可能需要用户提交照片.那么这张照片就应该要进行保存. 上传组件(工具) 为什么我们要使用上传工具? 为啥我 ...
- Optaplanner - 入门介绍
OptaPlanner背景 在上一篇里喷了不少水,这一篇准备放点干货:其实也没办法完全干,因为很多预备知道在交待一下.好了,说一下关于OptaPlanner的背景.应用兼容性及其原理. 这一篇先说一下 ...
- ant基础[转]
原文链接:http://www.cnblogs.com/wufengxyz/archive/2011/11/24/2261797.html 1,什么是antant是构建工具2,什么是构建概念到处可查到 ...
- ctags的使用
1. 生成tags文件 为当前目录下的所有C程序文件生成对应的tags文件: $ ctags *.c 为同一个目录下的所有文件建立tags如下 $ ctags –R (较常用) 这个命令 ...
- django-rest-framework之请求与响应
前言:在上一篇文章,已经实现了访问指定URL就返回了指定的数据,这也体现了RESTful API的一个理念,每一个URL代表着一个资源.当然我们还知道RESTful API的另一个特性就是,发送不同的 ...