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

Love The Way You Lie 2023-10-11 19:33 30阅读 0赞

## 场景 ##

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

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

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

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

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

### 原型模式(Prototype Pattern) ###

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

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

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

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

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

3、构造函数比较复杂。

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

具体举例：

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

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

注：

博客：  
[霸道流氓气质的博客\_CSDN博客-C\#,架构之路,SpringBoot领域博主][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());
        }
    }

运行测试代码

![6103bdbfb345452e8978948cb1f64552.jpeg][]

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

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

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

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

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

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

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

差别很明显。

修改clone方法

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

### 深克隆 ###

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

深克隆是通过实现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;
            }
        }
    }

此时再运行测试代码

![33704d853294423abf2e0a05889dc654.jpeg][]

[-_Java_-CSDN]: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/127539695
[-_-_Java_-CSDN]: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/127555096
[CSDN_-C_SpringBoot]: https://blog.csdn.net/badao_liumang_qizhi
[6103bdbfb345452e8978948cb1f64552.jpeg]: https://img-blog.csdnimg.cn/6103bdbfb345452e8978948cb1f64552.jpeg
[33704d853294423abf2e0a05889dc654.jpeg]: https://img-blog.csdnimg.cn/33704d853294423abf2e0a05889dc654.jpeg