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