• 问题引入：
• 创建一只羊对象，名字为tom，年龄为1，颜色为白色。之后创建多只与该羊完全相同的羊。

传统方法

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

public class Client {
    public static void main(String[] args) {
        // 传统方法
        Sheep sheep = new Sheep("tom","白色",1);
        Sheep sheep1 = new Sheep(sheep.getName(),sheep.getColor(),sheep.getAge());
        Sheep sheep2 = new Sheep(sheep.getName(),sheep.getColor(),sheep.getAge());
        System.out.println(sheep);
        System.out.println(sheep1);
        System.out.println(sheep2);
    }
}

原型模式

• 原型模式是指用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象；
• 原型模式也是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节；

利用Cloneable接口实现浅拷贝

// 这里需要实现Cloneable，并在后面重写clone方法
public class Sheep implements Cloneable{
    private String name;
    private String color;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

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

    public int getAge() {
        return age;
    }

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

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

    // 克隆该实例，使用默认的clone方法来完成
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

浅拷贝

• 对于数据类型为基本数据类型的成员变量，浅拷贝会直接进行数值传递，也就是将该属性值复制一份给新的对象；
• 对于数据类型时引用类型的成员变量，比如说成员变量时某个数组、某个类的对象等，那么浅拷贝会进行引用传递。因此，实际上两个对象的该成员变量指向的都是同一个实例。这种情况下，对于成员变量的修改会相互影响。
• 例如如下代码，在构造Sheep对象时传入了Person对象。由于浅拷贝的原因，每一个Sheep对象都指向了同一Person对象；

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("tom","白色",1,new Person("John"));
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        System.out.println(sheep);
        System.out.println(sheep.getOnwer().hashCode());
        System.out.println(sheep1);
        System.out.println(sheep1.getOnwer().hashCode());
        System.out.println(sheep2);
        System.out.println(sheep2.getOnwer().hashCode());
        sheep.onwer.setName("Alice");
        System.out.println(sheep);
        System.out.println(sheep.getOnwer().hashCode());
        System.out.println(sheep1);
        System.out.println(sheep1.getOnwer().hashCode());
        System.out.println(sheep2);
        System.out.println(sheep2.getOnwer().hashCode());
    }
}

深拷贝

• 复制对象的所有基本数据类型的成员变量值
• 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。
• 实现方式1：重写clone()方法实现深拷贝

@Override
    protected Object clone() throws CloneNotSupportedException {
        DeepProtoType deep = null;

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

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

// 方式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 deepProtoType = (DeepProtoType) ois.readObject();
            return deepProtoType;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }