个人Java设计模式-原型模式

时间  2019-11-10
标签 个人 java 设计 模式 原型 栏目 Java 繁體版
原文   原文链接

“很差意思，我是卧底！哇哈哈哈~”额......自从写了上一篇的观察者模式，就一直沉浸在这个角色当中，没法自拨。昨晚在看《使徒行者2》，有一集说到啊炮仗哥印钞票，我去，这就是想印多少就印多少的节奏。git

可是我以为他们印钞票的方法太low了，就用那“哧咔，哧咔~”的老机器没日没夜的印，看着都着急。github

这里咱们能够用原型模式优化印钞票的致富之路，为何，继续往下看......segmentfault

1、原型模式

定义

  用原型实例指定全部建立对象的类型，而且经过复制这个拷贝建立新的对象。设计模式

特色

  1）必须存在一个现有的对象，也就是原型实例，经过原型实例建立新对象。数组

  2）在Java中，实现Cloneable，而且由于全部的类都继承Object类，重写clone()方法来实现拷贝。ide

使用场景

  • 大量的对象，而且类初始化时消耗的资源多。没人会嫌钱多的吧，除了某云。
  • 这些钞票的信息属性基本一致，能够调整个别的属性。
  • 印钞票的工序很是复杂，须要进行繁琐的数据处理。

UML图

原型模式UML图.png

从上面的UML图能够看出，原型模式涉及到的角色有以下三个：性能

  - 客户端角色：负责建立对象的请求。学习

  - 抽象原型角色：该角色是一个抽象类或者是接口，提供拷贝的方法。优化

  - 具体原型角色：该角色是拷贝的对象，须要重写抽象原型的拷贝方法，实现浅拷贝或者深拷贝。this

2、实战

一块儿来印钞票，钞票实例必须实现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方法。

3、浅拷贝和深拷贝

在使用原型模式的时候，经常须要注意用的究竟是浅拷贝仍是深拷贝，固然这必须结合实际的项目需求。下面来了解学习这两种拷贝的用法和区别：

首先咱们来看一个例子，只改变客户端代码：

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类型和基本类型，但对象内的数组、引用对象都不拷贝，也就是说内存中原型实例和拷贝实例指向同一个引用对象的地址，这就是浅拷贝。浅拷贝的内存变化以下图：

浅拷贝内存分析.png

从上图能够看出，浅拷贝先后的两个实例对象共同指向同一个内存地址，即它们共有拥有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;
    }

}

深拷贝的内存变化以下图：

深拷贝内存分析.png

深拷贝除了须要拷贝值传递的数据，还须要拷贝引用对象、数组，即把全部引用的对象都拷贝。须要注意的是拷贝的引用对象是否还有可变的类成员对象，若是有就继续对该成员对象进行拷贝，如此类推。因此使用深拷贝是注意分析拷贝有多深，以避免影响性能。

序列化实现深拷贝

这是实现深拷贝的另外一种方式，经过二进制流操做对象，从而达到深拷贝的效果。把对象写到流里的过程是序列化过程，而把对象从流中读出来的过程则叫反序列化过程。深拷贝的过程就是把对象序列化（写成二进制流），而后再反序列化（从流里读出来）。注意，在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

4、原型模式的优缺点

优势

1）提升性能。不用new对象，消耗的资源少。

缺点

1）浅拷贝时须要实现Cloneable接口，深拷贝则要特别留意是否有引用对象的拷贝。

总结

原型模式自己比较简单，重写Object的clone方法，实现浅拷贝仍是深拷贝。重点在理解浅拷贝和深拷贝，这是比较细但又重要，却每每被忽略的知识点。好啦，原型模式就到这了，下一篇是策略模式，敬请关注，拜拜！

设计模式Java源码GitHub下载：https://github.com/jetLee92/DesignPattern

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程