简易理解设计模式之：原型模式——深、浅拷贝的概念

介绍：

原型模式是一种创建型模式，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

类图：

Prototype（抽象原型类）：抽象类或接口，声明复制方法。
ConcretePrototype（具体原型类）：具体被复制的对象。
Client（客户端类）：调用类。

用法：
•　类初始化时候需要消耗非常多资源，通过原型拷贝避免这些消耗。
•　通过new产生一个对象时候需要非常繁琐的数据准备或访问权限时。
•　一个对象需要提供给其它对象使用，并且各个调用者都可能修改其值时，可以考虑使用，即保护性拷贝。

个人理解：
•　在某个时刻从某个类的实例到一个与此时此刻相同又不相互影响的实例，实际上就是动态抽取当前对象运行时的状态。
•　当然我们并不是在任何情况下创建复杂对象都适合用这种模式，例如我需要初始化一个复杂且干净的类时还是考虑使用工厂方法模式。

例子：
原型模式的原理是对象拷贝。在Java中使用clone方法复制一个对象，就是原型模式的体现了。日常工作中，在我们编辑Word文档的时候，为了安全起见会拷贝一份当前文档的状态再进行修改，下面我们以这个例子说明一下这个模式：

需求：实现文档拷贝

1、引用拷贝

1.1、Word中有文字和图片，因此创建一个Word文档对象。

public class WordDocument {
    private String mText;
    private ArrayList<String> mImages = new ArrayList<>();

    public void setText(String text) {
        this.mText = text;
    }

    public void addImages(String img) {
        this.mImages.add(img);
    }

    public void show() {
        System.out.println("------- Word Start ------");
        System.out.println("文本内容：" + mText);
        for (String imgs : mImages) {
            System.out.println("图片名称：" + imgs);
        }
        System.out.println("------- Word  End  ------");
    }
}

1.2、用引用拷贝实现

实现复制功能很多初学者第一时间可能是想到这样写：

public class Client {
    public static void main(String[] args) {
        WordDocument a = new WordDocument();
        a.setText("啦啦啦");

        //拷贝a对象
        WordDocument b = a;
        //修改b的内容
        b.setText("呵呵呵");
    }
}

输出结果却不如人意，修改b的时候把原始的文档a也同时修改了：

//a的原始内容输出：
文本内容：啦啦啦
//修改b后输出a:
文本内容：呵呵呵
//修改b后输出b:
文本内容：呵呵呵

1.3、引用拷贝概念
两个对象的引用相同，都指向同一个对象，就叫引用拷贝。我们抽离出核心代码解释一下：

WordDocument a = new WordDocument();
WordDocument b = a;

在内存中发生如下事情：

本质上是复制了一个引用b，同时指向了堆区的对象。所以通过b将"啦啦啦"修改为"呵呵呵"后，a的输出结果也为"呵呵呵"了。所以我们怎么做才能从堆区中复制一个对象呢？

2、对象拷贝

2.1、使用原型模式实现

在java中，Cloneable接口相当于Prototype，而我们的WordDocument就相当于ConcretePrototype了。因此我们修改下1.1中的类：

public class WordDocument implements Cloneable {
     //....省略部分代码
    @Override
    protected Object clone() throws CloneNotSupportedException {
        try {
            WordDocument doc = (WordDocument)super.clone();
            doc.mText = this.mText;
            doc.mImages = this.mImages;
            return doc;
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

2.2、修改一下1.1中的实现部分：

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        WordDocument a = new WordDocument();
        a.setText("啦啦啦");
        a.show();

        //拷贝a对象
        WordDocument b = (WordDocument) a.clone();
        //修改b的内容
        b.setText("呵呵呵");
    }
}

输出结果：

//a的原始内容输出：
文本内容：啦啦啦
//修改b后输出a:
文本内容：啦啦啦
//修改b后输出b:
文本内容：呵呵呵

2.3、对象拷贝概念
从堆区中复制一个类型和值都是之前的一样的对象，就叫对象拷贝。深拷贝和浅拷贝都是对象拷贝。关键代码如下：

WordDocument a = new WordDocument();
WordDocument b = (WordDocument) a.clone();

我们再看下内存中是怎样的：

通过clone()方法，堆区的"啦啦啦"复制出一个对象，b引用之后将它改为"呵呵呵"。它们的内存地址都是不同的。

3、浅拷贝与深拷贝

3.1、浅拷贝的实现
我们继续完善我们的代码，加入图片部分的逻辑：

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        WordDocument a = new WordDocument();
        a.setText("啦啦啦");
        a.addImages("图片1.jpg");
        a.addImages("图片2.jpg");
        a.addImages("图片3.jpg");
        a.show();

        WordDocument b = (WordDocument) a.clone();
        //修改B的内容
        b.setText("呵呵呵");
        b.addImages("呵呵.jpg");
        //同时输出
        a.show();
        b.show();
    }
}

