设计模式—原型模式

设计模式—原型模式

一、 概述

复制粘贴功能我们都用过，我们可以把一个文件从一个地方复制到另外一个地方，复制完成之后这个文件和之前的文件也没有一点差别，这就是原型模式的思想：首先创建一个实例，然后通过这个实例去拷贝创建新的实例。

首先我们可以看到一共有三个角色：

（1）Client 角色：客户类提出创建对象的请求；也就是我们用户使用复制粘贴的功能。

（2）原始文件 角色：此角色定义了的具体原型类所需的实现的方法。也就是定义一个文件，说明一下它有被克隆复制的功能。

（3）具体拷贝文件 角色：实现抽象原型角色的克隆接口。就是我们的文件实现了可以被复制的功能。

我们会发现其实原型模式的核心就是原始文件 角色，他需要继承Cloneable接口，并且重写Object类中的clone方法才能有复制粘贴的功能。

二、浅拷贝与深拷贝

既然我们知道原型模式的核心就是拷贝对象，那么我们能拷贝一个对象实例的什么内容呢？这就要区分深拷贝和浅拷贝之分了。

（1）浅拷贝：我们只拷贝对象中的基本数据类型（8种），对于数组、容器、引用对象等都不会拷贝，只是把指向实例对象的引用复制一份，即指向的是同一个实例。

（2）深拷贝：不仅能拷贝基本数据类型，还能拷贝那些数组、容器、引用对象等，会把实例对象完全复制一份，即内存中有两份实例。

下面我们就使用代码去实现一下原型模式。这里实现的是基本类型与引用类型。

三、代码实现

3.1 浅拷贝（Object.clone()）

原始文件：Person类

• 必须实现Cloneable接口，才被允许拷贝，否则运行时报异常

public class Person implements Cloneable{
    private String name;
    private int age;
    private Car car;

    @Override
    public Object clone() throws CloneNotSupportedException {
        //基本数据类型的克隆
        Person prototype = (Person)super.clone();
        return prototype;
    }

    public Person(String name, int age, Car pc) {
        this.name = name;
        this.age = age;
        this.car = pc;
    }

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

引用类型：Car类

public class Car implements Cloneable{
    private String name;

    public Car(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }

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

Cllient：Test类

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {

        Car car = new Car("奥迪");
        Person zhangsan = new Person("张三", 20, car);
        //开始拷贝
        Person lisi = (Person)zhangsan.clone();
        System.out.println(zhangsan);
        System.out.println(lisi);
        System.out.println(zhangsan.getCar() == lisi.getCar());
    }
}

执行结果

Person{name='张三', age=20, car=Car{name='奥迪'}}
Person{name='张三', age=20, car=Car{name='奥迪'}}
true

通过执行结果可以看出，进行浅拷贝后两个对象的输出结果是一样的，并且引用类型Car的地址比较也是true。所以说明：浅拷贝不会拷贝一份引用类型的实例对象。

3.2 深拷贝

3.2.1 Object.clone()方式

还是基于上面的代码进行修改，修改的地方会标记出来

原始文件：Person类

• 必须实现Cloneable接口，才被允许拷贝，否则运行时报异常
• 当前引用类型也必须进行拷贝

public class Person implements Cloneable{
    private String name;
    private int age;
    private Car car;

    @Override
    public Object clone() throws CloneNotSupportedException {
        //基本数据类型的克隆
        Person prototype = (Person)super.clone();
        //引用类型的克隆
        prototype.car = (Car) this.car.clone();		//这里必须把当前的引用类型进行拷贝
        return prototype;
    }

    public Person(String name, int age, Car pc) {
        this.name = name;
        this.age = age;
        this.car = pc;
    }

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

引用类型：Car类

• 对引用类型进行深拷贝，那它必须实现Cloneable接口，重写Clone方法

public class Car implements Cloneable{
    private String name;
    
    //重写Clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    public Car(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }

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

Cllient：Test类

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {

        Car car = new Car("奥迪");
        Person zhangsan = new Person("张三", 20, car);
        //开始深拷贝
        Person lisi = (Person)zhangsan.clone();
        System.out.println(zhangsan);
        System.out.println(lisi);
        System.out.println(zhangsan.getCar() == lisi.getCar());
    }
}

执行结果

Person{name='张三', age=20, car=Car{name='奥迪'}}
Person{name='张三', age=20, car=Car{name='奥迪'}}
false

3.2.2 序列化方式(Serializable)

原始文件：Person类

• 必须实现Serializable接口

public class Person implements Serializable {
    private String name;
    private int age;
    private Car car;

    public Object deepBySerializable() throws IOException {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;


        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            //当前这个对象以对象流的方式输出
            oos.writeObject(this);
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            Person copyObj = (Person) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            ois.close();
            bis.close();
            oos.close();
            bos.close();
        }
    }
    public Person(String name, int age, Car pc) {
        this.name = name;
        this.age = age;
        this.car = pc;
    }

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Prototype{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

引用类型：Car类

public class Car implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;

    public Car(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }

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

Cllient：Test类

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {

        Car car = new Car("奥迪");
        Person zhangsan = new Person("张三", 20, car);
        //开始深拷贝
        Person lisi = (Person)zhangsan.clone();
        System.out.println(zhangsan);
        System.out.println(lisi);
        System.out.println(zhangsan.getCar() == lisi.getCar());
    }
}

执行结果

Prototype{name='张三', age=25, car=Car{name='宝马'}}
Prototype{name='张三', age=25, car=Car{name='宝马'}}
false

四、总结

• 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率

• 不用重新初始化对象，而是动态地获得对象运行时的状态

• 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码

• 在实现深克隆的时候可能需要比较复杂的代码

缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则，这点请同学们注意.