原型模式-创建型--设计模式-深拷贝-浅拷贝

原型模式介绍

1. 原型模式（Prototype模式）指的是：用原型示例值指定创建的对象，并通过拷贝这些原型，创建新的对象。
2. 原型模式是一种创建型设计模式，允许一个对象在创建另一个可定制的对象，无需知道如何创建的细节。
3. 工作原理：通过将一个原型对象传给那个要发懂创建的对象，这个要发动创建的对象通过请求原型对象拷贝它自己来实施创建，即对象.clone()

案例分析

克隆羊的问题：
现在有一只羊，姓名为：Tom年龄为1，颜色为：白色，请编写程序创建和Tom阳属性完全相同的10只羊。
最简单的办法就是new10只相同的对象即可

public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
    }
}

优缺点：

1. 优点就是比较好理解，简单易操作
2. 在创建对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
3. 总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活。

改进思路 ：
Java中Object类是所有类的基类，Object类提供了一个clone()方法该方法可以将Java对象赋值一份，但需要实现clone的Java类必须实现一个接口Cloneable，该接口表示该类具有能够被复制的能力——原型模式。

类图说明：

1. Prototype：原形类，声明一个克隆自己的接口
2. ConcretePrototype1：具体的原型类，实现一个克隆自己的操作
3. Client：让一个原型对象克隆自己，从而创建一个新的对象（属性一样）

使用原型模式解决

使用原型模式改进传统方式，让程序具有更高的效率和扩展

上面我们让Sheep类继承了Cloneable然后重写其中的Clone()方法，之后在事项刚开始的创建10只相同的🐏的时候就可以通过下面这种写法来实现。

public class Client {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("tom", 1, "白色");
       Sheep sheep2 = (Sheep)sheep1.clone();
    }
}

深拷贝和浅拷贝

1. 对于数据类型实基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性只复制一份给新的对象。
2. 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类型对象等，那么浅拷贝会进行引用传递，也就是只将该成员变量的引用值（内存地址）赋值一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例，这种情况下，在一个对象中修改成员变量会影响另一个对象的该成员变量值。
3. 前面我们克隆羊就是浅拷贝
4. 浅拷贝时使用默认的Clone（）方法实现的。（需要拷贝对象实现Cloneable）
5. sheep = (Sheep) super.clone() 浅拷贝

深拷贝基本介绍

1. 赋值对象的所有基本数据类型的成员变量值
2. 为所有引用数据类型的成员变量申请内存空间，并复制每个引用数据类型成员变量所引用的对象，知道该对象可到的所有对象。也就是说对象进行深拷贝要对整个对象进行拷贝。
3. 深拷贝实现方式1：重写clone方法来实现深拷贝
4. 深拷贝实现方式2：通过对象序列化实现深拷贝
   示例代码：

public class DeepCloneableTarget implements Serializable, Cloneable {

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private String cloneName;

    private String cloneClass;

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

    //因为该类的属性都是String，因此我们这里使用默认的clone完成即可。
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.zhao.prototype.deepclone;

import java.io.*;

/**
 * @Author Zhao
 * @Date 2021-06-24 下午 10:52
 * @Version 1.0
 */
//要想实现序列化必须实现Serializable接口
public class DeepPrototype implements Serializable,Cloneable {
    static final long serialVersionUID = 3L;

    public String name;//String 属性
    public DeepCloneableTarget deepCloneableTarget;//引用数据类型

    public DeepPrototype() {
    }

    //深拷贝 - 方式一 使用克隆方法

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //这里完成对基本数据类型（属性）和String的克隆
        deep = super.clone();
        //对引用类型的属性 单独处理
        DeepPrototype deepPrototype = (DeepPrototype)deep;
        deepPrototype.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
        return deepPrototype;
    }

    //深拷贝 - 方式2 通过序列化实现（推荐使用）
    public Object deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);//当前这个对象以对象流的方式输出
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepPrototype o = (DeepPrototype) ois.readObject();
            return o;
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return null;
        }finally {
            try {
                assert bos != null;
                bos.close();
                assert oos != null;
                oos.close();
                assert bis != null;
                bis.close();
                assert ois != null;
                ois.close();
            }catch (Exception e){
                System.out.println(e.getMessage());
            }
        }
    }

}

测试 ：

package com.zhao.prototype.deepclone;

/**
 * @Author Zhao
 * @Date 2021-06-24 下午 10:59
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) throws Exception {
        DeepPrototype p = new DeepPrototype();
        p.name = "小黑";
        p.deepCloneableTarget = new DeepCloneableTarget("jack", "Jack");

        //方式1 完成深拷贝
        DeepPrototype p2 = (DeepPrototype) p.clone();

        System.out.println(p.deepCloneableTarget.hashCode());
        System.out.println(p2.deepCloneableTarget.hashCode());
        System.out.println("===================================");
        //方式2 通过序列化的方式进行深拷贝
        Object o = p.deepClone();
        DeepPrototype p3 = (DeepPrototype) o;

        System.out.println(p.deepCloneableTarget.hashCode());
        System.out.println(p3.deepCloneableTarget.hashCode());
    }
}

深拷贝最后创建的对象打印的哈希值是相同的。

原型模式的注意事项和细节

1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
2. 不用重新初始化对象，而是动态地获取对象运行时的状态
3. 如果原始对象发生变化（增加或者减少属性），其他克隆的对象也会发生相应的变化，无需修改代码
4. 在实现深克隆的时候可能需要比较复杂的代码
5. 缺点：需要为每一个类配备一个克隆方法，这对全新的类不是很难，但对已有的类进行改造时，需要修改其源代码，违背了OCP原则，这点要注意。