一起学设计模式 - 创建型设计模式之Prototype原型设计模式

骑猪看日落 2022-11-05 08:33 206阅读 0赞

### 文章目录 ###

*  一起学设计模式 - 创建型设计模式之Prototype原型设计模式
 *   *  1.原型设计模式是什么？
     *  2.原型设计模式组成部分
     *  3.原型模式的实现
     *   *  3.1 浅拷贝
         *  3.2 深拷贝
     *  4.原型设计模式的优缺点

# 一起学设计模式 - 创建型设计模式之Prototype原型设计模式 #

## 1.原型设计模式是什么？ ##

>  原型设计模式是一种对象创建型模式，使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，主要用于创建重复的对象，同时又能保证性能。  
>    
>  工作原理就是将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝自己来实现创建过程。  
>    
>  应该是最简单的设计模式了，实现一个接口，重写一个方法即完成了原型模式。

## 2.原型设计模式组成部分 ##

>  原型设计模式主要组成为三部分：
> 
> 1.  `Prototype`: 声明克隆方法的接口，是所有具体原型类的公共父类(Cloneable接口)。
> 2.  `ConcretePrototype` : 具体原型类。
> 3.  `Client`: 让一个原型对象克隆自身从而创建一个新的对象。  
>      
> 
>  而原型设计模式应用场景也比较多。例如创建新对象成本较大，新的对象可以通过原型模式对已有对象进行复制来获得；或者如果系统要保存对象的状态，做备份使用。

## 3.原型模式的实现 ##

>  与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。而拷贝方式主要有两种：浅拷贝和深拷贝。  
>    
>  浅拷贝通过实现`Cloneable`并重写clone()方法；深拷贝则是通过实现 `Serializable`读取二进制流。

### 3.1 浅拷贝 ###

>  通过浅拷贝方式，如果原型对象的成员变量是基本数据类型（int、double、byte、boolean、char等），将复制一份给克隆对象；  
>    
>  如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。  
>    
>  通过覆盖Object类的clone()方法可以实现浅克隆。

>  这里我们依然以电脑对象为例。

**内存对象**

/** * 内存 */
    public class Memory { 
    
        private String model;
    
        private int capacity;
    
        public Memory(String model, int capacity) { 
            this.model = model;
            this.capacity = capacity;
        }
    
        public String getModel() { 
            return model;
        }
    
        public void setModel(String model) { 
            this.model = model;
        }
    
        public int getCapacity() { 
            return capacity;
        }
    
        public void setCapacity(int capacity) { 
            this.capacity = capacity;
        }
    
        @Override
        public String toString() { 
            return "Memory{" +
                    "model='" + model + '\'' +
                    ", capacity=" + capacity +
                    '}';
        }
    }

**电脑对象**

public class Computer implements Cloneable { 
    
        private String title;
    
        private int year;
    
        private List<Memory> memoryList;
    
        public Computer(String title, int year, List<Memory> memoryList) { 
            this.title = title;
            this.year = year;
            this.memoryList = memoryList;
        }
    
        public String getTitle() { 
            return title;
        }
    
        public void setTitle(String title) { 
            this.title = title;
        }
    
        public int getYear() { 
            return year;
        }
    
        public void setYear(int year) { 
            this.year = year;
        }
    
        public List<Memory> getMemoryList() { 
            return memoryList;
        }
    
        public void setMemoryList(List<Memory> memoryList) { 
            this.memoryList = memoryList;
        }
    
        @Override
        public String toString() { 
            return "Computer{" +
                    "title='" + title + '\'' +
                    ", year=" + year +
                    ", memoryList=" + memoryList +
                    '}';
        }
    
        @Override
        protected Computer clone() throws CloneNotSupportedException { 
            return (Computer) super.clone();
        }
    }

>  所使用的的对象都定义好了，这里我们通过一个简单的例子来看看效果。

public class Demo { 
    
