关于java:Java设计模式建造者模式

建造者模式

建造者模式（Builder Pattern）应用多个简略的对象一步一步构建成一个简单的对象。这种类型的设计模式属于创立型模式，它提供了一种创建对象的最佳形式。

一个 Builder 类会一步一步结构最终的对象。该 Builder 类是独立于其余对象的。

用意：将一个简单的构建与其示意相拆散，使得同样的构建过程能够创立不同的示意。

次要解决：次要解决在软件系统中，有时候面临着”一个简单对象”的创立工作，其通常由各个局部的子对象用肯定的算法形成；因为需要的变动，这个简单对象的各个局部常常面临着激烈的变动，然而将它们组合在一起的算法却绝对稳固。

何时应用：一些根本部件不会变，而其组合常常变动的时候。

如何解决：将变与不变分来到。

长处：

1. 建造者独立，易扩大。
2. 便于管制细节危险。

毛病：

​ 1. 产品必须有共同点，范畴有限度。

​ 2. 如外部变动简单，会有很多的建造类。

应用场景： 1、须要生成的对象具备简单的内部结构。 2、须要生成的对象外部属性自身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与整机拆卸的程序。而工厂更专一于整机的制作过程。

当初须要构建很多车辆，车的组成有车轮、外壳、发动机、方向盘等，每个组件有不同品牌，最初须要依据客户需要定制不同的车。（车的总体组成是一样的，组成部件变动）

/**
 * @author objcfeng
 * @description 车的实体类
 * @date 2020/11/2
 */
public class Car {
    //车轮
    private String wheel;
    //外壳
    private String shell;
    //发动机
    private String engine;
    //方向盘
    private String steeringWheel;

    @Override
    public String toString() {
        return "Car{" +
                "wheel='" + wheel + '\'' +
                ", Shell='" + shell + '\'' +
                ", engine='" + engine + '\'' +
                ", steeringWheel='" + steeringWheel + '\'' +
                '}';
    }

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getShell() {
        return shell;
    }

    public void setShell(String shell) {
        this.shell = shell;
    }

    public String getEngine() {
        return engine;
    }

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

    public String getSteeringWheel() {
        return steeringWheel;
    }

    public void setSteeringWheel(String steeringWheel) {
        this.steeringWheel = steeringWheel;
    }
}

//车的建造者
public abstract class CarBuilder {
    //造车轮的办法，因为实际上车轮可能是一个简单对象
    public abstract void buildWheel();

    //造外壳的办法
    public abstract void buildShell();

    //造引擎的办法
    public abstract void buildEngine();

    //造方向盘的办法
    public abstract void buildSteeringWheel();

}

建造者实现类，多个品牌组装不同的组件

/**
 * @author objcfeng
 * @description 飞驰建造者
 * @date 2020/11/2
 */
public class BenzBuilder extends CarBuilder {
    private Car car=new Car();

    @Override
    public void buildWheel() {
        car.setWheel("上好的车轮");
    }

    @Override
    public void buildShell() {
        car.setShell("飞驰外壳");
    }

    @Override
    public void buildEngine() {
        car.setEngine("飞驰产发动机");
    }

    @Override
    public void buildSteeringWheel() {
        car.setSteeringWheel("有飞驰标识的方向盘");
    }

    //不须要重写getCar
}

/**
 * @author objcfeng
 * @description 宝马建造者
 * @date 2020/11/2
 */
public class BmwBuilder extends CarBuilder {
    private Car car=new Car();

    @Override
    public void buildWheel() {
        car.setWheel("上好的车轮");
    }

    @Override
    public void buildShell() {
        car.setShell("宝马外壳");
    }

    @Override
    public void buildEngine() {
        car.setEngine("宝马产发动机");
    }

    @Override
    public void buildSteeringWheel() {
        car.setSteeringWheel("有宝马标识的方向盘");
    }
}

指挥者

/**
 * @author objcfeng
 * @description 指挥者,领导具体构建者如何构建产品，管制调用先后秩序，并向调用者返回残缺的产品类
 * @date 2020/11/2
 */
public class CarDirector {
    private CarBuilder builder;

    public CarDirector(CarBuilder builder) {
        this.builder = builder;
    }
    public Car build(){
        builder.buildEngine();
        builder.buildShell();
        builder.buildSteeringWheel();
        builder.buildWheel();
        return builder.getCar();
    }
}

应用：

public class Main {
    public static void main(String[] args) {
        CarBuilder builder1=new BmwBuilder();
        CarBuilder builder2=new BenzBuilder();
        CarDirector carDirector = new CarDirector(builder1);
        Car car = carDirector.build();
        System.out.println(car);
    }
}

输入

Car{wheel='上好的车轮', Shell='宝马外壳', engine='宝马产发动机', steeringWheel='有宝马标识的方向盘'}