原型模式

原型模式（Prototype Pattern）属于创建型模式。用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式可以用来创建重复对象。java中通过实现Cloneable接口，重写clone方法实现。

一个简单的浅克隆的demo：

public class ProtoType implements Cloneable {
    private int num;

    public ProtoType() {
        System.out.println("执行构造方法");
        num = 1;
    }

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "num = " + num;
    }

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

调用：

ProtoType protoType = new ProtoType();
System.out.println(protoType);

// clone一个对象，不会执行构造方法
ProtoType protoType1 = protoType.clone();
System.out.println(protoType1);

// 原对象的属性(基本数据类型和String类型)变了，clone对象中的这个属性不会变
protoType.setNum(2);
System.out.println(protoType);
System.out.println(protoType1);

输出结果：

执行构造方法 
num = 1 

num = 1 

num = 2 
num = 1

但是，浅克隆中克隆对象中的对象，只是克隆了对象的引用，而不是拷贝对象，demo：

public class ClassA {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class ProtoType implements Cloneable {
    private ClassA classA;

    public ProtoType() {
        classA = new ClassA();
        classA.setName("momo");
    }

    public ClassA getClassA() {
        return classA;
    }

    @Override
    public String toString() {
        return classA.getName();
    }

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

调用：

ProtoType protoType = new ProtoType();
ProtoType protoType1 = protoType.clone();

// 对象中的对象改变了，clone的也会改变
protoType.getClassA().setName("mmxb");
System.out.println(protoType);
System.out.println(protoType1);

输出结果：

mmxb
mmxb

把上面的例子改为深克隆：

public class ClassA implements Cloneable {
    String name;

    public String getName() {
        return name;
    }

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

    // 实现Cloneable接口
    @Override
    protected ClassA clone() {
        Object object = null;
        try {
            object = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return (ClassA) object;
    }
}

public class ProtoType implements Cloneable {
    private ClassA classA;

    public ProtoType() {
        classA = new ClassA();
        classA.setName("momo");
    }

    public ClassA getClassA() {
        return classA;
    }

    @Override
    public String toString() {
        return classA.getName();
    }

    @Override
    protected ProtoType clone() {
        Object object = null;
        try {
            object = super.clone();
            // clone包含的对象
            ((ProtoType)object).classA = classA.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return (ProtoType) object;
    }
}

优点：由于clone方法是由虚拟机直接复制内存块执行，所以在速度上比使用new的方式创建对象要快。可以在运行时动态的获取对象的类型以及状态，从而创建一个对象。

缺点就是实现深度拷贝比较困难，需要很多额外的代码量。