3.创建型-原型模式

1.原型模式(Prototype 模式)是指：

	1.用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
    2.原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
    3.工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()
    4.形象的理解：孙大圣拔出猴毛， 变出其它孙大圣

2.UML类图

原理结构图说明
Prototype : 原型类，声明一个克隆自己的接口
ConcretePrototype: 具体的原型类, 实现一个克隆自己的操作
Client: 让一个原型对象克隆自己，从而创建一个新的对象(属性一样）

package com.zjc.designmode.prototype;

/**
* @author : zoujc
* @date : 2020/11/9
* @description : 原型模式
*/
public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String color;


    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }


    public String getColor() {
        return color;
    }


    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    public Sheep() {
    }

    @Override
    protected Object clone(){
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }

}

class SheepTest{
    public static void main(String[] args) {
        Sheep sheep = new Sheep("多利",10,"黑色");
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();
        Sheep sheep5 = (Sheep) sheep.clone();
        System.out.println(sheep1);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
    }
}

3.Spring中原型bean的创建,就是原型模式的应用

4.浅拷贝
a.对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
b.对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
c.前面写的原型模式是浅拷贝
d.浅拷贝是使用默认的 clone()方法来实现
sheep = (Sheep) super.clone();

5.深拷贝
a.复制对象的所有基本数据类型的成员变量值
b.为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷贝
c.深拷贝实现方式 1：重写 clone 方法来实现深拷贝
d.深拷贝实现方式 2：通过对象序列化实现深拷贝(推荐)

package com.zjc.designmode.prototype;


import java.io.Serializable;


/**
* @author : zoujc
* @date : 2020/11/9
* @description : 深拷贝时候所要用到的类
*/
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.zjc.designmode.prototype;


import java.io.*;


/**
* @author : zoujc
* @date : 2020/11/9
* @description : 深拷贝实现
*/


public class DeepProtoType implements Serializable, Cloneable{


    public String name; //String 属 性
    public DeepCloneableTarget deepCloneableTarget;// 引用类型
    public DeepProtoType() { super();
    }


    //深拷贝 - 方式 1  使用 clone 方法
    @Override
    protected Object clone() throws CloneNotSupportedException {


        Object deep = null;
        //这里完成对基本数据类型(属性)和 String 的克隆
        deep = super.clone();
        //对引用类型的属性，进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType)deep;
        deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();


        // TODO Auto-generated method stub
        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 copyObj = (DeepProtoType)ois.readObject();
            return copyObj;
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        } finally {
        //关闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
     } catch (Exception e2) {
        // TODO: handle exception
            System.out.println(e2.getMessage());
            }
        }
    }
}

package com.zjc.designmode.prototype;


/**
* @author : zoujc
* @date : 2020/11/9
* @description :
*/
public class Client {


    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        DeepProtoType p = new DeepProtoType(); p.name = "宋江";
        p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");


        //方式 1  完成深拷贝
        // DeepProtoType p2 = (DeepProtoType) p.clone();
        //
        // System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
        // System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());


        //方式 2  完成深拷贝
        DeepProtoType p2 = (DeepProtoType) p.deepClone();


        System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
        System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    }


}