基本介绍

1）原型模式（Prototype模式）是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象

2）原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节

3）工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone（）

浅拷贝

1)对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。

2)对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

3浅拷贝是使用默认的 clone（）方法来实现sheep=(Sheep)super.clone();

深拷贝

1)复制对象的所有基本数据类型的成员变量值

2)为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝

3)深拷贝实现方式1：重写clone方法来实现深拷贝

4)深拷贝实现方式2：通过对象序列化实现深拷贝

public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tome",1,new Dog("joy",2));
        //方式1
        Sheep sheep1 = sheep.clone();
        System.out.println(sheep.hashCode()+"===="+sheep.getDog().hashCode());
        System.out.println(sheep1.hashCode()+"===="+sheep1.getDog().hashCode());
        //方式2
        Sheep deepSheep = sheep.deepClone();
        System.out.println(sheep.hashCode()+"===="+sheep.getDog().hashCode());
        System.out.println(deepSheep.hashCode()+"===="+deepSheep.getDog().hashCode());
    }
}
Sheep()类
public class Sheep implements Cloneable, Serializable {
    private String name;
    private int age;
    public  Dog dog;
    //实现Cloneable重写clone()方法实现深拷贝 
    @Override
    protected Sheep clone() {
        Sheep s = null;
        try {
            s = (Sheep) super.clone();
            //深拷贝；这里做friend得类属性的处理
            s.dog = (Dog) s.getDog().clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return s;
    }
    
    public Sheep(String name, int age, Dog dog) {
        this.name = name;
        this.age = age;
        this.dog = dog;
    }
    //序列化和反序列化得方式实现深拷贝
    public Sheep 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);
            Sheep sheep = (Sheep) ois.readObject();
            return sheep;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}
Dog()类
public class Dog implements Serializable,Cloneable {
    private String name;
    private int age;

        public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Dog dog = null;
        try {
            dog = (Dog) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return dog;
    }
}