基本介绍

(1) 原型模式(prototype模式): 用原型实例指定创建对象的种类并且通过拷贝这些原型创建新的对象

(2) 原型模式是一种创建型设计模式允许一个对象再创建另一个可定制的对象而不需要知道如何创建的细节

(3) 工作原理: 通过将一个原型对象传给那个要发动创建的对象这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建即对象.clone()

传统方式克隆

(1) 优点是简单易操作比较好理解

(2) 在创建新的对象时总是需要重新获取原始对象的属性如果创建的对象比较复杂时效率较低

(3) 总是需要重新初始化对象而不是动态地获得对象运行时的状态不够灵活

(4)改进思路分析

java中Object类是所有类的基类 Object类提供了一个clone()方法该方法可以将一个java对象复制一份但是需要实现clone的java类必须要实现一个接口Cloneable 该接口表示该类能够复制且具有复制的能力-->原型模式

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Monkery {
    private String name;
    private Integer age;
    private String color;

}

测试结果:

原型模式改进

要克隆的实例实现Cloneable接口并实现默认的clone方法

@Data
@NoArgsConstructor
@AllArgsConstructor
public class MonkeyClone implements Cloneable{

    private String name;
    private Integer age;
    private String color;
    //克隆该实例 使用默认的clone方法实现
    @Override
    protected Object clone() {
        MonkeyClone monkeyClone = null;
        try {
            monkeyClone = (MonkeyClone)super.clone();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        return monkeyClone;
    }
}

测试结果:

浅拷贝和深拷贝

浅拷贝的介绍

(1) 对于数据类型是基本数据类型的成员变量浅拷贝会直接进行值传递也就是将该属性值复制一份给新的对象

(2) 对于数据类型是引用数据类型的成员变量比如说成员变量是某个数组某个类的对象等那么浅拷贝会进行引用传递也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象因为实际上两个对象的该成员变量都指向同一个实例在这种情况下在一个对象中修改该成员变量的话会影响其他对象的该成员变量值

(3) 前面的克隆monkey就是浅拷贝

(4) 浅拷贝是使用默认的clone()方法来实现 monkey=(MonkeyClone) super.clone();

为MonkeyClone 添加一个MonkeryClone类型的child属性此时这个数据类型即为引用类型

@Data
@NoArgsConstructor
@AllArgsConstructor
public class MonkeyClone implements Cloneable{

    private String name;
    private Integer age;
    private String color;
    private MonkeyClone child;

    public MonkeyClone(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    //克隆该实例 使用默认的clone方法实现
    @Override
    protected Object clone() {
        MonkeyClone monkeyClone = null;
        try {
            monkeyClone = (MonkeyClone)super.clone();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        return monkeyClone;
    }
}

我们接下来看引用数据类型的clone特性:

测试

我们这里可以看到,后面复制的monke它们的hashCode都是一致的,说明它们的内存地址指向的都是同一个地址

深拷贝的介绍

(1) 复制对象的所有基本数据类型的成员变量值

(2) 为所有引用数据类型的成员变量申请储存空间并复制每个引用数据类型成员变量所引用的对象直到该对象可达的所有对象也就是说对象进行深拷贝要对整个对象进行拷贝

(3) 深拷贝的实现方式1: 重写clone方法来实现深拷贝

(4) 深拷贝的实现方式2: 通过对象序列化来实现深拷贝

public class DeepCloneTarget implements Serializable,Cloneable {
    private String cloneName;
    private String cloneClass;

    public DeepCloneTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

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

@Data
@Accessors(chain = true)
public class DeepProtoType implements Serializable,Cloneable {
     String name; //String 属性
     DeepCloneTarget deepCloneTarget; //引用类型

    public DeepProtoType() {
        super();
    }

    //深拷贝 方式1 使用clone方法


    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //这里完成对基本数据类型(属性)和String的克隆
        deep = super.clone();
        //对引用类型的属性 进行单独处理
        DeepProtoType deepProtoType =(DeepProtoType) deep;
        deepProtoType.deepCloneTarget = (DeepCloneTarget) deepCloneTarget.clone();
        return deepProtoType;
    }
}

方式二:

@Data
@Accessors(chain = true)
public class DeepProtoType implements Serializable,Cloneable {
     String name; //String 属性
     DeepCloneTarget deepCloneTarget; //引用类型

    public DeepProtoType() {
        super();
    }

    //深拷贝 方式1 使用clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //这里完成对基本数据类型(属性)和String的克隆
        deep = super.clone();
        //对引用类型的属性 进行单独处理
        DeepProtoType deepProtoType =(DeepProtoType) deep;
        deepProtoType.deepCloneTarget = (DeepCloneTarget) deepCloneTarget.clone();
        return deepProtoType;
    }

    //深拷贝 方式2 通过对象序列化实现(推荐)
    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);
            DeepProtoType copyObj = (DeepProtoType) ois.readObject();
            return copyObj;

        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            //关闭流
            try {
                bos.close();
                oos.close();
                ois.close();
                bis.close();
            }catch (Exception ee){
                System.out.println(ee.getMessage());
            }
        }
    }
}

测试