• 创建型设计模式 原型模式 建造者模式 创建者模式对比

    创建型设计模式 单例 工厂模式 看这一篇就够了_软工菜鸡的博客-CSDN博客

    4.3 原型模式

    4.3.1 概述

    用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。

    4.3.2 结构

    原型模式包含如下角色：

    • 抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
    • 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
    • 访问类：使用具体原型类中的 clone() 方法来复制新的对象。

    接口类图如下：

    4.3.3 实现

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

    浅克隆：创建一个新对象， 新对象的属性和原来对象完全相同，对于非基本类型属性， 仍指向原有属性 所指向的对象 的 内存 地址。
    深克隆：创建一个新对象， 属性中引用的其他对象也会被克隆，不再指向原有对象地址。

    Java中的Object类中提供了 clone() 方法来实现浅克隆。 Cloneable 接口是上面的类图中的抽象原型类，而实现了Cloneable接口的子实现类就是具体的原型类。代码如下：

    Realizetype（具体的原型类）：

    1. public class Realizetype implements Cloneable {
    2.  
    3.     public Realizetype() {
    4.         System.out.println("具体的原型对象创建完成！");
    5.     }
    6.  
    7.     @Override
    8.     protected Realizetype clone() throws CloneNotSupportedException {
    9.         System.out.println("具体原型复制成功！");
    10.         return (Realizetype) super.clone();
    11.     }
    12. }

    PrototypeTest（测试访问类）：

    1. public class PrototypeTest {
    2.     public static void main(String[] args) throws CloneNotSupportedException {
    3.         Realizetype r1 = new Realizetype();
    4.         Realizetype r2 = r1.clone();
    5.  
    6.         System.out.println("对象r1和r2是同一个对象？" + (r1 == r2));
    7.     }
    8. }

    4.3.4 案例

    用原型模式生成“三好学生”奖状

    同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个“三好学生”奖状出来，然后在修改奖状上的名字即可。

    类图如下：

    代码如下：

    1. //奖状类
    2. public class Citation implements Cloneable {
    3.     private String name;
    4.  
    5.     public void setName(String name) {
    6.         this.name = name;
    7.     }
    8.  
    9.     public String getName() {
    10.         return (this.name);
    11.     }
    12.  
    13.     public void show() {
    14.         System.out.println(name + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
    15.     }
    16.  
    17.     @Override
    18.     public Citation clone() throws CloneNotSupportedException {
    19.         return (Citation) super.clone();
    20.     }
    21. }
    22.  
    23. //测试访问类
    24. public class CitationTest {
    25.     public static void main(String[] args) throws CloneNotSupportedException {
    26.         Citation c1 = new Citation();
    27.         c1.setName("张三");
    28.  
    29.         //复制奖状
    30.         Citation c2 = c1.clone();
    31.         //将奖状的名字修改李四
    32.         c2.setName("李四");
    33.  
    34.         c1.show();
    35.         c2.show();
    36.     }
    37. }

    4.3.5 使用场景

    • 对象的创建非常复杂，可以使用原型模式快捷的创建对象。
    • 性能和安全要求比较高。

    4.3.6 扩展（深克隆）

    将上面的“三好学生”奖状的案例中Citation类的name属性修改为Student类型的属性。代码如下：

    1. //奖状类
    2. public class Citation implements Cloneable {
    3.     private Student stu;
    4.  
    5.     public Student getStu() {
    6.         return stu;
    7.     }
    8.  
    9.     public void setStu(Student stu) {
    10.         this.stu = stu;
    11.     }
    12.  
    13.     void show() {
    14.         System.out.println(stu.getName() + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
    15.     }
    16.  
    17.     @Override
    18.     public Citation clone() throws CloneNotSupportedException {
    19.         return (Citation) super.clone();
    20.     }
    21. }
    22.  
    23. //学生类
    24. public class Student {
    25.     private String name;
    26.     private String address;
    27.  
    28.     public Student(String name, String address) {
    29.         this.name = name;
    30.         this.address = address;
    31.     }
    32.  
    33.     public Student() {
    34.     }
    35.  
    36.     public String getName() {
    37.         return name;
    38.     }
    39.  
    40.     public void setName(String name) {
    41.         this.name = name;
    42.     }
    43.  
    44.     public String getAddress() {
    45.         return address;
    46.     }
    47.  
    48.     public void setAddress(String address) {
    49.         this.address = address;
    50.     }
    51. }
    52.  
    53. //测试类
    54. public class CitationTest {
    55.     public static void main(String[] args) throws CloneNotSupportedException {
    56.  
    57.         Citation c1 = new Citation();
    58.         Student stu = new Student("张三", "西安");
    59.         c1.setStu(stu);
    60.  
    61.         //复制奖状
    62.         Citation c2 = c1.clone();
    63.         //获取c2奖状所属学生对象
    64.         Student stu1 = c2.getStu();
    65.         stu1.setName("李四");
    66.  
    67.         //判断stu对象和stu1对象是否是同一个对象
    68.         System.out.println("stu和stu1是同一个对象？" + (stu == stu1));
    69.  
    70.         c1.show();
    71.         c2.show();
    72.     }
    73. }

    运行结果为：

    说明：

    stu对象和stu1对象是同一个对象，就会产生将stu1对象中name属性值改为“李四”，两个Citation（奖状）对象中显示的都是李四。这就是浅克隆的效果，对具体原型类（Citation）中的引用类型的属性进行引用的复制。这种情况需要使用深克隆，而进行深克隆需要使用对象流。代码如下：

    1. public class CitationTest1 {
    2.     public static void main(String[] args) throws Exception {
    3.         Citation c1 = new Citation();
    4.         Student stu = new Student("张三", "西安");
    5.         c1.setStu(stu);
    6.  
    7.         //创建对象输出流对象
    8.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\b.txt"));
    9.         //将c1对象写出到文件中
    10.         oos.writeObject(c1);
    11.         oos.close();
    12.  
    13.         //创建对象出入流对象
    14.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\b.txt"));
    15.         //读取对象
    16.         Citation c2 = (Citation) ois.readObject();
    17.         //获取c2奖状所属学生对象
    18.         Student stu1 = c2.getStu();
    19.         stu1.setName("李四");
    20.  
    21.         //判断stu对象和stu1对象是否是同一个对象
    22.         System.out.println("stu和stu1是同一个对象？" + (stu == stu1));
    23.  
    24.         c1.show();
    25.         c2.show();
    26.     }
    27. }

    运行结果为：

    注意：Citation类和Student类必须实现Serializable接口，否则会抛NotSerializableException异常。

    4.4 建造者模式（无）

    4.4.1 概述

    将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

    • 分离了部件的构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。
    • 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
    • 建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

    4.4.2 结构

    建造者（Builder）模式包含如下角色：

    • 抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
    • 具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
    • 产品类（Product）：要创建的复杂对象。
    • 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

    类图如下：

    4.4.3 实例

    创建共享单车

    生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。

    这里Bike是产品，包含车架，车座等组件；Builder是抽象建造者，MobikeBuilder和OfoBuilder是具体的建造者；Director是指挥者。类图如下：

    具体的代码如下：

    1. //自行车类
    2. public class Bike {
    3.     private String frame;
    4.     private String seat;
    5.  
    6.     public String getFrame() {
    7.         return frame;
    8.     }
    9.  
    10.     public void setFrame(String frame) {
    11.         this.frame = frame;
    12.     }
    13.  
    14.     public String getSeat() {
    15.         return seat;
    16.     }
    17.  
    18.     public void setSeat(String seat) {
    19.         this.seat = seat;
    20.     }
    21. }
    22.  
    23. // 抽象 builder 类
    24. public abstract class Builder {
    25.  
    26.     protected Bike mBike = new Bike();
    27.  
    28.     public abstract void buildFrame();
    29.     public abstract void buildSeat();
    30.     public abstract Bike createBike();
    31. }
    32.  
    33. //摩拜单车Builder类
    34. public class MobikeBuilder extends Builder {
    35.  
    36.     @Override
    37.     public void buildFrame() {
    38.         mBike.setFrame("铝合金车架");
    39.     }
    40.  
    41.     @Override
    42.     public void buildSeat() {
    43.         mBike.setSeat("真皮车座");
    44.     }
    45.  
    46.     @Override
    47.     public Bike createBike() {
    48.         return mBike;
    49.     }
    50. }
    51.  
    52. //ofo单车Builder类
    53. public class OfoBuilder extends Builder {
    54.  
    55.     @Override
    56.     public void buildFrame() {
    57.         mBike.setFrame("碳纤维车架");
    58.     }
    59.  
    60.     @Override
    61.     public void buildSeat() {
    62.         mBike.setSeat("橡胶车座");
    63.     }
    64.  
    65.     @Override
    66.     public Bike createBike() {
    67.         return mBike;
    68.     }
    69. }
    70.  
    71. //指挥者类
    72. public class Director {
    73.     private Builder mBuilder;
    74.  
    75.     public Director(Builder builder) {
    76.         mBuilder = builder;
    77.     }
    78.  
    79.     public Bike construct() {
    80.         mBuilder.buildFrame();
    81.         mBuilder.buildSeat();
    82.         return mBuilder.createBike();
    83.     }
    84. }
    85.  
    86. //测试类
    87. public class Client {
    88.     public static void main(String[] args) {
    89.         showBike(new OfoBuilder());
    90.         showBike(new MobikeBuilder());
    91.     }
    92.     private static void showBike(Builder builder) {
    93.         Director director = new Director(builder);
    94.         Bike bike = director.construct();
    95.         System.out.println(bike.getFrame());
    96.         System.out.println(bike.getSeat());
    97.     }
    98. }

    注意：

    上面示例是 Builder模式的常规用法，指挥者类 Director 在建造者模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把指挥者类和抽象建造者进行结合

    1. // 抽象 builder 类
    2. public abstract class Builder {
    3.  
    4.     protected Bike mBike = new Bike();
    5.  
    6.     public abstract void buildFrame();
    7.     public abstract void buildSeat();
    8.     public abstract Bike createBike();
    9.     
    10.     public Bike construct() {
    11.         this.buildFrame();
    12.         this.BuildSeat();
    13.         return this.createBike();
    14.     }
    15. }

    说明：

    这样做确实简化了系统结构，但同时也加重了抽象建造者类的职责，也不是太符合单一职责原则，如果construct() 过于复杂，建议还是封装到 Director 中。

    4.4.4 优缺点

    优点：

    • 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
    • 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
    • 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
    • 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。

    缺点：

    造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

    4.4.5 使用场景

    建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

    • 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
    • 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

    4.4.6 模式扩展

    建造者模式除了上面的用途外，在开发中还有一个常用的使用方式，就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时就可以利用建造者模式进行重构。

    重构前代码如下：

    1. public class Phone {
    2.     private String cpu;
    3.     private String screen;
    4.     private String memory;
    5.     private String mainboard;
    6.  
    7.     public Phone(String cpu, String screen, String memory, String mainboard) {
    8.         this.cpu = cpu;
    9.         this.screen = screen;
    10.         this.memory = memory;
    11.         this.mainboard = mainboard;
    12.     }
    13.  
    14.     public String getCpu() {
    15.         return cpu;
    16.     }
    17.  
    18.     public void setCpu(String cpu) {
    19.         this.cpu = cpu;
    20.     }
    21.  
    22.     public String getScreen() {
    23.         return screen;
    24.     }
    25.  
    26.     public void setScreen(String screen) {
    27.         this.screen = screen;
    28.     }
    29.  
    30.     public String getMemory() {
    31.         return memory;
    32.     }
    33.  
    34.     public void setMemory(String memory) {
    35.         this.memory = memory;
    36.     }
    37.  
    38.     public String getMainboard() {
    39.         return mainboard;
    40.     }
    41.  
    42.     public void setMainboard(String mainboard) {
    43.         this.mainboard = mainboard;
    44.     }
    45.  
    46.     @Override
    47.     public String toString() {
    48.         return "Phone{" +
    49.                 "cpu='" + cpu + '\'' +
    50.                 ", screen='" + screen + '\'' +
    51.                 ", memory='" + memory + '\'' +
    52.                 ", mainboard='" + mainboard + '\'' +
    53.                 '}';
    54.     }
    55. }
    56.  
    57. public class Client {
    58.     public static void main(String[] args) {
    59.         //构建Phone对象
    60.         Phone phone = new Phone("intel","三星屏幕","金士顿","华硕");
    61.         System.out.println(phone);
    62.     }
    63. }

    上面在客户端代码中构建Phone对象，传递了四个参数，如果参数更多呢？代码的可读性及使用的成本就是比较高。

    重构后代码：

    1. public class Phone {
    2.  
    3.     private String cpu;
    4.     private String screen;
    5.     private String memory;
    6.     private String mainboard;
    7.  
    8.     private Phone(Builder builder) {
    9.         cpu = builder.cpu;
    10.         screen = builder.screen;
    11.         memory = builder.memory;
    12.         mainboard = builder.mainboard;
    13.     }
    14.  
    15.     public static final class Builder {
    16.         private String cpu;
    17.         private String screen;
    18.         private String memory;
    19.         private String mainboard;
    20.  
    21.         public Builder() {}
    22.  
    23.         public Builder cpu(String val) {
    24.             cpu = val;
    25.             return this;
    26.         }
    27.         public Builder screen(String val) {
    28.             screen = val;
    29.             return this;
    30.         }
    31.         public Builder memory(String val) {
    32.             memory = val;
    33.             return this;
    34.         }
    35.         public Builder mainboard(String val) {
    36.             mainboard = val;
    37.             return this;
    38.         }
    39.         public Phone build() {
    40.             return new Phone(this);}
    41.     }
    42.     @Override
    43.     public String toString() {
    44.         return "Phone{" +
    45.                 "cpu='" + cpu + '\'' +
    46.                 ", screen='" + screen + '\'' +
    47.                 ", memory='" + memory + '\'' +
    48.                 ", mainboard='" + mainboard + '\'' +
    49.                 '}';
    50.     }
    51. }
    52.  
    53. public class Client {
    54.     public static void main(String[] args) {
    55.         Phone phone = new Phone.Builder()
    56.                 .cpu("intel")
    57.                 .mainboard("华硕")
    58.                 .memory("金士顿")
    59.                 .screen("三星")
    60.                 .build();
    61.         System.out.println(phone);
    62.     }
    63. }

    重构后的代码在使用起来更方便，某种程度上也可以提高开发效率。从软件设计上，对程序员的要求比较高。

    4.6 创建者模式对比

    4.6.1 工厂方法模式VS建造者模式

    工厂方法模式注重的是整体对象的创建方式；而建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。

    我们举个简单例子来说明两者的差异，如要制造一个超人，如果使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人；而如果使用建造者模式，则需要组装手、头、脚、躯干等部分，然后再把内裤外穿，于是一个超人就诞生了。

    4.6.2 抽象工厂模式VS建造者模式

    抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可。

    建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

    如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车。

    非常感谢您阅读到这里，创作不易！如果这篇文章对您有帮助，希望能留下您的点赞👍 关注💖 收藏 💕评论💬感谢支持！！！

    听说 三连能够给人 带来好运！更有可能年入百w，进入大厂，上岸

  • 相关阅读:
    hive on tez学习之官网和源码
    k8s--基础--12.2--pod--生命周期,状态,重启策略
    《教练型管理者》读书笔记-第3篇 【教练流程】
    C#常量的定义和使用
    【实战】kubeadmin安装kubernetes集群
    安防监控用品经营商城小程序搭建
    Centos7系统重装报错“ /dev/root does not exist“解决办法
    Vue.js项目中使用vue-i18n
    【Flink】事务型Sink连接器、kafka连接器、写入到redis、mysql
    html实现爱情告白(附源码)
  • 原文地址：https://blog.csdn.net/m0_67184231/article/details/133492154