输出结果：

------- Word Start ------
文本内容：啦啦啦
图片名称：图片1.jpg
图片名称：图片2.jpg
图片名称：图片3.jpg
------- Word  End  ------
------- Word Start ------
文本内容：啦啦啦
图片名称：图片1.jpg
图片名称：图片2.jpg
图片名称：图片3.jpg
图片名称：呵呵.jpg
------- Word  End  ------
------- Word Start ------
文本内容：呵呵呵
图片名称：图片1.jpg
图片名称：图片2.jpg
图片名称：图片3.jpg
图片名称：呵呵.jpg
------- Word  End  ------

我们不难发现，修改后图片部分的内容输出竟然是一致的。我们添加了"呵呵.jpg"直接插入了原来的数组里面了。因为在我们2.1中的clone()方法只是简单的进行浅拷贝，mImages只是单纯指向了this.mImages的引用，并没有重新构造一个mImages对象，这样导致了b中的mImages与原始文档是同一个对象了。

3.2、浅拷贝的概念
上述例子在内存的情况如下：

在浅拷贝中仅仅克隆基本类型的变量，而不克隆引用类型的变量。String类型也是一种引用类型，为什么却不受影响呢？

String类型非常特殊，它属于引用数据类型，不属于基本数据类型，但是String类型的数据是存放在常量池中的，也就是无法修改的。

3.3、深拷贝的实现
我们将2.1的clone方法修改，克隆方法中的对象也执行一下clone()方法：

public class WordDocument implements Cloneable {
    //省略部分代码
    @Override
    protected Object clone() throws CloneNotSupportedException {
        try {
            WordDocument doc = (WordDocument)super.clone();
            doc.mText = this.mText;
            doc.mImages = (ArrayList<String>) this.mImages.clone();
            return doc;
        } catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

再执行3.1中Client类的代码，效果如下：

------- Word Start ------
文本内容：啦啦啦
图片名称：图片1.jpg
图片名称：图片2.jpg
图片名称：图片3.jpg
------- Word  End  ------
------- Word Start ------
文本内容：啦啦啦
图片名称：图片1.jpg
图片名称：图片2.jpg
图片名称：图片3.jpg
------- Word  End  ------
------- Word Start ------
文本内容：呵呵呵
图片名称：图片1.jpg
图片名称：图片2.jpg
图片名称：图片3.jpg
图片名称：呵呵.jpg
------- Word  End  ------

我们看到，加了"呵呵.jpg"之后并不影响原本的对象了。再看一下内存：

4、总结

原型模式原理就是对象拷贝，而对象拷贝中分为浅拷贝和深拷贝。这个也是值得注意的问题。为了减少使用错误我认为都应该尽可能使用深拷贝，避免操作副本时影响原始对象的问题。

浅拷贝：仅仅复制基本类型的变量，而不复制引用类型的变量。
深克隆：既复制基本类型的变量，也复制引用类型变量。

感谢您的阅读~

推荐阅读

基础篇：
设计模式前篇之——UML类图必会知识点
设计模式前篇之——一起过一下面向对象的概念
创建型模式：
简易理解设计模式之：简单工厂模式——来试试接入支付功能
简易理解设计模式之：工厂方法模式——数据存储例子
简易理解设计模式之：抽象工厂模式——更换数据库例子
简易理解设计模式之：建造者模式——学习使用“链式调用”
简易理解设计模式之：原型模式——深、浅拷贝的概念
简易理解设计模式之：单例模式——单例模式的几种常用写法
结构型模式：
简易理解设计模式之：适配器模式——Android列表视图控件设计方式
简易理解设计模式之：桥接模式——穿衣服经典案例2
简易理解设计模式之：组合模式——实现View中的树状结构
简易理解设计模式之：装饰模式——穿衣服经典案例
简易理解设计模式之：外观模式——第三方SDK的帮助类
简易理解设计模式之：享元模式——五子棋游戏例子
简易理解设计模式之：代理模式——iOS视图控件设计方式
行为型模式：
简易理解设计模式之：策略模式——优化一下支付功能
简易理解设计模式之：模板方法模式——Android中的BaseActivity基类
简易理解设计模式之：观察者模式——监听与回调
简易理解设计模式之：状态模式——优化登录操作
简易理解设计模式之：备忘录模式——Word文档的工作原理
简易理解设计模式之：迭代器模式——遍历对象的好帮手
简易理解设计模式之：命令模式——实现命令的参数化配置
简易理解设计模式之：责任链模式——OA中请假流程示例
简易理解设计模式之：中介者模式——多人聊天室例子
简易理解设计模式之：解释器模式——语言和文法
简易理解设计模式之：访问者模式——员工考核例子