java设计模式之原型模式

原型模式概念

　　该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。java中复制通过clone()实现的。clone中涉及深、浅复制。深、浅复制的概念如下：

　　⑴浅复制（浅克隆） 

   　　 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址

　　⑵深复制（深克隆） 

   　　 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 

package com.Geeksun.prototype;

import java.io.*;
import java.util.Date;

public class Girl implements Cloneable, Serializable {
    private static final long serialVersionUID = 1107125866318890906L;
    private String name;
    private Date birthday;
    private Address address;

    public Girl(String name, Date birthday,Address address) {
        this.name = name;
        this.birthday = birthday;
        this.address = address;
    }

    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 Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                ", birthday=" + birthday +
                ", address=" + address +
                '}';
    }

    //浅复制
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        return super.clone();
//    }

    //深复制1
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Girl girl = (Girl)super.clone();
        girl.setAddress((Address) address.clone());
        girl.setBirthday((Date)birthday.clone());
        return girl;
    }

    //深复制2
    public Object deepClone()throws IOException,ClassNotFoundException {
        /* 写入当前对象的二进制流 */
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

class Address implements Cloneable,Serializable{

    public Address(){ }

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }

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

package com.Geeksun.prototype;

import java.util.Date;

public class Client {

    public static void main(String[] args) throws Exception {
        Address address = new Address();
        address.setAddress("HuBei");
        Girl girl = new Girl("Geeksun",new Date(),address);
        System.out.println(girl);
        Girl newGirl = (Girl) girl.deepClone();
        newGirl.getBirthday().setTime(1235);
        newGirl.getAddress().setAddress("BeiJing");
        System.out.println(girl);
        System.out.println(newGirl);
    }
}

最后得到的结果是

Girl{name='Geeksun', birthday=Thu Feb 21 17:41:44 CST 2019, address=Address{address='HuBei'}}
Girl{name='Geeksun', birthday=Thu Feb 21 17:41:44 CST 2019, address=Address{address='HuBei'}}
Girl{name='Geeksun', birthday=Thu Jan 01 08:00:01 CST 1970, address=Address{address='BeiJing'}}

　　 拷贝还有2个知识点，对象拷贝时，类的构造函数是不会被执行的。一个实现了 Cloneable 并重写了 clone 方法的类 Programmer,有一个无参构造或有参构造 ，通过 new 关键字产生了一个对象 A，再然后通过 A.clone()方式产生了一个新的对象 T，那么在对象拷贝时构造函数是不会被执行的。即拷贝的过程中只执行一次构造方法。

　　Clone 与 final 两对冤家。对象的 clone 与对象内的 final 属性是由冲突.在上面的Programmer类中修改为private final Address address;去掉get,set方法， proto.address=(Address) address.clone();这一句就会报错： proto.address=(Address) address.clone();final类型不能重新设置值。解决办法就是删除掉fina咯

　　深拷贝和浅拷贝建议不要混合使用，一个类中某些引用使用深拷贝某些引用使用浅拷贝，这是一种非常差的设计，特别是是在涉及到类的继承，父类有几个引用的情况就非常的复杂，建议深拷贝和浅拷贝分开实现。