java23种设计模式—建造者模式

 

1.  定义：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。


简单点描述就是将一个复杂对象的构建拆分成若干步骤，每个构建步骤赋予复杂对象不同的属性，如此以来，通过同样的构建过程可以创建不同的对象。对象的构建过程由指导者director指导。客户端通过指导者创建需要的对象。


2. 该模式包含的角色及其功能：
- 产品：需要被构造的对象
- 建造者：具有一系列构建产品的方法的对象
- 指导者：负责调用建造者，执行建造者一系列的建造方法


3. 使用情景：
 
- 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时
- 当构造过程允许被构造的对象有不同的表示时
4. 示例代码：

 

 

 

 

/**
 * 抽象汽车建造者接口.
 */
public interface ICarBulider {


    void composeEngine(String engine);


    void composeSteelingWheel(String steelingWheel);


    void composeWheel(String wheel);


    Car buildCar();
}

/**
 * 被建造的产品（汽车）.
 */
public class Car {
    
    private String Engine;
    /**
     * desc:方向盘
     */
    private String SteelingWheel;
    
    /**
     * desc:轮子
     */
    private String wheel;


    public String getEnging() {
        return Enging;
    }


    public void setEnging(String enging) {
        Enging = enging;
    }


    public String getSteelingWheel() {
        return SteelingWheel;
    }


    public void setSteelingWheel(String steelingWheel) {
        SteelingWheel = steelingWheel;
    }


    public String getWheel() {
        return wheel;
    }


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


    @Override
    public String toString() {
        return "Car{" +
                "Enging='" + Enging + '\'' +
                ", SteelingWheel='" + SteelingWheel + '\'' +
                ", wheel='" + wheel + '\'' +
                '}';
    }
}

/**
 * 具体的汽车建造者
 */
public class CarBuilder implements ICarBulider {
    
    private Car car = new Car();


    @Override
    public void composeEngine(String engine) {
        car.setEnging(engine);
    }


    @Override
    public void composeSteelingWheel(String steelingWheel) {
        car.setSteelingWheel(steelingWheel);
    }


    @Override
    public void composeWheel(String wheel) {
        car.setWheel(wheel);
    }
    
    @Override
    public Car buildCar() {
        return car;
    }
}

/**
 * 指导者
 */
public class Director {
    private ICarBuilder builder

    public Director(ICarBuilder carBuilder) {
        this.builder = carBuilder;
    } 
    public ICarBuilder buildEngine(String name) {
        builder.composeEngine(name);
        return builder;
    }

    public ICarBuilder buildWheel(String name) {
        builder.composeWheel(name);
        return builder;
    }

    public ICarBuilder buildSteelingWheel(String name) {
        builder.composeSteelingWheel(name);
        return builder;
    }

    public Car build() {
        return this.carbuilder.builderCar();
    }




    public static Car constructCar(ICarBulider carBulider) {
        carBulider.composeEngine("德国制造");
        carBulider.composeWheel("四轮子汽车轮胎");
        carBulider.composeSteelingWheel("单幅");
        return carBulider.buildCar();
    }
}

/**
 * 测试客户端
 */
public class Client {
    public static void main(String[] args) {
        Director direct = new Director(new CarBuilder());
        Car car = direct.buildEngine("德国制造“).buildWheel("四轮汽车轮 
        胎").buildSteelingWheel("单幅").build()；
        System.err.println(car.toString());
    }
    
}

 

控制台打印结果：
Car{Enging='德国制造', SteelingWheel='单幅', wheel='四轮子汽车轮胎'}

5. 延伸

 

 

当建造者是系统具体的一个类的时候，指导者可以省略。其结果就是指导者和建造者合二为一。

 

此博客与github个人博客同步，如果想要更好的阅读体验，请访问：https://asituyasi.github.io/

更多设计模式原创文章：

原型模式

单例模式

建造者模式

工厂模式

策略模式