233_尚学堂_高淇_java300集最全视频教程_【GOF23设计模式】_原型模式_prototype_浅复制_深复制_反序列化实现深复制

原型模式分为深复制和浅复制
浅复制：只是拷贝对象本身，不拷贝对象的属性，所以”浅“。复制后的对象自然在内存中位于不同的地址中，因为本质上是两个对象，所以内存中的地址自然不同。但是复制之后的对象的属性却与原对象的属性相同，也就是两个对象的属性在内存中位于同一地址，并没有拷贝出另一份。复制（或者说拷贝）的意思是生成了另外的对象，只是复制对象本身，说明生成了本质上别的对象，在内存中另一个地方，没有复制对象的属性，说明两个对象的属性在内存中同一地方。

深赋值：既复制了对象本身，也复制了对象的属性，也就是说复制后的对象的属性在内存中的另外的地址中，尽管另外的地址中的内容跟原对象的相同。

public class Sheep01 implements Cloneable{
    private Date date;
    private String name;
    private Date birthday;

    public Sheep01(){
    }
    public Sheep01(Date date, String name, Date birthday) {
        this.date = date;
        this.name = name;
        this.birthday = birthday;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep01 s = (Sheep01) super.clone();
        s.date = (Date) this.date.clone();  //对date这个属性进行了深复制
        //birthday这个属性并没有深复制
        return s;
    }

    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

public class Demo01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //正确示例
        Date date1 = new Date();
        Date date2 = new Date();
        Sheep01 s1 = new Sheep01(date1, "hah", date2);
        Sheep01 s2 = (Sheep01) s1.clone();
        date1.setTime(234234234234L);
        date2.setTime(3423424234243L);
        System.out.println(s1.getDate()+"====="+s2.getDate());
        System.out.println(s1.getBirthday()+"====="+s2.getBirthday());
    }
}
/*
结果：
s1:Sat Jun 04 09:03:54 CST 1977=====s2:Mon Jun 15 22:48:45 CST 2015
s1:Sun Jun 26 07:10:34 CST 2078=====s2:Sun Jun 26 07:10:34 CST 2078
*/

因为s2的date进行了深复制，所以s2的date跟s1的虽然开始时间值相同，但是是不同的对象，所以改变s1的date的时间之后，s2的date的时间并没有变化。
因为s2的birthday是浅赋值，s2的birthday与s1的birthday是同一个对象，所以改变了s1的birthday后s2的birthday自然会变化。
这里注意一个问题：

public class Demo01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //错误示例，set的时候，不能new新的对象
        Sheep01 s1 = new Sheep01(new Date(), "hah", new Date(1121212121L));
        Sheep01 s2 = (Sheep01) s1.clone();
        s1.setDate(new Date(333223223L));
        s1.setBirthday(new Date(45645454534L));
        System.out.println(s1.getDate()+"====="+s2.getDate());
        System.out.println(s1.getBirthday()+"====="+s2.getBirthday());
    }
}
/*
结果：
s1:Mon Jan 05 04:33:43 CST 1970=====s2:Mon Jun 15 22:52:23 CST 2015
s1:Sun Jun 13 15:17:34 CST 1971=====s2:Wed Jan 14 07:26:52 CST 1970
*/

这里s1在设置时间的时候，并不是改变原来的对象的时间值，而是让s1的date和birthday指向其他的对象，原来的对象没有变化，所以改了s1之后s2并不会变化，所以输出结果无论是深复制还是浅赋值，s1和s2的结果都是不同的。

通过反序列化实现深复制，不需要在clone方法中手动写深复制需要的代码。例程如下：

import java.io.Serializable;
import java.util.Date;

public class Sheep02 implements Cloneable, Serializable{
    private Date date;
    private String name;
    private Date birthday;

    public Sheep02(){
        // TODO Auto-generated constructor stub
    }
    public Sheep02(Date date, String name, Date birthday) {
        super();
        this.date = date;
        this.name = name;
        this.birthday = birthday;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        Sheep02 s = (Sheep02) super.clone();
        return s;
    }

    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

}

/**
 * 通过反序列化实现深复制，用到两种IO流
 * @author Hong
 *
 */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        Date date = new Date();
        Sheep02 s = new Sheep02();
        s.setDate(date);
        System.out.println("s:  "+s.getDate());
        //os可以将对象转换成输出流，同时bao可以获得这个输出流，并且可以转化成字节数组
        ByteArrayOutputStream bao = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bao);

        oos.writeObject(s);
        byte[] b = bao.toByteArray();

        //bai可以将字节数组转化成输入流，ois可以获得这个输入流，并且将输入流转化成对象
        ByteArrayInputStream bai = new ByteArrayInputStream(b);
        ObjectInputStream ois = new ObjectInputStream(bai);

        Sheep02 s2 = (Sheep02) ois.readObject();
        System.out.println("s2:  "+s2.getDate());

        date.setTime(23232323232L);

        System.out.println("s:  "+s.getDate() +"----s2:  "+s2.getDate());
    }
}

/**
运行结果：
s:  Thu Jun 18 21:01:56 CST 2015
s2:  Thu Jun 18 21:01:56 CST 2015
s:  Sun Sep 27 05:25:23 CST 1970----s2:  Thu Jun 18 21:01:56 CST 2015
**/