Java设计模式 03-原型模式

ゞ浴缸里的玫瑰 2023-09-27 16:09 5阅读 0赞

## 原型模式 ##

### 一、克隆羊问题 ###

*现在有一只羊 tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和 tom 羊 属性完全相同的 10只羊。*

### 二、传统方式解决克隆羊问题 ###

*  **图解**  
    ![在这里插入图片描述][cb65921bbf0f4cf7b1a9c2842d6ec17c.png]
 *  **代码演示**

*羊实体类*

//羊实体类
    public class Sheep {
        
        private String name;
        private Integer age;
        private String color;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Integer getAge() {
        
            return age;
        }
    
        public void setAge(Integer age) {
        
            this.age = age;
        }
    
        public String getColor() {
        
            return color;
        }
    
        public void setColor(String color) {
        
            this.color = color;
        }
    
        public Sheep() {
        
        }
    
        public Sheep(String name, Integer age, String color) {
        
            this.name = name;
            this.age = age;
            this.color = color;
        }
    }

*主函数*

//主函数
    public class Client {
        
        public static void main(String[] args) {
        
            Sheep sheep1 = new Sheep("tom",1,"白色");
            Sheep sheep2 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep3 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep4 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep5 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep6 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep7 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep8 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep9 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
            Sheep sheep10 = new Sheep(sheep1.getName(),sheep1.getAge(),sheep1.getColor());
    
            System.out.println(sheep1);
            System.out.println(sheep2);
            System.out.println(sheep3);
            System.out.println(sheep4);
            System.out.println(sheep5);
            System.out.println(sheep6);
            System.out.println(sheep7);
            System.out.println(sheep8);
            System.out.println(sheep9);
            System.out.println(sheep10);
        }
    }

### 三、传统的方式的优缺点 ###

*  1、优点是比较`好理解`，简单`易操作`。
 *  2、在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，`效率较低`
 *  3、总是需要重新初始化对象，而不是动态地获得对象运行时的状态, `不够灵活`

**改进的思路分析**: 思路

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

### 四、原型模式-基本介绍 ###

#### 1、基本介绍 ####

原型模式(Prototype 模式)是指：

*用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象*

> ①原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
> 
> ②工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象\*\*.clone\*\*()

*形象的理解：孙大圣拔出猴毛， 变出其它孙大圣*

#### 2、uml 类图 ####

![在这里插入图片描述][c487eed30ac0489b9588ed987e48ea72.png]  
**原理结构图说明**：

*  1)**Prototype** :

`原型类`，声明一个克隆自己的接口

*  2)**ConcretePrototype**:

`具体的原型类`, 实现一个克隆自己的操作

*  3)**Client:**

让一个原型对象克隆自己，从而创建一个新的对象(属性一样）

### 五、原型模式解决克隆羊问题的应用实例 ###

使用原型模式改进传统方式，让程序具有更高的效率和扩展性。

*  **代码实现**

*sheep实体类*

![在这里插入图片描述][6eb5fef711964bbbac26a362532038d8.png]  
*主函数*

public class Client {
        
        public static void main(String[] args) {
        
            Sheep sheep = new Sheep("tom",18,"白色");
            Sheep sheep1 = (Sheep) sheep.clone();
            Sheep sheep2 = (Sheep) sheep.clone();
            Sheep sheep3 = (Sheep) sheep.clone();
            Sheep sheep4 = (Sheep) sheep.clone();
            Sheep sheep5 = (Sheep) sheep.clone();
            Sheep sheep6 = (Sheep) sheep.clone();
            Sheep sheep7 = (Sheep) sheep.clone();
            Sheep sheep8 = (Sheep) sheep.clone();
            Sheep sheep9 = (Sheep) sheep.clone();
            Sheep sheep10 = (Sheep) sheep.clone();
    
            System.out.println(sheep);
            System.out.println(sheep1);
            System.out.println(sheep2);
            System.out.println(sheep3);
            System.out.println(sheep4);
            System.out.println(sheep5);
            System.out.println(sheep6);
            System.out.println(sheep7);
            System.out.println(sheep8);
            System.out.println(sheep9);
            System.out.println(sheep10);
        }
    }

![在这里插入图片描述][b24b56fcf2b24a1ca473b6df8c50d78a.png]

### 六、深入讨论-浅拷贝和深拷贝 ###

#### 1、浅拷贝的介绍 ####

*实体类的属性的类型是引用类型，那么浅拷贝就只是将克隆对象的引用类型变量指向原来的*

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

2)对于数据类型是`引用数据类型`的`成员变量`，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行`引用传递`，也就是只是将该`成员变量的引用值（内存地址）复制一份给新的对象`。

