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

本文链接：https://blog.csdn.net/qq_15719613/article/details/105156680

介绍：

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

类图：
原型模式UML类图.png
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;

在内存中发生如下事情：

引用拷贝.png
本质上是复制了一个引用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();

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

对象拷贝.png
通过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、浅拷贝的概念
上述例子在内存的情况如下：

浅拷贝.png
在浅拷贝中仅仅克隆基本类型的变量，而不克隆引用类型的变量。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  ------