设计模式之原型模式

原型模式（Prototype）: 用原型示例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。

克隆又分为浅克隆和深克隆，在java中，我们可以使用clone（）方法快速实现对象的克隆。

---

浅克隆： 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

---

首先，来一个我们需要克隆的类MyPrototype，其中包含了int,String,List,Address类型的数据。要实现对象的浅克隆我们需要实现Cloneable接口。Serializable 接口是为了实现对象的深克隆：

public class MyPrototype implements Cloneable,Serializable {

    private int age;
    private String name;
    private List<String> prototes;
    private Address address;

    public Address getAddress() {
        return address;
    }

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

    public List<String> getPrototes() {
        return prototes;
    }

    public void setPrototes(List<String> prototes) {
        this.prototes = prototes;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "MyPrototype{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", prototes=" + prototes +
                ", address=" + address.getAddress() +
                '}';
    }

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

Address:

public class Address implements Serializable{

    private String address;

    public String getAddress() {
        return address;
    }

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

运行：

public class test {

    public static void main(String[] args) {
        MyPrototype p1 = new MyPrototype();
        p1.setName("aaa");
        p1.setAge(111);

        List list = new ArrayList();
        list.add("a");
        list.add("b");
        p1.setPrototes(list);
        Address address = new Address();
        address.setAddress("上海");
        p1.setAddress(address);

        MyPrototype p2 = null;
        try {
//            通过clone而不是直接创建对象
            p2 = (MyPrototype) p1.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(p1.toString());
        System.out.println(p2.toString());

//        MyPrototype{age=111, name='aaa', prototes=[a, b], address=上海}
//        MyPrototype{age=111, name='aaa', prototes=[a, b], address=上海}


//      int,String等数据类型克隆对象会自己维护一份数据，修改不会影响原对象的值
        p2.setName(null);
        p2.setAge(0);

//      使用list,自定义对象等数据类型时原对象和克隆对象的值指向同一个地址，修改克隆对象会影响原有对象的属性值
//        如果我们想要实现各种维护各自的属性值，就需要实现深克隆。
        p2.getPrototes().clear();
        p2.getAddress().setAddress("北京");

        System.out.println(p1.toString());
        System.out.println(p2.toString());
//        MyPrototype{age=111, name='aaa', prototes=[], address=北京}
//        MyPrototype{age=0, name='null', prototes=[], address=北京}


    }

}

其中：实现浅克隆只需要p2 = (MyPrototype) p1.clone();这一行代码就够了。我们需要注意的是属性值修改时的变化情况。都写在注释里了。

---

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

---

这里，我们使用序列化Serializable来进行对象的深克隆。简单点说，就是将原对象写入到数据流中，在从数据流读取出来并新建一个克隆对象。在MyPrototype类中新增一个方法：

    public Object deepClone() throws Exception {

        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);

        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return oi.readObject();

    }

运行：

public class test2 {

    public static void main(String[] args) {

        MyPrototype p1 = new MyPrototype();
        p1.setName("aaa");
        p1.setAge(111);

        List list = new ArrayList();
        list.add("a");
        list.add("b");
        p1.setPrototes(list);
        Address address = new Address();
        address.setAddress("上海");
        p1.setAddress(address);

        MyPrototype p2 = null;
        try {
//            通过深克隆
            p2 = (MyPrototype) p1.deepClone();

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(p1.toString());
        System.out.println(p2.toString());
//        MyPrototype{age=111, name='aaa', prototes=[a, b], address=上海}
//        MyPrototype{age=111, name='aaa', prototes=[a, b], address=上海}


        //实现深克隆之后，修改克隆对象的属性值，不会影响到原有对象
        p2.setName(null);
        p2.setAge(0);

        p2.getPrototes().clear();
        p2.getAddress().setAddress("北京");

        System.out.println(p1.toString());
        System.out.println(p2.toString());
//        MyPrototype{age=111, name='aaa', prototes=[a, b], address=上海}
//        MyPrototype{age=0, name='null', prototes=[], address=北京}

    }

}

作为创建型模式的一种，就是为我们用来创建对象的。与直接new一个对象相比，原型模式是在内存二进制流的拷贝。如果要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。

注意点：直接在内存中拷贝，构造函数是不会执行的。

源码地址

本文地址：http://blog.csdn.net/ProdigalWang/article/details/77044045