原型模式解析-优快云博客

文章目录

原型模式

介绍

原型模式的几种实现方式

原型模式（浅拷贝）

原型模式（深拷贝）

介绍

描述

原型模式设计模式属于创建型模式，是用于创建重复的对象，对于当前指定对象创建对象种类，并且拷贝这些原型，创建出新的对象。

该模式一般适用于一个类直接创建对象所带来的代价比较高时，通过对已有缓存对象的克隆，在下一个次独立创建时返回他的克隆，以保证性能。

特点

性能有所提高，避免了通过new构造函数多次创建的过程。

实现原理

JAVA中Object类是所有类的根类，提供了一个clone()方法，可以将一个JAVA对象复制一份，但是需要实现clone的类，必须实现Cloneable接口，并且重写clone方法，此种方式为浅拷贝。
当被clone的类中还有其他类对象时，要想实现深拷贝需要实现Cloneable和Serializable。

适用

该类对象初始化需要消耗大量资源。
通过new操作等复杂操作产生该类对象的情况下。
该类对象可能被多个管理者独立拥有并且改动的情况下。

原型模式的几种实现方式

原型模式（浅拷贝）

概念：对于基本数据类型的成员变量，浅拷贝直接进行值传递，也就是将该属性复制一份给新的对象。对于引用类型的成员变量（数组、类对象）等则进行引用传递（地址内存）复制给新的对象。因此在一个对象中对于引用变量的修改将会导致同类对象成员变量值的修改。

public class Prototype implements Cloneable{

    private String cloneName;
    private String cloneDesc;

    public Prototype(String cloneName, String cloneDesc) {
        this.cloneName = cloneName;
        this.cloneDesc = cloneDesc;
    }

    // 1. 重写clone方法
    @Override
    protected Object clone(){
        Object clone = null;
        try {
            clone = super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
            return null;
        }
        return clone;
    }
    
    @Override
    public String toString() {
        return "Prototype{" +
                "cloneName='" + cloneName + '\'' +
                ", cloneDesc='" + cloneDesc + '\'' +
                '}';
    }
}

原型模式（深拷贝）

概念：复制对象的所有基本数据类型的成员变量，为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型的成员变量所引用的对象，复制到克隆对象中。

实现方式：

当被clone的类中还有其他类对象时，要想实现深拷贝需要实现Cloneable和Serializable。

重写clone方法实现深拷贝

// 等待克隆对象
public class DeepParent implements Serializable, Cloneable {
    private static final long serialVersionUID = 1L;
    private String id;
    private DeepChild child;

    public DeepParent(String id, DeepChild child) {
        this.id = id;
        this.child = child;
    }

    // 1. 实现拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object clone = null;
        // 完成对基本数据类型的拷贝和String的克隆
        clone = super.clone();
        // 对引用类型进行拷贝
        DeepParent parent = (DeepParent) clone;
        // 缺点 子类型中设计到引用类型 仍然需要重新修改代码
        parent.child = (DeepChild) child.clone();
        return parent;
    }
}
// 引用对象
public class DeepChild implements Serializable,Cloneable {
    private static final long serialVersionUID = 1L;

    private String id;

    public DeepChild(String id) {
        this.id = id;
    }

    // 1. 子类 实现克隆 （成员变量均为基本类型 使用默认clone）
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

通过对象序列化实现深拷贝

public class DeepParent implements Serializable, Cloneable {
    private static final long serialVersionUID = 1L;
    private String id;
    public DeepChild child;

    public DeepParent(String id, DeepChild child) {
        this.id = id;
        this.child = child;
    }

    // 1.实现深拷贝 通过 序列化方式（推荐）
    public Object deepClone() {
        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);
            DeepParent parent = (DeepParent) ois.readObject();
            return parent;
        }catch (IOException|ClassNotFoundException e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}