设计模式之原型模式

原型模式是指构建对象时候不需要考虑对象的构造函数和数据，从原有基础之上复刻出来一个新的对象并且保留原有的数据。具体原型模式又分为两种
1.深克隆 2.潜克隆
两者区别？
浅克隆只复制基本数据类型，引用数据类型会指向同一个地址。
深克隆更消耗性能，它需要通过序列化和反序列化将类重新写入到内存中实现所有数据都独立的效果。原型模式本身对单例模式有冲突，不能同时存在，因为两者是互斥的。

public class CloneStudent implements Cloneable,Serializable {
    private long number;                //学号
    private String name;            //名字
    private int age;                //年龄
    private List<String> clazz;     //课程
    //浅克隆实现方式
    @Override
    protected CloneStudent clone() throws CloneNotSupportedException {
        return (CloneStudent)super.clone();
    }

    //深克隆实现方式
    public CloneStudent deepClone(){
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            try {
                return (CloneStudent) ois.readObject();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
            return null;
    }
    public long getNumber() {
        return number;
    }

    public void setNumber(long number) {
        this.number = number;
    }

    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 List<String> getClazz() {
        return clazz;
    }

    public void setClazz(List<String> clazz) {
        this.clazz = clazz;
    }

    @Override
    public String toString() {
        return "number:"+number+";name:"+name+";age:"+age+";clazz:"+clazz.toString();
    }