*因为实际上两个对象的该成员变量都指向同一个实例*。

在这种情况下，**在一个对象中修改该成员变量会影响到另一个对象的该成员变量值**  
![在这里插入图片描述][706249cd3cbb41a584a9c0b153b36772.png]  
3)浅拷贝是使用默认的 clone()方法来实现，通过`super.clone()`

sheep = (Sheep) super.clone();

![在这里插入图片描述][29b37fc00b7c46c08cbf4995e974e860.png]

#### 2、深拷贝基本介绍 ####

1.  `复制对象的所有基本数据类型的成员变量值`
2.  `为所有引用数据类型的成员变量申请存储空间`，并`复制`每个`引用数据类型成员变量所引用的对象`，`直到该对象可达的所有对象`。也就是说，对象进行深拷贝要对整个对象\*\*(**包括对象的引用类型**)\*\*进行拷贝  
    ![在这里插入图片描述][c7b503e626e145bfaf266d6c9741443e.png]

public class DeepCloneableTarget implements Serializable, Cloneable {
        
        private static final long serialVersionUID = 1L;
        private String cloneName;
        private String cloneClass;
        
        //构造器
        public DeepCloneableTarget(String cloneName, String cloneClass) {
         
            this.cloneName = cloneName;
            this.cloneClass = cloneClass;
        }
        
        //因为该类的属性，都是 String ,  因此我们这里使用默认的 clone 完成即可
        @Override
        protected Object clone() throws CloneNotSupportedException {
         
            return super.clone();
        }
    }

*  **深拷贝实现方式 1**：*`重写 clone() 方法`来实现深拷贝*

多重浅拷贝=>深拷贝=>套娃

*该类的属性都是基本类型，所以使用super.clone()默认的克隆方法*

//深拷贝（方式1）----使用 clone 方法
    public class DeepProtoType implements Serializable, Cloneable{
        
        public String name; //String 属 性
        public DeepCloneableTarget deepCloneableTarget;// 引用类型
        public DeepProtoType() {
         
            super();
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {
        
            Object deep = null;
            //这里完成对基本数据类型(属性)和 String 的克隆
            deep = super.clone();
            //对引用类型的属性，进行单独处理
            DeepProtoType deepProtoType = (DeepProtoType)deep;
            //再调用引用类型里面的clone()，对引用类型进行套娃clone()克隆
            deepProtoType.deepCloneableTarget	= (DeepCloneableTarget)deepCloneableTarget.clone();
            return deepProtoType;
        }

*  **深拷贝实现方式 2**： *通过`对象序列化`实现深拷贝(推荐)*

*在类中，写出这个方法来通过正反序列化，实现克隆深拷贝操作*

//深拷贝(方式 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();
                bis.close();
                ois.close();
            } catch (Exception e2) {
        
                System.out.println(e2.getMessage());
            }
        }
    }

### 七、深拷贝应用实例 ###

*  1、使用 重写 clone 方法实现深拷贝
 *  2、使用序列化来实现深拷贝
 *  3、代码演示

### 八、原型模式的注意事项和细节 ###

> 1、创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
> 
> 2、不用重新初始化对象，而是动态地获得对象运行时的状态
> 
> 3、如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
> 
> 4、在实现深克隆的时候可能需要比较复杂的代码

**缺点**：

*需要为`每一个类配备一个克隆方法`，这对全新的类来说不是很难，*

*但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则.*

[cb65921bbf0f4cf7b1a9c2842d6ec17c.png]: https://img-blog.csdnimg.cn/cb65921bbf0f4cf7b1a9c2842d6ec17c.png
[c487eed30ac0489b9588ed987e48ea72.png]: https://img-blog.csdnimg.cn/c487eed30ac0489b9588ed987e48ea72.png
[6eb5fef711964bbbac26a362532038d8.png]: https://img-blog.csdnimg.cn/6eb5fef711964bbbac26a362532038d8.png
[b24b56fcf2b24a1ca473b6df8c50d78a.png]: https://img-blog.csdnimg.cn/b24b56fcf2b24a1ca473b6df8c50d78a.png
[706249cd3cbb41a584a9c0b153b36772.png]: https://img-blog.csdnimg.cn/706249cd3cbb41a584a9c0b153b36772.png
[29b37fc00b7c46c08cbf4995e974e860.png]: https://img-blog.csdnimg.cn/29b37fc00b7c46c08cbf4995e974e860.png
[c7b503e626e145bfaf266d6c9741443e.png]: https://img-blog.csdnimg.cn/c7b503e626e145bfaf266d6c9741443e.png