Java设计模式--建造者模式（4）

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

 

举个简单的例子：比如一辆汽车，它包括车轮，方向盘，轴，发动机等多种零件，但是对于大多数用户来说，并不需要知道这些装配细节也不会单独使用某一个零件，而是使用一辆完整的汽车。

 

建造者模式角色分为Builder(抽象建造者)，ConcreteBuilder(具体建造者)，Product(产品)，Director(指挥者) 4个角色。

 

需求：建造一辆汽车，汽车包含轮胎，方向盘，座位，发动机等等零件（代码只写这4个属性。。。）。

 

建造者模式代码实战：

 

汽车产品对象（对应的角色为产品）

package com.create.builder;

import java.io.Serializable;

/**
 * 汽车复杂类
 */
public class Car implements Serializable {

    /**
     * 轮胎尺寸
     */
    private String tireSize;

    /**
     * 发动机类型
     */
    private String engine;

    /**
     * 几座
     */
    private Integer number;

    /**
     * 方向盘
     */
    private String circle;

    public String getTireSize() {
        return tireSize;
    }

    public void setTireSize(String tireSize) {
        this.tireSize = tireSize;
    }

    public String getEngine() {
        return engine;
    }

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

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }

    public String getCircle() {
        return circle;
    }

    public void setCircle(String circle) {
        this.circle = circle;
    }
}

 

汽车抽象建造者（对应的角色为抽象建造者）

package com.create.builder;

/**
 * 汽车建造者 (充当抽象建造者)
 */
public abstract class CarBuilder {

    protected Car car = new Car();

    public abstract void buildTireSize();

    public abstract void buildEngine();

    public abstract void buildNumber();

    public abstract void buildCircle();


    //工厂方法，返回一个完整的对象
    public Car createCar() {
        return car;
    }

}

 

具体建造者（对应的角色为具体建造者）

package com.create.builder;

/**
 * 奔跑汽车建造者 （充当具体建造者）
 */
public class BenPaoCarBuilder extends CarBuilder {
    @Override
    public void buildTireSize() {
        car.setTireSize("10寸轮胎");
    }

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

    @Override
    public void buildNumber() {
        car.setNumber(2);
    }

    @Override
    public void buildCircle() {
        car.setCircle("三角形方向盘");
    }
}

 

具体建造者（对应的角色为具体建造者）

package com.create.builder;

/**
 * 飞豹汽车建造者 （充当具体建造者）
 */
public class FeiBaoCarBuilder extends CarBuilder {
    @Override
    public void buildTireSize() {
        car.setTireSize("16寸轮胎");
    }

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

    @Override
    public void buildNumber() {
        car.setNumber(7);
    }

    @Override
    public void buildCircle() {
        car.setCircle("圆形方向盘");
    }
}

 

 

汽车控制器（对应的角色为指挥者）

package com.create.builder;

/**
 * 建造者汽车控制器（指挥者）
 */
public class CarController {


    public Car construct(CarBuilder carBuilder) {
        //逐步构建复杂产品对象汽车
        Car car;
        carBuilder.buildTireSize();
        carBuilder.buildEngine();
        carBuilder.buildNumber();
        carBuilder.buildCircle();
        car = carBuilder.createCar();
        return car;
    }
}

 

测试类

 

package com.create.builder;

public class Client {


    public static void main(String[] args) {
        //建造者模式测试
        CarController carController = new CarController();
        //通知指挥者创建对象
        Car car = carController.construct(new FeiBaoCarBuilder());

        System.out.println("轮胎尺寸是： "+car.getTireSize());
        System.out.println("发动机是： "+car.getEngine());
        System.out.println("座位数是： "+car.getNumber());
        System.out.println("方向盘是： "+car.getCircle());
    }
}

 

运行的结果是：

轮胎尺寸是： 16寸轮胎
发动机是： 中国发动机
座位数是： 7
方向盘是： 圆形方向盘

 

建造者模式的优缺点：

优点：客户端不必知道产品内部的组成细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的对象。

           每一个建造者都是独立的，增加新的建造者无需修改原有代码，系统扩展方便，符合开闭原则。

 

 缺点：建造者模式所创建的对象一般具有较多的共同属性，其组成部分相似，如果对象产品差异性较大，则不适合使用建造者模              式，使用范围受限。

            如果产品内部变化复杂，可能会导致需要定义更多的具体建造者类来实现这种变化，这会导致系统变得越来越庞大，随                之而来的是理解难度和运行成本的增加。