目录

一 需求以及实现方式

1.1  需求描述

1.2  传统实现方式

1.3 优缺点

二 建造者模式

2.1 建造者模式概念

2.2 组成部分

2.3 代码实现部分

2.4 总结

---

一 需求以及实现方式

1.1  需求描述

我们要创建一个表示汽车的复杂对象，汽车包含发动机、轮胎和座椅等部分。用传统方式创建，代码如下

1.2  传统实现方式

1.抽象类

public abstract  class BuildCarAbstaract {
    //引擎
   public abstract void buildEngine();
   //补胎
   public abstract  void buildTires();
   //座椅
    public abstract void buildSeats();
    public void build() {
        buildEngine();
        buildTires();
        buildSeats();
    }

}

2.具体实现

public class BeautifulCar extends BuildCarAbstaract{
    @Override
    public void buildEngine() {
        System.out.println(" 豪华ar发动引擎");
    }

    @Override
    public void buildTires() {
        System.out.println(" 豪华car 补胎");
    }

    @Override
    public void buildSeats() {
        System.out.println(" 豪华car 座椅");
    }
}

3.调用

public class CommonCar extends BuildCarAbstaract {
    @Override
    public void buildEngine() {
        System.out.println(" 普通car发动引擎");
    }

    @Override
    public void buildTires() {
       System.out.println(" 普通car 补胎");
    }

    @Override
    public void buildSeats() {
       System.out.println(" 普通car 座椅");
    }
}

4.查看执行结果：

1.3 优缺点

1.优点：容易理解，操作简单

2.缺点：产品和创建产品的过程耦合性强。

3.解决方案：将产品和产品建造过程解耦。使用建造者模式。

二 建造者模式

2.1 建造者模式概念

建造者模式：用于创建一些复杂的、可定制的对象，该对象由多个部分组成，且对象的创建过程需要遵循特定的顺序。将对象的构建过程与其表现分离，使得同样的构建过程可以创建不同的表现。

2.2 组成部分

1.产品（Product）：表示最终要构建的复杂对象。

2.建造者（Builder）：定义用于构建产品的接口，包含创建产品各个部分的方法。

3.具体建造者（Concrete Builder）：实现Builder接口，完成产品各个部分的具体构建工作。

4.指挥者（Director）：负责调用合适的建造者方法，按照特定顺序组装产品。

链接：https://www.zhihu.com/question/21857130/answer/3058463145

2.3 代码实现部分

1.定义一个car的产品类型

package com.ljf.dp.jianshe.demo;

/**
 * @ClassName: Car
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/02/18 12:52:30 
 * @Version: V1.0
 **/
//定义一个car的产品类型
public class Car {
    private String engine;
    private String tires;
    private String seats;

    public String getEngine() {
        return engine;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public String getTires() {
        return tires;
    }

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

    public String getSeats() {
        return seats;
    }

    public void setSeats(String seats) {
        this.seats = seats;
    }

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

2.定义一个建造者，定义一个创建产品car的接口

public interface CarBuilder {
    void buildEngine();
    void buildTires();
    void buildSeats();
    Car getCar();
}

3.定义一个具体的建造者

//定义一个具体的建造者
public class SuvCarBuilder implements CarBuilder {
    private Car car=null;
    public SuvCarBuilder() {
        car=new Car();
    }

    @Override
    public void buildEngine() {
    car.setEngine("suv型 发动机");
    }

    @Override
    public void buildTires() {
       car.setTires("suv型 安全带");
    }

    @Override
    public void buildSeats() {
      car.setSeats("suv型 椅子");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

package com.ljf.dp.jianshe.demo;

/**
 * @ClassName: QiCarBuilder
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/02/18 13:03:40 
 * @Version: V1.0
 **/
public class QiCarBuilder implements CarBuilder{
    private Car car=null;
    public QiCarBuilder() {
        car=new Car();
    }

    @Override
    public void buildEngine() {
        car.setEngine("小轿车型 发动机");
    }

    @Override
    public void buildTires() {
        car.setTires("小轿车型 安全带");
    }

    @Override
    public void buildSeats() {
        car.setSeats("小轿车型 椅子");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

4.创建一个负责组装汽车的类CarDirector

//创建一个负责组装汽车的类CarDirector
public class CarDirector {
    private CarBuilder carBuilder;

    public CarDirector(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public void constructCar() {
        carBuilder.buildEngine();
        carBuilder.buildTires();
        carBuilder.buildSeats();
    }

    public Car getCar() {
        return carBuilder.getCar();
    }

}

5.测试

//可以使用建造者模式来创建不同类型的汽车：
public class TestCar {
    public static void main(String[] args) {
        CarBuilder luxuryCarBuilder = new SuvCarBuilder();
        CarDirector luxuryCarDirector = new CarDirector(luxuryCarBuilder);
        luxuryCarDirector.constructCar();
        Car luxuryCar = luxuryCarDirector.getCar();
        System.out.println("suv汽车：" + luxuryCar);
        CarBuilder qiCarBuilder = new QiCarBuilder();
        CarDirector qiCarDirector = new CarDirector(qiCarBuilder);
        qiCarDirector.constructCar();
        Car qiCar = luxuryCarDirector.getCar();
        System.out.println("小轿车汽车：" + qiCar);
    }
}

6.结果

2.4 总结

建造者模式可以帮助我们创建复杂的对象，同时保持代码的可读性和灵活性。通过将对象的构建过程与其表现分离，我们可以使用同样的构建过程创建不同的表现。在实际开发中，当遇到需要创建复杂对象的场景时，可以考虑使用建造者模式。