设计模式之原型模式(java深浅克隆)

悠悠 2023-05-21 15:13 15阅读 0赞

### 文章目录 ###

*   *   *   *  一、定义
             *  二、适用场景
             *  三、主要角色
             *  四、对象的深浅克隆
             *   *  1.错误的克隆
                 *  2.浅克隆
                 *  3.深克隆
                 *   *  方式一:通过将引用类型手动clone实现深克隆
                     *  方式二:通过序列化实现深克隆

#### 一、定义 ####

原型模式（Prototype pattern）属于创造性设计模式，是指原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。  
单例模式多次请求后得到的实例其实都只有一个，但是原型模式每次请求都会得到一个新的实例，只不过这个新的实例不是new出来的，而是原先的实例clone出来的。

#### 二、适用场景 ####

1.  创建的对象实例较为复杂，如构造函数中含有多个参数，通过new生成对象实例花费高。
2.  解耦框架与类，不通过具体类名，而是预先的"注册"一个"原型"实例，之后通过复制这个原型实例来生成新的实例。
3.  原型模式一般一般与工厂模式结合使用，通过clone(),提供实例

> ❓**Q:** 为什么clone会比new的效率高❓

package com.selenium.demo;
    public class AA implements Cloneable { 
        public AA() { 
            System.out.println("构造函数被调用");
        }
    
        public static void main(String[] args) throws CloneNotSupportedException { 
            AA aa = new AA();
            AA bb = (AA) aa.clone();
        }
    }

![在这里插入图片描述][20200417144818259.png]  
可以看出只有在new AA()的时候调用了一次构造方法，clone()的时候并没有调用构造方法.

> ❗️**A:** 因为clone是native方法,直接在内存中复制数据块，操作二进制流,不会调用构造方法，少了对象的初始化的一些操作。❗️

#### 三、主要角色 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70]

*  **Client(使用者):** 负责使用复制实例的方法来复制实例
 *  **Prototype(原型):** 原型是接口类型，用来定义复制实例的方法
 *  **ConcretePrototype(具体原型):** 复制实例的方法的具体实现类

#### 四、对象的深浅克隆 ####

##### 1.错误的克隆 #####

刚学java的同学，可能想通过=不就实现了克隆吗?我真是个小天才!!!

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person{ 
        private int id;
        private String name;
        private Dog dog;
    
        public static void main(String[] args) throws Exception { 
            Dog dog = new Dog(1, "dog");
            Person person = new Person(1, "person", dog);
            Person person1 = person;
            System.out.println("person==person1: " + (person == person1));
        }
    }

❌但是这样是错误的，=并没有重新开辟内存空间，而是将新的引用指向了同一块内存空间而已.

![在这里插入图片描述][20200417150635997.png]  
person和person1的内存地址相同，说明两个引用指向了同一块内存空间.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 1]

##### 2.浅克隆 #####

java.lang.Object中有native clone()方法，而我们实现克隆只需要实现Cloneable接口。

> Cloneable、Serializable这些接口都是空实现，作用都是起标识作用，标识这个对象可以被克隆、被序列化.

java默认的clone方法实现的是浅克隆，即:`只克隆了基本数据类型，而不克隆引用类型`

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person implements Cloneable { 
        private int id;
        private String name;
        private Dog dog;
    
        @Override
        protected Person clone() throws CloneNotSupportedException { 
            return ((Person) super.clone());
        }
        public static void main(String[] args) throws Exception { 
            Dog dog = new Dog(1, "dog");
            Person person = new Person(1, "person", dog);
            Person person2 = person.clone();
            //浅克隆:克隆对象内的基本数据类型，引用类型不被克隆
            System.out.println("person2==person: " + (person2 == person));
            System.out.println("person2.dog==person.dog:" + (person2.dog == person.dog));
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 2]  
可以看到，person的实例不同了，但是它们的dog实例还是同一个实例.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 3]

##### 3.深克隆 #####

了解了浅克隆，很容易就知道深克隆的概念，即:`既克隆了基本数据类型，也克隆了引用类型`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 4]

###### 方式一:通过将引用类型手动clone实现深克隆 ######

1.  将Dog也实现Cloneable接口

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Dog implements Cloneable{ 
        private int id;
        private String name;
    
        @Override
        protected Dog clone() throws CloneNotSupportedException { 
            return (Dog) super.clone();
        }
    }

1.  手动clone Dog

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person implements Cloneable, Serializable { 
        private int id;
        private String name;
        private Dog dog;
    
        @Override
        protected Person clone() throws CloneNotSupportedException { 
            return ((Person) super.clone());
        }
    
        public static void main(String[] args) throws Exception { 
            Dog dog = new Dog(1, "dog");
            Person person = new Person(1, "person", dog);
            //深克隆:1.将引用对象也克隆
            Person person3 = person.clone();
            //手动clone Dog
            person3.setDog(dog.clone());
            System.out.println("person3==person: " + (person3 == person));
            System.out.println("person3.dog==person.dog:" + (person3.dog == person.dog));
        }
    }

![在这里插入图片描述][20200417154250896.png]  
可以看到，person和dog都不是原来的实例了，都被clone了.

###### 方式二:通过序列化实现深克隆 ######

方式一实现深克隆的方式很直观，但是弊端也很明显:`如果含有多个引用类型，或者引用类型又有引用类型，就很麻烦`.  
所以通过Serializable实现序列化(Andriod推荐使用Parcelable)的方式实现深克隆才是最常用的方式.

1.  Dog实现Serializable接口

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Dog implements Serializable { 
        private int id;
        private String name;
    }

1.  Person实现Serializable接口

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person implements Serializable { 
        private int id;
        private String name;
        private Dog dog;
        public static void main(String[] args) throws Exception { 
            Dog dog = new Dog(1, "dog");
            Person person = new Person(1, "person", dog);
            //深克隆:2.通过序列化的方式
            //将序列化对象写入流
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(bos);
            objectOutputStream.writeObject(person);
            //将序列化对象从流中反序列化
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(bis);
            Person person4 = (Person) objectInputStream.readObject();
            System.out.println("person4==person: " + (person4 == person));
            System.out.println("person4.dog==person.dog:" + (person4.dog == person.dog));
        }
    }

![在这里插入图片描述][20200417160152984.png]  
可以看到，person和dog也都不是原来的实例了

[20200417144818259.png]: /images/20230521/45d18d09c6814878886538ac3880048b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70]: /images/20230521/743295371b434720b8667251cdde73c2.png
[20200417150635997.png]: /images/20230521/c2f0f42882184b9c8acb124754be0b07.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 1]: /images/20230521/421203591c144a5b83ae03fcfd669936.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 2]: /images/20230521/003d22961061408b8e76d8ad3ee90b4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 3]: /images/20230521/23f3108bf15844439e6a1d01615ec44d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDUzMjY2_size_16_color_FFFFFF_t_70 4]: /images/20230521/c0e86880a922487e9bf277640a4b0cda.png
[20200417154250896.png]: /images/20230521/efcefd777e684ad4961300df0b32d32a.png
[20200417160152984.png]: /images/20230521/e3c9315c05b74a15b86f9ec6bbbfcc57.png