深度揭秘原型（深浅克隆）模式！

原型模式：
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

深克隆和浅克隆：
1、对于浅克隆

public class People implements Cloneable {
    String name;
    int age;
    Date date;
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public People(String name, int age, Date date) {
        super();
        this.name = name;
        this.age = age;
        this.date = date;
    }
    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;
    }

    @Override
    public String toString() {
        return "People [name=" + name + ", age=" + age + ", date=" + date + "]";
    }
    public People() {
        super();
    }

    public People(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {

        return super.clone();
    }

}

测试类：

public class Client {
    public static void main(String[] args) throws Exception {
        Date date = new Date(2364262352L);
        System.out.println(date);
        People p1 = new People("张三", 18,date);
        date.setTime(62786892498243L);
        System.out.println(date);
        People p2 = (People) p1.clone();

        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p1.hashCode() +"-----"+p2.hashCode());
        /*
         * 打印结果：
         * 
         * People [name=张三, age=18, date=Sat Aug 22 11:28:18 GMT+08:00 3959]
         * People [name=张三, age=18, date=Sat Aug 22 11:28:18 GMT+08:00 3959]
         *发现：克隆之后在修改时间依然还是没有变化。
         * */
    }
}

对于浅克隆，如图所示：

深克隆：
这里有两种方式：
1、通过重写clone方法，来实现深克隆。

/**
 * 深度克隆
 * */
public class People2 implements Cloneable {
    String name;
    int age;
    Date date;
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public People2(String name, int age, Date date) {
        super();
        this.name = name;
        this.age = age;
        this.date = date;
    }
    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;
    }

    @Override
    public String toString() {
        return "People [name=" + name + ", age=" + age + ", date=" + date + "]";
    }
    public People2() {
        super();
    }

    public People2(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    protected People2 clone() throws CloneNotSupportedException {
        //在克隆对象的同时把对象的属性也给克隆了
        Object obj = super.clone();
        People2 p = (People2) obj;
        Date d = (Date) p.date.clone();
        p.setDate(d);
        return p;
    }

}

测试代码：

public class Client2 {

    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date(2678264781672L);
        People2 p = new People2("张三",12,date);
        People2 p1 = p.clone();
        date.setTime(897892798732L);
        System.out.println(p);
        System.out.println(p1);
        /*
         * 打印结果：
         * People [name=张三, age=12, date=Mon Jun 15 14:39:58 GMT+08:00 1998]
         *  People [name=张三, age=12, date=Sat Nov 14 18:26:21 GMT+08:00 2054]
         * 可以观察到深度克隆之后，在修改属性此时就会发生变化
         * */

    }
}

第二种方式，通过序列化和反序列化来实现：

public class People3 implements Serializable {

    private static final long serialVersionUID = 1L;



    String name;
    Date date;
    @Override
    public String toString() {
        return "People3 [name=" + name + ", date=" + date + "]";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public People3(String name, Date date) {
        super();
        this.name = name;
        this.date = date;
    }
    public People3() {
        super();
        // TODO Auto-generated constructor stub
    }

    //内容写到数组里边然后在读取 ， 通过此种方式来深度复制对象
    public People3 clone(People3 p){
        //定义这个数组用于接收对象信息
        byte[] by=null;
        //初始化字节数组输出流
        ByteArrayOutputStream baos = null;
        //初始化对象输出流
        ObjectOutputStream oos = null;
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            //将对象写入到硬盘中
            oos.writeObject(p);
            by = baos.toByteArray();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
        //获取字节数组输入流
        ByteArrayInputStream bais = null;
        //获得对象输入六
        ObjectInputStream ois = null;
        try {
            //读取by数组
            bais = new ByteArrayInputStream(by);

            ois = new ObjectInputStream(bais);
            //通过反序列化读取到对象
            People3 p1= (People3) ois.readObject();
            //System.out.println(p);
            return p1;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                bais.close();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }
}

测试代码：

public class Client3 {
    public static void main(String[] args) {
        Date d = new Date(35483782375L);
        System.out.println(d);
        People3 p = new People3("张三",d);
        People3 p1 = p.clone(p);
        d.setTime(78946582782L);
        System.out.println("p的时间"+"---"+d);
        System.out.println("p"+"---"+p);
        System.out.println("p1"+"---"+p1);
        /*
         * 打印结果：
         *  Tue Feb 16 00:36:22 GMT+08:00 1971
         *  p的时间---Mon Jul 03 01:36:22 GMT+08:00 1972
         *  p---People3 [name=张三, date=Mon Jul 03 01:36:22 GMT+08:00 1972]
         *  p1---People3 [name=张三, date=Tue Feb 16 00:36:22 GMT+08:00 1971]
         *
         * 如上一种深克隆一样
         * */

    }
}

那么，原型模式到底在什么时候用？
假设一个系统的产品类是动态加载的，而且产品类具有一定的等级结构。这个时候如果采取工厂模式的话，工厂类就不得不具有一个相应的等级结构。而产品品类的等级结构一旦变化，工厂类的等级结构就不得不有以恶相应的变化。这对于产品结构可能会有经常变化的系统来说，采用工厂模式就有不方便之处。
此时若采用原型模式，给每一个产品类配备一个克隆方法（大多时候只需个产品类等级结构配备一个根类配备一个克隆方法），便可免去工厂模式所带来的据哟有固定等级结构的工厂类。

还有一点，假设通过普通方法创建对象很耗时时，也可采用原型模式，例如：

/**
 * 测试普通new方式创建对象和clone方式创建对象的效率差异！
 * 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！
 * 
 *
 */
public class Client4 {

    public static void testNew(int size){
        long start = System.currentTimeMillis();
        for(int i=0;i<size;i++){
            Laptop t = new Laptop();
        }
        long end = System.currentTimeMillis();
        System.out.println("new的方式创建耗时："+(end-start));
    }

    public static void testClone(int size) throws CloneNotSupportedException{
        long start = System.currentTimeMillis();
        Laptop t = new Laptop();
        for(int i=0;i<size;i++){
            Laptop temp = (Laptop) t.clone();
        }
        long end = System.currentTimeMillis();
        System.out.println("clone的方式创建耗时："+(end-start));
    }


    public static void main(String[] args) throws Exception {   
        testNew(1000);
        testClone(1000);
        /**
         * 测试结果：
         * new的方式创建耗时：10288
         *  clone的方式创建耗时：10
         *
         * 
         * */
    }
}


class Laptop implements Cloneable {  //笔记本电脑
    public Laptop() {
        try {
            Thread.sleep(10);  //模拟创建对象耗时的过程!
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();  //直接调用object对象的clone()方法！
        return obj;
    }

}