• 小侃设计模式（四）-原型模式

    1.概述

    原型模式（Prototype Pattern）适用于创建重复的对象，同时又能保证性能，它提供了一种创建对象的最佳方式。JAVA中原型模式通过实现一个原型接口，该接口用于创建对象的克隆，当创建对象的代价比较大时，采用这种模式能够有效提升系统性能。它是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节，本文主要讲述JAVA中采用浅拷贝和深拷贝方式来实现原型模式。

    2.原型模式

    原型模式指的是：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。它通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

    案例：有一只羊名叫多利，现在需要通过克隆方式，生成3个和它一样的羊。在JAVA中的代码实现如下：

    public class Sheep implements Cloneable {

    private Integer age;

    private String color;

    private String 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 String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}


public class Main {
    public static void main(String[] args) {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
       
        System.out.println(JSON.toJSONString(sheep1));
        System.out.println(JSON.toJSONString(sheep2));
        System.out.println(JSON.toJSONString(sheep3));
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    运行结果如下：
    在这里插入图片描述

    2.1 浅拷贝

    在JAVA中，对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。对于数据类型是引用数据类型的成员变量（比如说成员变量是某个数组，某个类的对象等），那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。也就是说，浅拷贝的对象直接会互相干扰，一旦其中一个对象修改某个引用数据类型的成员变量，会改变这个对象拷贝出来的所有对象该成员变量。

    案例：上述克隆羊的案例中，如果每只小羊有一个成员属性friend，用来存储自己的朋友，用原型模式生成sheep1、sheep2、sheep3时，friend的哈希地址相同。代码如下：

    public class Sheep implements Cloneable {

    private Integer age;

    private String color;

    private String name;

    private Sheep friend;

    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 String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Sheep getFriend() {
        return friend;
    }

    public void setFriends(Sheep friend) {
        this.friend = friend;
    }

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

public class Main {
    public static void main(String[] args) {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep friend = new Sheep();
        friend.setName("小羊克隆");
        friend.setColor("red");
        friend.setAge(1);
        sheep.setFriend(friend);
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriends().hashCode());
        System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriends().hashCode());
        System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriends().hashCode());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    运行结果如下：
    在这里插入图片描述

    2.2 深拷贝

    深拷贝与浅拷贝不同，深拷贝不仅会复制对象的所有基本数据类型的成员变量值，还会为所有引用数据类型的变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
    深拷贝主要有以下两种方式：1.重写clone方法来实现深拷贝；2.通过对象序列化实现深拷贝。

    2.2.1 重写clone方法来实现深拷贝

    由于引用类型不能实现深拷贝，所以将引用类型拆分成基本类型，重写每个引用类型的clone()方法。这种方式的缺陷在于如果引用类型还嵌套引用类型，那么需要在每个引用类型中重写clone()方法，有多少个引用类型就要重写多少次，代价太大且违背开闭原则。

    public class Sheep implements Cloneable, Serializable {

    private Integer age;

    private String color;

    private String name;

    private Sheep friend;

    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 String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep friend) {
        this.friend = friend;
    }

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
        //对基本数据类型（属性）和String类型的克隆
            sheep = (Sheep) super.clone();
            //对引用类型的属性的单独克隆
            Sheep clone = (Sheep) friend.clone();
            sheep.friend = clone;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

public class Main {
    public static void main(String[] args) {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep friend = new Sheep();
        friend.setName("小羊克隆");
        friend.setColor("red");
        friend.setAge(1);
        sheep.setFriend(friend);
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriend().hashCode());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78

    运行结果如下：
    在这里插入图片描述

    2.2.2 通过对象序列化实现深拷贝

    通过序列化方式的实现原理是将原始对象利用序列化产生克隆对象，然后反序列化获取这个对象。由于序列化产生的是两个完全独立的对象，所以无论对象嵌套多少个引用类型，序列化都能够实现深拷贝。

    public class Sheep implements Cloneable, Serializable {

    private Integer age;

    private String color;

    private String name;

    private Sheep friend;

    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 String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep friend) {
        this.friend = friend;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        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);
            Sheep copyObj = (Sheep) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                ois.close();
                bos.close();
                oos.close();
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep friend = new Sheep();
        friend.setName("小羊克隆");
        friend.setColor("red");
        friend.setAge(1);
        sheep.setFriend(friend);
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriend().hashCode());
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96

    运行结果如下：
    在这里插入图片描述

    2.2.3 原型模式的优势和缺点

    1.优势
    （1）创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率；
    （2）利用原型模式创建对象不用重写初始化对象，而是动态地获得对象运行时地状态；
    （3）如果原始对象发生变化（增加或者减少属性），其它克隆对象的也会发生相应的变化，无需修改代码；
    2.缺点
    （1）在实现克隆的时候需要比较复杂的代码；
    （2）需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背OCP原则。

    3.小结

    1.原型模式是期望通过一种低损耗的方式来快速创建对象，JAVA中使用这种方式，需要实现Cloneable接口并重写clone()方法；
    2.浅拷贝适用于一个类只拥有基本类型，深拷贝适用于拥有基本类型和引用类型的类；
    3.原型模式主要适用于创建大对象或者批量创建大量相同对象的场景。

    4.参考文献

    1.《设计模式-可复用面向对象软件的基础》-Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides
    2.《可复用物联网Web3D框架的设计与实现》-程亮（知网）
    3.https://www.bilibili.com/video/BV1G4411c7N4-尚硅谷设计模式

  • 相关阅读:
    CANape导出标定数据Hex/S19等二进制文件
    古建筑测绘任重道远，三维实景建模是唯一突破口？
    TRC心血管研究之艾美捷TRC缺血研究领域
    Linux shell编程基础
    “UTONMOS”掀起元宇宙游戏热潮，全球发展前景广阔
    【C++中预处理语句 include、define、if】
    【Spring Cloud】安装 ElasticSearch、KIbana
    Redis系列12：Redis 的事务机制
    【C++】topk问题
    动态生成表格完整版（内含解析）
  • 原文地址：https://blog.csdn.net/qq_33479841/article/details/127602513