Java23种设计模式——原型模式

该系列文章为博主学习笔记，原文请参考参考链接
本文禁止转载，但是欢迎大家留言区留言交流[微笑]

原形模式总（面）结（试）：原型模式是一种对象创建型模式，通过创建一个原形对象，通过克隆方法（调用父类的克隆方法或者序列化），返回一个全新的对象，它们在内存中拥有新的地址。

这里的克隆方法分为两种：
1、调用父类的克隆方法
该对象应该实现Cloneable接口，在克隆方法中调用super.clone()方法，返回一个全新的对象，改方法属于浅克隆。
2、在该对象中实现Serializable接口，在克隆方法中运用序列化和反序列化生产一个全新的对象，该方法属于深度克隆。

浅克隆和深克隆简单的来讲：是否支持引用类型成员变量的复制。

对于int、double等成员变量，深克隆和浅克隆都是将值复制一份。
而对于引用类型的成员变量，例如类、接口等等，浅克隆复制出来的新对象跟原有对象还是共享同一个内存地址。如果复制的对象更改了值，那么原来对象的值也会被更改。所以我建议使用深克隆。

代码如下：

public class Customer implements Serializable {    private Address address;    private String name;    private int age;    public Address getAddress() {        return address;    }    public void setAddress(Address address) {        this.address = address;    }    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 Customer deepClone() throws IOException, ClassNotFoundException {        //将对象写入流中        ByteArrayOutputStream bao = new ByteArrayOutputStream();        ObjectOutputStream oos = new ObjectOutputStream(bao);        oos.writeObject(this);        //将对象从流中取出        ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());        ObjectInputStream ois = new ObjectInputStream(bis);        return (Customer) ois.readObject();    }}

public class Address implements Serializable {    private String adress;    public String getAdress() {        return adress;    }    public void setAdress(String adress) {        this.adress = adress;    }}

public class myClass {    public static void main(String[] args) {        Customer customer = new Customer();        Address address = new Address();        customer.setAddress(address);        Customer deepClone = null;        try {            deepClone = customer.deepClone();        } catch (IOException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        }        System.out.println(customer == deepClone);        System.out.println(customer.getAddress() == deepClone.getAddress());    }}

输出：

false
false

这里使用了深克隆，不仅被克隆对象要实现Serializable接口，同时该对象里面的引用对象Address类也要实现Serializable接口。

如果我们换成实现Cloneable接口，我们对Customer类进行如下更改：

public class Customer implements Cloneable {    private Address address;    private String name;    private int age;    public Address getAddress() {        return address;    }    public void setAddress(Address address) {        this.address = address;    }    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 Customer deepClone() throws IOException, ClassNotFoundException {        Object clone = null;        try {            clone = super.clone();        } catch (CloneNotSupportedException e) {            e.printStackTrace();        }        return (Customer) clone;    }}

输出:
false
true

可以看到通过实现Cloneable接口，当被复制的类中有引用对象时，复制完之后的对象和复制之前的对象他们的内存地址是一样的。

微信公众号：

QQ群：365473065