Java设计模式-建造者模式理论代码相结合

最新推荐文章于 2024-07-09 00:33:04 发布

宁在春

最新推荐文章于 2024-07-09 00:33:04 发布

阅读量114

点赞数

分类专栏： JAVA 文章标签： java 设计模式面试

本文链接：https://blog.csdn.net/weixin_45821811/article/details/119517569

版权

JAVA 专栏收录该内容

24 篇文章 6 订阅

订阅专栏

继工厂模式后的建造者模式，也是java中常常能够见到的模式一种，应用场景也比较广，比较好用。
大家想了解的话，一起来看一看啦。😁
很喜欢一句话：“八小时内谋生活，八小时外谋生存”
你好，如果喜欢，请一起坚持！！
望别日与君相见时，君已有所成。
共勉

在这里插入图片描述
先看看图舒缓心情。😁 （~~我才不会告诉你我是一名喜欢蓝天白云大海的小小博主😀~~ ）

Java设计模式-建造者模式理论代码相结合

一、建造者模式

1）概念：

建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示.

举几个生活中的例子：

生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。

还例如，计算机是由 CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。

在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。

在这里插入图片描述

2）使用场景：

当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
当构造过程必须允许被构造的对象有不同表示时。

3）角色：

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

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

4）解释：

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

图示：

在这里插入图片描述

二、代码实例

2.1、题目

创建手机

生产手机是一个复杂的过程，它包含了手机芯片、后壳、屏幕等组件。手机芯片又有多种高通、ios等，后壳也有多种玻璃、陶瓷等，屏幕也是一样的。

这里Phone是产品，包含芯片、后壳、屏幕等组件；Builder是抽象建造者，IphoneBuilder和HuaweiBuilder是具体的建造者；Director是指挥者。

2.2、类图

在这里插入图片描述

2.3、代码

1、Phone （具体产品类）

@Data
public class Phone {
    /**手机芯片*/
    private String chip;
    /** 后壳*/
    private String backCover;
    /**屏幕*/
    private String screen;
}

2、Builder (抽象建造者类)

public abstract  class Builder {
    protected Phone phone = new Phone();
    
    public abstract void buildchip();
    public abstract void buildbackCover();
    public abstract void buildscreen();
    public abstract Phone getPhone();

}

3、HuaweiBuilder、IphoneBuilder （具体建造者类）

public class HuaweiBuilder extends Builder{

    @Override
    public void buildchip() {   phone.setChip("华为自言芯片麒麟9000");  }

    @Override
    public void buildbackCover() {     phone.setBackCover("玻璃后壳");  }

    @Override
    public void buildscreen() {     phone.setScreen("国产屏幕"); }

    @Override
    public Phone getPhone() {   return phone; }
}

public class IphoneBuilder extends Builder {

    @Override
    public void buildchip() {  phone.setChip("苹果自研ios芯片"); }

    @Override
    public void buildbackCover() { phone.setBackCover("玻璃后壳"); }

    @Override
    public void buildscreen() {   phone.setScreen("iphone屏幕");  }

    @Override
    public Phone getPhone() {   return phone; }
}

4、Director （指挥者类）

public class Director {

    private Builder builder;

    public Director(Builder builder) {     this.builder = builder; }

    public Phone construct() {
        builder.buildchip();
        builder.buildbackCover();
        builder.buildscreen();
        return builder.getPhone();
    }
}

上面示例是 Builder模式的常规用法，根据系统设计情况的不同，设计模式在一些细节地方会作出一些更改，当然这是为了更好的利用设计模式的优势。（具体问题具体分析使用，这是不可避免的）😁

2.4、测试

代码就是上面这些，不多。

public class Client {

    public static void main(String[] args) {
        // Director director = new Director(new IphoneBuilder());
        // 想要换Huawei啦 只需要换成HuaweiBuilder 即可，而不需要修改其他代码
        Director director = new Director(new HuaweiBuilder());
        Phone phone = director.construct();
        System.out.println(phone);
    }
}

三、总结

优点：

1）建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。

2）客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象

3）可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程

4）增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”

缺点：

造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式.

四、扩展

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

这个是非常常见的。

代码重构前：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
}

public class Client {
    public static void main(String[] args) {
        //构建Phone对象
        Phone phone = new Phone("intel","三星屏幕","金士顿","华硕");
        System.out.println(phone);
    }
}

new 对象是需要传递了四个参数，如果参数更多呢？代码的可读性及使用的成本就是比较高。

代码重构后：

public class Phone {

    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    private Phone(Builder builder) {
        cpu = builder.cpu;
        screen = builder.screen;
        memory = builder.memory;
        mainboard = builder.mainboard;
    }

    public static final class Builder {
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;

        public Builder() {}

        public Builder cpu(String val) {
            cpu = val;
            return this;
        }
        public Builder screen(String val) {
            screen = val;
            return this;
        }
        public Builder memory(String val) {
            memory = val;
            return this;
        }
        public Builder mainboard(String val) {
            mainboard = val;
            return this;
        }
        public Phone build() {
            return new Phone(this);}
    }
    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}


public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .cpu("intel")
                .mainboard("华硕")
                .memory("金士顿")
                .screen("三星")
                .build();
        System.out.println(phone);
    }
}

重构后的这种代码，大家也是经常能够看到的方式，不过这里只是一个小小demo，只是为了演示，不足之处众多，请见谅。

五、工厂模式VS建造者模式

Java设计模式-工厂方法模式

1、工厂方法模式VS建造者模式

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

举个简单例子：

1、如要制造一个超人，如果使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人；

2、而如果使用建造者模式，则需要组装手、头、脚、躯干等部分，然后再把内裤外穿，于是一个超人就诞生了。

2、抽象工厂模式VS建造者模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可。
建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

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

五、自言自语

你卷我卷，大家卷，什么时候这条路才是个头啊。😇（还是直接上天吧)

有时候也想停下来歇一歇，一直做一个事情，感觉挺难坚持的。😁

你好，如果你正巧看到这篇文章，并且觉得对你有益的话，就给个赞吧，让我感受一下分享的喜悦吧，蟹蟹。🤗

如若有写的有误的地方，也请大家不啬赐教！！

同样如若有存在疑惑的地方，请留言或私信，定会在第一时间回复你。

持续更新中

宁在春

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java设计模式-建造者模式理论代码相结合

继工厂模式后的建造者模式，也是java中常常能够见到的模式一种，应用场景也比较广，比较好用。大家想了解的话，一起来看一看啦。????很喜欢一句话：“八小时内谋生活，八小时外谋生存”你好，如果喜欢，请一起坚持！！望别日与君相见时，君已有所成。共勉先看看图舒缓心情。???? （我才不会告诉你我是一名喜欢蓝天白云大海的小小博主???? ）Java设计模式-建造者模式理论代码相结合一、建造者模式1）概念：2）使用场景：3）角色：4）解释：二、代码实例2.1、题目2.2、类图2.3、代码2.4、测
复制链接

扫一扫