        public static void main(String[] args) throws CloneNotSupportedException { 
            Computer computer = buildData();
            System.out.println("原始数据: " + computer.toString());
    
            // 浅拷贝
            Computer cloneComputer = computer.clone();
            System.out.println("浅拷贝数据: " + computer.toString());
    
            computer.getMemoryList().get(0).setModel("微星");
            System.out.println("修改内存型号后的原始数据: " + computer.toString());
            System.out.println("修改内存型号后的浅拷贝数据: " + cloneComputer.toString());
    
        }
    
        public static Computer buildData(){ 
            ArrayList<Memory> memories = new ArrayList<>();
            memories.add(new Memory("金士顿", 4));
            memories.add(new Memory("三星", 8));
    
            return new Computer("微星550", 2021, memories);
        }
    
    }

>  这里通过运行结果我们就会发现，如果是引用类型的成员变量克隆之后确实只是把地址复制了一份。若我们修改其中一个，另一个也会被修改。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70]

### 3.2 深拷贝 ###

>  通过深拷贝方式，无论原型对象的成员变量是基本数据类型还是引用类型，都将复制一份给克隆对象，如果需要实现深克隆，可以通过序列化(Serializable)等方式来实现。  
>    
>  深拷贝方式首先一点就是，这里的`Computer`和`Memory`类都需要实现`Serializable`序列化接口。  
>    
>  然后我们通过下面这种方式就可以实现深拷贝，主要是借助了对象输入输出流。这里我们把方法放在了`Computer`类中，大家需要的话可以单独抽取封装一个工具类出来。

/** * 深拷贝 * @return */
        public Object deepClone(){ 
            try { 
                //输出 序列化
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
                objectOutputStream.writeObject(this);
    
                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
                Object copyObj = objectInputStream.readObject();
    
                return copyObj;
            } catch (IOException | ClassNotFoundException e) { 
                e.printStackTrace();
            }
            return null;
        }

>  简单修改一下调用就可以看到结果。

public class Demo { 
    
        public static void main(String[] args) throws CloneNotSupportedException { 
            Computer computer = buildData();
            System.out.println("原始数据: " + computer.toString());
            
            // 深拷贝
            Computer cloneComputer = (Computer) computer.deepClone();
            System.out.println("深拷贝数据: " + computer.toString());
    
            computer.getMemoryList().get(0).setModel("微星");
            System.out.println("修改内存型号后的原始数据: " + computer.toString());
            System.out.println("修改内存型号后的浅拷贝数据: " + cloneComputer.toString());
    
        }
    
        public static Computer buildData(){ 
            ArrayList<Memory> memories = new ArrayList<>();
            memories.add(new Memory("金士顿", 4));
            memories.add(new Memory("三星", 8));
    
            return new Computer("微星550", 2021, memories);
        }
    
    }

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

>  这里我们可以看到，通过深拷贝方式拷贝的对象，如果修改一个之后另一个是不会改变的。

## 4.原型设计模式的优缺点 ##

>  原型设计模式比较简单，不过我们同样可以总结一下优缺点。
> 
> 1.  `优点`：  
>      当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，可以提高新实例的创建效率；  
>        
>      可辅助实现撤销操作，使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便在需要的时候使用恢复到历史状态。
> 2.  `缺点`：  
>      在实现深克隆时需要编写较为复杂的代码，且当对象之间存在多重的嵌套引用时，需要对每一层对象对应的类都必须支持深克隆。
> 
>    
>  原型模式是内存二进制流的拷贝，比new对象性能高很多。而使用的时候主要还是需要考虑的是选择浅拷贝还是深拷贝。

--------------------

>  源码地址：[【设计模式博客源码】][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70]: /images/20221023/383c313a22c14154893707d418e8af47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 1]: /images/20221023/8cb726b9e7904a8ca67a11e759dd7821.png
[Link 1]: https://gitee.com/onethree/design-pattern