java设计模式之——建造者（Builder）模式

设计模式之——建造者（Builder）模式

建造者模式定义

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

建造者模式的优点

1. 每个具体的建造者互相独立，便于系统的扩展；
2. 客户端无需知道产品内部组成的部分，有利于控制风险。

建造者模式的缺点

1. 产品的组成部分必须相同；
2. 产品的内部如果变化复杂，就会增加很多建造者。

建造者模式的实现

定义一个产品

/**
 * @ClassName Car
 * @Description TODO
 * @Author mamingcong
 * @Date 2020/6/7 15:25
 * @Version 1.0
 */
public class Car {
    private String tyre;//轮胎
    private String brake;//刹车
    private String wheel;//方向盘

    public String getTyre() {
        return tyre;
    }

    public void setTyre(String tyre) {
        this.tyre = tyre;
    }

    public String getBrake() {
        return brake;
    }

    public void setBrake(String brake) {
        this.brake = brake;
    }

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
    
    public void run(){
        if("".equals(tyre) || tyre==null){
            System.out.println("汽车没有轮胎");
        }else if("".equals(brake) || brake==null){
            System.out.println("汽车没有刹车");
        }else if("".equals(wheel) || wheel==null){
            System.out.println("汽车没有方向盘");
        }else{
            System.out.println("汽车跑起来了");
        }
    }
}

定义抽象建造者

/**
 * @ClassName Builder
 * @Description TODO
 * @Author mamingcong
 * @Date 2020/6/7 15:30
 * @Version 1.0
 */
public abstract class Builder {

    protected Car car = new Car();

    public abstract void buildTyre();

    public abstract void buildBrake();

    public abstract void buildWheel();
    
    public Car getResult() {
        return car;
    }
}

定义具体建造者

/**
 * @ClassName RealBuilder
 * @Description TODO
 * @Author mamingcong
 * @Date 2020/6/7 15:32
 * @Version 1.0
 */
public class RealBuilder extends Builder {
    @Override
    public void buildTyre() {
        car.setTyre("安装了轮胎");
    }

    @Override
    public void buildBrake() {
        car.setBrake("安装了刹车");
    }

    @Override
    public void buildWheel() {
        car.setWheel("安装了方向盘");
    }
}

定义指挥者

/**
 * @ClassName Director
 * @Description TODO
 * @Author mamingcong
 * @Date 2020/6/7 15:35
 * @Version 1.0
 */
public class Director {

    private Builder builder;

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

    public Car build() {
        builder.buildBrake();
        builder.buildTyre();
        builder.buildWheel();
        return builder.getCar();
    }
}

测试

/**
 * @ClassName Test
 * @Description TODO
 * @Author mamingcong
 * @Date 2020/6/7 15:38
 * @Version 1.0
 */
public class Test {

    public static void main(String[] args) {
        Builder builder = new RealBuilder();
        Director director = new Director(builder);
        Car build = director.build();
        build.run();
    }
}

运行结果

汽车跑起来了

建造者模式的使用场景

1. 创建的对象较复杂，由多个部件构成；
2. 产品的构建过程和最终的表示是独立的。