java游戏服务器 建造者模式

这里的具体的建造者ConcreteBuilder可以多个

这里我们以建造汽车为例：

假设汽车需要：方向盘、汽车壳、还有四个轮子  ---------这三样才能跑起来

如果你因为粗心漏了其中的某个建造过程（例如：忘了装方向盘），那么汽车就跑不起来。

有什么方法可以避免粗心，漏了其中的某个过程？

代码如下：

1.Builder类 为 AbstractBuilderCar

**
 *
 * 抽象建造汽车父类
 * @author lizhibiao
 * @date 2019/1/16 21:34
 */
public abstract class AbstractBuilderCar
{
    /**
     * 抽象的----建造方向盘方法
     */
    public abstract void buildSteeringWheel();

    /**
     * 抽象的----安上汽车壳
     */
    public abstract void buildShell();

    /**
     * 抽象的----安上轮子
     */
    public abstract void buildWheel();

    /**
     * 获取汽车
     * @return 返回汽车类
     */
    public abstract Car getCar();

}

这里最核心的地方是： 

首先 AbstractBuilderCar是一个抽象类

然后 它的方法都是抽象方法，这么做的必要是为了让子类继承时，都必须实现抽象方法，避免粗心，漏掉其中的某个建造过程。（子类是不是抽象类，那么继承抽象父类时，必须实现所有的抽象方法，否则报错）

最后，有一个获取汽车类

2.两个ConcreteBuilder类(小黄车和小蓝车)，继承Builder

/**
 * 小黄车
 * @author lizhibiao
 * @date 2019/1/16 21:43
 */
public class YellowCar extends AbstractBuilderCar
{

    private Car car = new Car();

    @Override
    public void buildSteeringWheel()
    {
        car.add("1.装上方向盘");
    }

    @Override
    public void buildShell()
    {
        car.add("2.装上黄色的车壳");
    }

    @Override
    public void buildWheel()
    {
        car.add("3.最后安上四个轮子");
    }

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

/**
 * 小蓝车
 * @author lizhibiao
 * @date 2019/1/16 21:46
 */
public class BlueCar extends AbstractBuilderCar
{
    private Car car = new Car();

    @Override
    public void buildSteeringWheel()
    {
        car.add("1.装上方向盘");
    }

    @Override
    public void buildShell()
    {
        car.add("2.装上蓝色的车壳");
    }

    @Override
    public void buildWheel()
    {
        car.add("3.最后安上四个轮子");
    }

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

3.Car类

/**
 * @author lizhibiao
 * @date 2019/1/16 21:52
 */
public class Car
{
    /**
     * 建造步骤list
     */
    private List<String> list = new ArrayList<>();

    /**
     * 添加汽车建造步骤
     */
    public void add(String steps)
    {
        list.add(steps);
    }

    /**
     * 打印汽车
     */
    public void printCar()
    {
        for (String stepInfo : list)
        {
            System.out.println(stepInfo);
        }
    }

}

4.指挥者类

/**
 * 指挥者类
 * @author lizhibiao
 * @date 2019/1/16 21:49
 */
public class Director
{

    /**
     * 建造过程
     * @param builderCar 传入具体建造者，例如：小黄、小蓝
     */
    public void build(AbstractBuilderCar builderCar)
    {
        builderCar.buildSteeringWheel();
        builderCar.buildShell();
        builderCar.buildWheel();
    }

}

5.测试类

/**
 * 测试类
 * @author lizhibiao
 * @date 2019/1/17 15:05
 */
public class Main
{
    public static void main(String[] args)
    {
        //指挥者
        Director director = new Director();

        //new一个小黄车，多态，返回的是抽象父类
        AbstractBuilderCar buildYellowCar = new YellowCar();
        //按顺序建造汽车
        director.build(buildYellowCar);
        //获取小黄车
        Car yellowCar = buildYellowCar.getCar();
        //打印建造过程
        yellowCar.printCar();

        System.out.println("=======================");
        System.out.println("=======================");

        //建造小蓝车
        AbstractBuilderCar buildBlueCar = new BlueCar();
        director.build(buildBlueCar);
        Car blueCar = buildBlueCar.getCar();
        blueCar.printCar();

    }
}

输出结果：

1.装上方向盘

2.装上黄色的车壳

3.最后安上四个轮子

=======================

=======================

1.装上方向盘

2.装上蓝色的车壳

3.最后安上四个轮子