为了账号安全,请及时绑定邮箱和手机立即绑定

设计模式 | 原型模式 prototype

2019.03.04 09:42 400浏览

原型模式属于创建型设计模式

推荐访问我的个人网站,排版更好看:https://chenmingyu.top/design-phototype/

原型模式

原型模式通过克隆一个已经存在的对象实例来返回新的实例,而不是通过new去创建对象,多用于创建复杂的或者耗时的实例,因为这种情况下,复制一个已经存在的实例使程序运行更高效;

java中复制对象是通过重写clone()实现的,原型类需要实现Cloneable接口,否则报CloneNotSupportedException异常

类图

  1. 抽象原型角色:Prototype,可以为接口或者抽象类,实现了Cloneable接口,重写了clone()方法,子类只需实现或集成即可拥有克隆功能

  2. 具体原型角色:PrototypeA,PrototypeB,实现/集成了Prototype接口的类,拥有克隆方法

  3. 工厂模式:原型模式常和工厂模式一起使用,通过 clone 的方法创建一个对象,然后由工厂方法提供给调用者

实现

以笔为例子,结合工厂模式讲解如何使用原型模式,涉及的类:Pen(抽象类),Pencil(铅笔),CarbonPen(碳素笔),PenFactory(工厂方法)

Pen

抽象类,抽象原型角色,实现了Cloneable接口,重写了clone()方法

/**
 * @author: chenmingyu
 * @date: 2019/2/28 09:54
 * @description: 抽象原型角色
 */@Datapublic 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);
    }
}
PenFactory

简单工厂实现

/**
 * @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.CarbonPenclass com.example.design.prototype.Pencil
  ... 
class com.example.design.prototype.CarbonPenclass com.example.design.prototype.Pencil
  ...

浅拷贝和深拷贝

浅拷贝:将一个对象复制后,基本类型会被重新创建,引用类型的对象会把引用拷贝过去,实际上还是指向的同一个对象

深拷贝:将一个对象复制后,基本类型和引用类型的对象都会被重新创建

浅拷贝

举个例子

/**
 * @author: chenmingyu
 * @date: 2019/2/28 14:53
 * @description: 克隆
 */@Datapublic 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()方法是执行的浅拷贝,这个需要在写代码的时候注意一下,浅拷贝是否可以满足需求

深拷贝

深拷贝的实现方案主要有两种

  1. 引用类型也使用clone(),进行clone的时候,对引用类型在调用一次clone()方法

  2. 使用序列化,将对象序列化后在反序列化回来,得到新的对象实例

使用序列化实现以下

/**
 * @author: chenmingyu
 * @date: 2019/2/28 14:53
 * @description: 浅克隆
 */@Datapublic 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

在使用原型模式的时候一定要理解什么是浅拷贝和深拷贝,才可以放心的使用原型模式,并且一般都会和工厂模式一起使用

作者:叫我明羽

原文出处:https://www.cnblogs.com/cmyxn/p/10451328.html  

点击查看更多内容
0人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 邀请有奖 帮助中心 APP下载
官方微信

举报

0/150
提交
取消