笨蛋学设计模式创建者模式-建造者模式【5】

6.4建造者模式⬆️⬆️⬆️

6.4.1概念

​ 建造者模式将一个复杂对象的构建和表示分离开，使得同样的构建过程可以创建不同的表示。通过将对象的创建过程抽象为一个建造者接口，并定义了创建复杂对象的方法。具体实现类可以按照一定的顺序和方式创建对象，并最终返回创建好的复杂对象

---

​ 与工厂模式不同的是，工厂模式注重的是创建对象，并不关注创建对象过程及结构；但是建造者模式需要了解创建对象的结构，并按照一定的顺序和方式创建这些。

---

6.4.2场景

​ 我们都知道建造房子这个过程是由不同的对象组成的，比如门、窗、家具、灯饰等，且都有一定的顺序，比如得先安装门、窗等，再去布局屋内。所以当我们建造房子时，会由工人(建造者)按照一定的顺序先后对房子进行建造，由于这个过程是十分复杂的，所以我们可以与工人(建造者)进行沟通，按照我们的想法去制定不同的建造顺序来建造房子。

6.4.3优势 / 劣势

• 提高封装性：将对象的创建过程和使用分离，使得可以相互独立，提高了代码的模块化和可维护性
• 提升扩展性：将对象的创建过程抽象为一个建造者接口，并定义创建对象的方法，不同的实现类根据需求实现接口创建不同的对象，使得建造类之间相互独立

---

• 限制使用范围：要求组成部分必须相同，限制了使用范围；若对象的部分组成不同，就需要创建不同的建造者类来处理这些差异，增加了代码的复杂度

• 增加维护成本：若对象内部组成复杂，当发生变化时，建造者也需要同步修改，维护成本大

• 过于复杂：若对象构建过程简单，使用建造者模式可能会显得过于复杂，反而增加了代码的复杂度

---

6.4.4建造者模式分为

• 产品Product：被构建的复杂对象，包含多个组成部分
• 抽象建造者Builder：定义构建产品各个部分的抽象接口和一个返回复杂产品的方法getResult
• 具体建造者Concrete Builder：是心啊抽象建造者接口，构建产品的各个组成部分，并提供一个方法返回最终的产品
• 指导者Director：调用具体建造者的方法，按照一定的顺序或逻辑来构建产品

6.4.5建造者模式

package com.designpattern.mode.builder;

public class Builder {

    public static void main(String[] args) {
        //客户端使用建造者模式，在客户端创建具体建造者对象和指导者对象，通过指导者来构建产品
        //创建具体建造者
        AbstractBuilder builder = new ConcreteBuilder();
        //创建指导者
        Director director = new Director(builder);

        //指导者构建产品
        director.construct();

        //获取构建好的产品
        Product product= builder.getResult();

        //输出产品信息
        System.out.println(product);

    }
}

//产品类，包含多个组成部分，并由这些属性和方法构成产品
class Product{
    private String part1;
    private String part2;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                '}';
    }
}

//抽象建造者接口，创建接口用于包含构建产品各个部分的抽象方法，用于设置产品的各个属性
interface AbstractBuilder{
    void buildPart1(String part1);
    void buildPart2(String part2);
    Product getResult();
}

//创建具体建造者，实现抽象建造者接口，构建具体的产品
class ConcreteBuilder implements AbstractBuilder{
    private Product product=new Product();

    @Override
    public void buildPart1(String part1) {
        product.setPart1(part1);
    }

    @Override
    public void buildPart2(String part2) {
        product.setPart2(part2);
    }

    @Override
    public Product getResult() {
        return product;
    }
}

//定义Director类，指导者来控制构建产品的顺序和步骤
class Director{
    private AbstractBuilder builder;

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

    //调用方法构建产品
    public void construct(){
        builder.buildPart1("构建part1");
        builder.buildPart2("构建part2");
    }
}

6.4.6实战

6.4.6.1题目描述

小明家新开了一家自行车工厂，用于使用自行车配件（车架 frame 和车轮 tires ）进行组装定制不同的自行车，包括山地车和公路车。

山地车使用的是Aluminum Frame（铝制车架）和 Knobby Tires（可抓地轮胎），公路车使用的是 Carbon Frame （碳车架）和 Slim Tries。

现在它收到了一笔订单，要求定制一批自行车，请你使用【建造者模式】告诉小明这笔订单需要使用那些自行车配置吧。

6.4.6.2输入描述

输入的第一行是一个整数 N（1 ≤ N ≤ 100），表示订单的数量。

接下来的 N 行，每行输入一个字符串，字符串表示客户的自行车需求。

字符串可以包含关键词 “mountain” 或 “road”，表示客户需要山地自行车或公路自行车。

6.4.6.3输出描述

对于每笔订单，输出该订单定制的自行车配置。

6.4.6.4代码

package com.designpattern.mode.builder;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nums = scanner.nextInt();
        scanner.nextLine();

        //构建指导者
        BicycleDirector bicycleDirector = new BicycleDirector();

        for(int i=0;i<nums;i++){
            String bicycleType = scanner.nextLine();
            BicycleBuilder bicycleBuilder = null;
            //根据输入的类型，分别创建不同的具体建造者
            if(bicycleType.equals("mountain")){
                bicycleBuilder=new MountainBicycle();
            }else if(bicycleType.equals("road")){
                bicycleBuilder= new RoadBicycle();
            }

            //执行生产方法构建自行车
            Bicycle bicycle = bicycleDirector.construct(bicycleBuilder);
            System.out.println(bicycle);
        }
    }
}

//定义自行车产品
class Bicycle{
    //车架
    private String frame;
    //车轮
    private String tires;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getTires() {
        return tires;
    }

    public void setTires(String tires) {
        this.tires = tires;
    }

    @Override
    public String toString() {
        return 
                "frame='" + frame + '\'' +
                ", tires='" + tires;
    }
}

//抽象建造者，用于定义自行车的车轮和车架
interface BicycleBuilder{

    void buildFrame();

    void buildTires();

    Bicycle getResult();
}

//创建具体建造者，构建具体的产品
class MountainBicycle implements BicycleBuilder{

    private Bicycle bicycle=new Bicycle();
    @Override
    public void buildFrame() {
        bicycle.setFrame("Aluminum Frame");
    }

    @Override
    public void buildTires() {
        bicycle.setTires("Knobby Tires");
    }

    @Override
    public Bicycle getResult() {
        return bicycle;
    }
}

class RoadBicycle implements BicycleBuilder{

    private Bicycle bicycle=new Bicycle();
    @Override
    public void buildFrame() {
        bicycle.setFrame("Carbon Frame");
    }

    @Override
    public void buildTires() {
        bicycle.setTires("Slim Tires");
    }

    @Override
    public Bicycle getResult() {
        return bicycle;
    }
}

//定义指导者，指导自行车构建顺序
class BicycleDirector{

    //构建自行车
    public Bicycle construct(BicycleBuilder bicycleBuilder){
        bicycleBuilder.buildFrame();
        bicycleBuilder.buildTires();
        return bicycleBuilder.getResult();
    }

}

6.4.7总结

• 建造者模式

优点：

• 将⼀个复杂对象的构建与其表示分离，通过将构建复杂对象的过程抽象出来，可以使客户端代码与具体的构建过程解耦
• 同样的构建过程可以创建不同的表示

总结：将复杂对象的构建过程与其表示分离，以使同样的构建过程可以创建不同的表示

场景：适用于构建复杂对象的场景，并且希望将构建逻辑与表示分离的情况