设计模式-原型模式-浅克隆和深克隆在Java中的使用示例

场景

设计模式-简单工厂模式、工厂模式、抽象工厂模式在Java中的使用示例：

设计模式-简单工厂模式、工厂模式、抽象工厂模式在Java中的使用示例_霸道流氓气质的博客-CSDN博客

设计模式-单例模式-饿汉式单例模式、懒汉式单例模式、静态内部类在Java中的使用示例：

设计模式-单例模式-饿汉式单例模式、懒汉式单例模式、静态内部类在Java中的使用示例_霸道流氓气质的博客-CSDN博客

上面讲了工厂模式和单例模式在Java中的示例，下面将原型模式的示例。

原型模式(Prototype Pattern)

原型模式是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式可分为浅克隆和深克隆。

原型模式主要适用于以下场景:

1、类初始化消耗资源较多。

2、使用new生成一个对象需要非常繁琐的过程(数据准备、访问权限等)。

3、构造函数比较复杂。

4、在循环体重产生大量对象。

具体举例：

一个对象需要在一个高代价的数据库操作之后被创建，我们可以缓存该对象，在下一个请求时返回它的克隆，在需要

的时候更新数据库，以此来减少数据库调用。

注：

博客：
霸道流氓气质的博客_CSDN博客-C#,架构之路,SpringBoot领域博主
关注公众号
霸道的程序猿
获取编程相关电子书、教程推送与免费下载。

实现

浅克隆-复制过程自己实现

先创建原型Prototype

package com.ruoyi.demo.designPattern.prototypePattern;
 
/**
 * 原型Prototype接口
 */
public interface Prototype {
    Prototype clone();
}

创建具体需要克隆的类ConcretePrototypeA 

package com.ruoyi.demo.designPattern.prototypePattern;
 
import java.io.*;
import java.util.List;
 
/**
 * 需要克隆的类
 */
public class ConcretePrototypeA implements Prototype{
 
    private int age;
    private String name;
    private List hobbies;
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public List getHobbies() {
        return hobbies;
    }
 
    public void setHobbies(List hobbies) {
        this.hobbies = hobbies;
    }
 
    @Override
    public ConcretePrototypeA clone() {
        //浅克隆-复制过程自己实现
        ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
        concretePrototype.setAge(this.age);
        concretePrototype.setName(this.name);
        concretePrototype.setHobbies(this.hobbies);
        return concretePrototype;
    }
}

创建Client类

package com.ruoyi.demo.designPattern.prototypePattern;
 
public class Client {
    private Prototype prototype;
    public Client(Prototype prototype){
        this.prototype = prototype;
    }
    public Prototype startClone(Prototype concretePrototype){
        return concretePrototype.clone();
    }
}

测试代码如下

package com.ruoyi.demo.designPattern.prototypePattern;
 
import java.util.ArrayList;
 
public class ProtoTypeTest {
    public static void main(String[] args) {
        //创建一个具体的需要克隆的对象
        ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
        //填充属性，方便测试
        concretePrototype.setAge(20);
        concretePrototype.setName("霸道的程序猿");
        concretePrototype.setHobbies(new ArrayList());
        System.out.println(concretePrototype);
 
        //创建client对象，准备开始克隆
        Client client = new Client(concretePrototype);
        ConcretePrototypeA concretePrototypeClone = (ConcretePrototypeA) client.startClone(concretePrototype);
 
        System.out.println(concretePrototypeClone);
        System.out.println(concretePrototype.getHobbies() == concretePrototypeClone.getHobbies());
    }
}

运行测试代码

从测试结果看，hobbies的引用地址是相同的，意味着复制的不是值，而是引用的地址。

这样的话，如果我们修改任意一个对象的属性值，则concretePrototype和concretePrototypeClone的hobbies

值都会改变，这就是浅克隆。

浅克隆-调用jdk现成api-clone方法

只需要实现Cloneable接口，重写clone方法，此处clone方法可以改成任意名称，因为Cloneable接口是个空接口，

可以任意定位实现类的方法，此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法。

在Object类中clone()是native的，是底层C实现的，它直接操作内存中的二进制流，特别是复制大对象时，性能的

差别很明显。

修改clone方法

package com.ruoyi.demo.designPattern.prototypePattern;
 
import java.io.*;
import java.util.List;
 
/**
 * 需要克隆的类
 */
public class ConcretePrototypeA implements Prototype,Cloneable{
 
    private int age;
    private String name;
    private List hobbies;
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public List getHobbies() {
        return hobbies;
    }
 
    public void setHobbies(List hobbies) {
        this.hobbies = hobbies;
    }
 
    @Override
    public ConcretePrototypeA clone() {
 
        //浅克隆-调用jdk现成的api，只需要实现Cloneable接口接口
        try{
            return (ConcretePrototypeA) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

此时也是浅克隆。下面介绍深克隆。

深克隆

将一个对象复制之后，不论是基本数据类型还有引用类型，都是重新创建的。

深克隆是通过实现Serializable读取二进制流。

package com.ruoyi.demo.designPattern.prototypePattern;
 
import java.io.*;
import java.util.List;
 
/**
 * 需要克隆的类
 */
public class ConcretePrototypeA implements Prototype,Cloneable,Serializable{
 
    private int age;
    private String name;
    private List hobbies;
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public List getHobbies() {
        return hobbies;
    }
 
    public void setHobbies(List hobbies) {
        this.hobbies = hobbies;
    }
 
    @Override
    public ConcretePrototypeA clone() {
        //深克隆-方法得实现可序列化，Serializable
        try {
            //序列化
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            //将当前对象以对象流的方式输出
            oos.writeObject(this);
            //反序列化
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
 
            ConcretePrototypeA copy = (ConcretePrototypeA) ois.readObject();
            return  copy;
 
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

此时再运行测试代码