23种设计模式总篇:chenmingyu.top/design/
原型模式
原型模式属于创建型设计模式
**定义:**用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象
原型模式通过克隆一个已经存在的对象实例来返回新的实例,而不是通过new去创建对象,多用于创建复杂的或者耗时的实例,因为这种情况下,复制一个已经存在的实例使程序运行更高效;
java中复制对象是通过重写clone()
实现的,原型类需要实现Cloneable
接口,否则报CloneNotSupportedException
异常
模式类图
角色
- 抽象原型:Prototype,可以为接口或者抽象类,实现了
Cloneable
接口,重写了clone()
方法,子类只需实现或集成即可拥有克隆功能 - 具体原型:PrototypeA,PrototypeB,实现/集成了Prototype接口的类,拥有克隆方法
- 工厂模式:原型模式常和工厂模式一起使用,通过 clone 的方法创建一个对象,然后由工厂方法提供给调用者
优点
- 性能优良,比new一个对象性能好很多
- 不受对象构造函数的约束
模式代码实现
以获取笔对象为例子,结合工厂模式讲解如何使用原型模式,涉及的类:Pen
(抽象类),Pencil
(铅笔),CarbonPen
(碳素笔),PenFactory
(工厂类)
抽象原型
抽象类,实现了Cloneable
接口,重写了clone()
方法
/**
* @author: chenmingyu
* @date: 2019/2/28 09:54
* @description: 抽象原型角色
*/
@Data
public abstract class Pen implements Cloneable{
private String name;
public Pen(String name) {
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
复制代码
具体原型
Pencil
,继承Pen
/**
* @author: chenmingyu
* @date: 2019/2/28 11:27
* @description: 铅笔
*/
public class Pencil extends Pen{
public Pencil(String name) {
super(name);
}
}
复制代码
CarbonPen
,继承了`Pen
/**
* @author: chenmingyu
* @date: 2019/2/28 11:29
* @description: 碳素笔
*/
public class CarbonPen extends Pen{
public CarbonPen(String name) {
super(name);
}
}
复制代码
工厂类
简单工厂实现
/**
* @author: chenmingyu
* @date: 2019/2/28 11:32
* @description: 笔生产工厂
*/
public class PenFactory {
/**
* 原型类容器
*/
private static Map<String, Pen> penMap = new Hashtable<>();
/**
* 初始化
*/
public static void init() {
Pen carbonPen = new CarbonPen("碳素笔");
penMap.put(CarbonPen.class.getName(),carbonPen);
Pen pencil = new Pencil("铅笔");
penMap.put(Pencil.class.getName(),pencil);
}
/**
* 通过复制获取实例
* @param className
* @return
* @throws CloneNotSupportedException
*/
public static Pen getPen(Class className) throws CloneNotSupportedException{
Pen cachedShape = penMap.get(className.getName());
return (Pen) cachedShape.clone();
}
}
复制代码
验证
public static void main(String[] args){
PenFactory.init();
IntStream.range(0,2).forEach(i->{
try {
System.out.println(PenFactory.getPen(CarbonPen.class).getClass());
System.out.println(PenFactory.getPen(Pencil.class).getClass());
System.out.println(" ... ");
}catch (CloneNotSupportedException e){
e.printStackTrace();
}
});
}
复制代码
输出
class com.example.design.prototype.CarbonPen
class com.example.design.prototype.Pencil
...
class com.example.design.prototype.CarbonPen
class com.example.design.prototype.Pencil
...
复制代码
浅拷贝和深拷贝
浅拷贝:将一个对象复制后,基本类型会被重新创建,引用类型的对象会把引用拷贝过去,实际上还是指向的同一个对象
深拷贝:将一个对象复制后,基本类型和引用类型的对象都会被重新创建
浅拷贝
举个例子
/**
* @author: chenmingyu
* @date: 2019/2/28 14:53
* @description: 克隆
*/
@Data
public class Clone implements Cloneable{
private CloneA CloneA;
public Clone() {
this.CloneA = new CloneA();
}
@Override
protected Clone clone() throws CloneNotSupportedException {
return (Clone) super.clone();
}
class CloneA{
}
}
复制代码
验证
public static void main(String[] args) throws CloneNotSupportedException{
Clone clone = new Clone();
Clone clone1 = clone.clone();
System.out.println(clone == clone1);
System.out.println(clone.getCloneA() == clone1.getCloneA());
}
复制代码
输出
false
true
复制代码
所以clone()方法是执行的浅拷贝,这个需要在写代码的时候注意一下,浅拷贝是否可以满足需求
深拷贝
深拷贝的实现方案主要有两种
- 引用类型也使用clone(),进行clone的时候,对引用类型在调用一次clone()方法
- 使用序列化,将对象序列化后在反序列化回来,得到新的对象实例
使用序列化实现以下
/**
* @author: chenmingyu
* @date: 2019/2/28 14:53
* @description: 浅克隆
*/
@Data
public class Clone implements Cloneable ,Serializable {
private CloneA CloneA;
public Clone() {
this.CloneA = new CloneA();
}
@Override
protected Clone clone() throws CloneNotSupportedException {
return (Clone) super.clone();
}
/**
* 深拷贝
* @return
* @throws CloneNotSupportedException
*/
protected Clone deepClone() throws CloneNotSupportedException {
Clone clone = null;
try{
ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(baos);
oos.writeObject(this);
oos.close();
ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois=new ObjectInputStream(bais);
//生成新的对象实例
clone=(Clone)ois.readObject();
ois.close();
}catch (Exception e){
e.printStackTrace();
}
return clone;
}
class CloneA implements Serializable{
}
}
复制代码
验证
public static void main(String[] args) throws CloneNotSupportedException{
Clone clone = new Clone();
Clone clone1 = clone.deepClone();
System.out.println(clone == clone1);
System.out.println(clone.getCloneA() == clone1.getCloneA());
}
复制代码
输出
false
false
复制代码
在使用原型模式的时候一定要理解什么是浅拷贝和深拷贝,才可以放心的使用原型模式,并且一般都会和工厂模式一起使用
相关阅读
创建型设计模式
关注于如何创建对象
-
保证在程序运行期间一个类只有一个实例,并提供一个全局访问点
-
用工厂方法代替new操作,让子类去决定实例化哪个类,工厂方法将一个类的实例化延迟到子类
-
抽象工厂模式属于创建型模式,是对工厂方法模式的扩展,抽象工厂比工厂模式更为抽象,工厂方法模式针对产品等级结构,而抽象工厂针对产品族
-
通过克隆一个已经存在的对象实例来返回新的实例,而不是通过new去创建对象
-
通过克隆一个已经存在的对象实例来返回新的实例,而不是通过new去创建对象
结构型设计模式
关注于类和对象之间的关系
-
组合两个不相干类,在两个不兼容的接口之间提供一个混合接口,使其兼容适配
-
将抽象部分与它的实现部分分离,使它们都可以独立地变化。桥接模式将系统各维度抽象出来,各维度独立变化,之后可通过聚合,将各维度组合起来,减少它们之间耦合
-
用来描述部分与整体的关系,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,所以组合模式的使用场景就是出现树形结构的地方。
-
装饰器模式可以为一个现有的类增加新功能,又不改变其结构,要求装饰类和被装饰类实现同一个接口,装饰类持有被装饰类的实例
-
外观模式是为了解决类与类之家的责任关系和依赖关系的,通过提供一个Facade类来隐藏这些复杂的类之间关系的调用,并提供一个接口,供外部调用,利用这种方式进行类之间的解耦
-
代理模式就是在操作原对象的时候,多出来一个代理类,用来对原对象的访问进行控制和替代原对象进行一些操作
-
运用共享技术有效地支持大量细粒度对象的复用,主要用来减少对象的创建,用来减少内存和提高性能,比较常见的连接池,缓冲池这类的池技术都是享元模式
行为型设计模式
关注于对象之间的通信
-
在父类(抽象类)中定义好算法的流程,提供抽象方法,针对不同的实现交由不同的子类去实现,通过这种方式将公共代码提取出来封装在父类中,然后父类去控制行为,子类负责实现
-
在系统中提供一组策略,并将每个策略封装成类,使他们可以相互转换,具体策略的选择由客户端决定
-
定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并被自动更新
-
迭代器模式就是为解决遍历元素而诞生的,它提供一种方法访问一个容器对象中各个元素,而又不需暴露该对象的内部细节
-
使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止
-
将一个请求封装成一个对象,从而让你使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能,用来降低类之间解耦
-
在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态,其实就是在某个时刻备份了对象的状态,在更改对象状态后,可以通过备份将对象还原成备份时刻的状态
-
允许一个对象在其内部状态改变时改变它的行为,对象看起来似乎修改了它的类,对象的行为依赖于它的状态(属性),并且可以根据它的状态改变而改变它的相关行为
-
封装一些作用于某种数据结构中的各元素的操作,它可以在不改变数据结构的前提下定义作用于这些元素的新的操作,访问者模式就是将数据结构与数据操作相分离
-
用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互
-
给定一门语言,定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子