原型模式（创建型）

定义：
使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。
两个角色：
抽象原型类：定义抽象原型，可以是抽象类也可以是接口，需要继承Cloneable接口或自行设计克隆接口。
具体原型类：实现抽象原型类中保留的方法。

浅克隆：仅仅复制原型对象以及其中的值类型变量，引用类型变量不会被复制而是传递引用。
深克隆：复制原型对象以及其中的所有成员变量。

---

浅克隆：

// 抽象原型类  实现Cloneable接口并重写clone方法
public abstract class AbstractCopy implements Cloneable
{

    protected int id;
    protected Sun sun;
    
    public abstract void func();

    @Override
    protected Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}

//具体原型类
public class Copy extends AbstractCopy
{

    public Copy(int id, Sun sun)
    {
        this.id = id;
        this.sun = sun;
    }

    @Override
    public void func()
    {
        System.out.println("id = "+id);
        System.out.println(sun.toString());
    }
}

// 引用类型对象
public class Sun{
    private int id;
    private String name;

    public Sun(int id, String name)
    {
        this.id = id;
        this.name = name;
    }
    // geter/seter 
    .....
    @Override
    public String toString()
    {
        return "Sun{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
// 客户端
public class Client{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        AbstractCopy copy = new Copy(1,new Sun(1,"suntd"));
        AbstractCopy cc = (AbstractCopy) copy.clone();
        copy.func();
        cc.func();
    }
}
Output:
id = 1
Sun{id=1, name='suntd'}
id = 1
Sun{id=1, name='suntd'}

---

深克隆：

// 抽象原型类同上

// 具体原型类
public class Copy extends AbstractCopy{
    public Copy(int id, Sun sun)
    {
        this.id = id;
        this.sun = sun;
    }

    @Override
    public void func()
    {
        System.out.println("id = "+id);
        System.out.println(sun.toString());
    }
 
    // 重写 clone 方法实现深克隆
    @Override
    protected Object clone() throws CloneNotSupportedException
    {
         Sun sunn = (Sun) sun.clone();
        return new Copy(id,sunn);
    }
}

//  客户端方法同上