设计模式系列（五）：建造者模式

设计模式干学着难免有些枯燥，相比而言，王者荣耀就显得有意思多了。所以今天我们不谈设计模式，谈农药。

王者荣耀有很多英雄以及装备，不同的英雄还要搭配不同的装备，这个对新手显得不太友好。咱们作为一个老手，今天来帮帮忙。

实现

虽然游戏里角色众多，但大致可以分为射手，法师，坦克，战士，辅助这几类。我们为这几大类英雄定制一套通用的出装，来指导新手。

产品类

需求有了，根据描述，我们首先得有一个具体的产品类，也就是游戏的英雄角色。

public class Hero {
    // 英雄的装备
    private List<String> equipments = new ArrayList<String>()；
    // 英雄的种类
    private String type;

    public Hero(type) {
        this.type = type;
    }

    // 为英雄添加装备
    public void add(String equipment) {
        equipments.add(equipment)
    }

    public void show() {
        Log.d("Chen", type + "类英雄通用出装如下：");
        for(int i = 0; i < equipments.size(); i++) {
            Log.d("Chen", "第" + i + "件装备出" + equipments.get(i));
        }
        Log.d("Chen", "------------------------");
    }
}

抽象建造者

抽象构造者用来规范产品的组建。

public abstract class Builder {
    // 设定防御装
    protect abstract void buildDefense();
    // 设定攻击装
    protect abstract void buildAttact();
    // 设定移速装
    protect abstract void buildSpeed();
    // 获得配齐装备的英雄
    public abstract Hero getHero();
}

具体建造者

根据需求，首先实现射手类的具体建造者。具体建造者实现抽象类定义的所有方法，并返回一个组建好的对象。

public class SheShouBuilder extend Build {
    // 创建产品类的实例
    Hero sheShou = new Hero("射手");

    @Override
    protect void buildDefense(){
        sheShou.add("防御装--魔女斗篷");
    }
    @Override
    protect void buildAttact(){
        sheShou.add("攻击装--闪电匕首");
    }
    @Override
    protect void buildSpeed(){
        sheShou.add("移速装--影忍之足");
    }

    @Override
    protect Hero getHero(){
        return sheShou;
    }
}

同理，接着实现法师类的具体建造者。

public class FaShiBuilder extend Build {
    // 创建产品类的实例
    Hero fashi = new Hero("法师");

    @Override
    protect void buildDefense(){
        fashi.add("防御装--极寒风暴");
    }
    @Override
    protect void buildAttact(){
        fashi.add("攻击装--痛苦面具");
    }
    @Override
    protect void buildSpeed(){
        fashi.add("移速装--秘法之靴");
    }

    @Override
    protect Hero getHero(){
        return fashi;
    }
}

最后时坦克类的具体建造者。

public class TankeBuilder extend Build {
    // 创建产品类的实例
    Hero tanke = new Hero("坦克");

    @Override
    protect void buildDefense(){
        tanke.add("防御装--红莲斗篷");
    }
    @Override
    protect void buildAttact(){
        tanke.add("攻击装--暗影战斧");
    }
    @Override
    protect void buildSpeed(){
        tanke.add("移速装--抵抗之靴");
    }

    @Override
    protect Hero getHero(){
        return tanke;
    }
}

导演类

导演类负责安排已有模块的组装顺序，并告诉建造者开始建造。

每种英雄角色的侧重点都不同，所以出装顺序很有讲究。

可以看出，这里射手需要输出，所以优先出攻击装；法师需要支援，所以优先出移速装；坦克需要抗伤，所以优先出防御装。

public class Director {
    public void constructSheShou(Builder builder) {
        // 射手出装：攻击装-移速装-防御装
        builder.buildAttact();
        builder.buildSpeed();
        builder.buildDefense();
    }

    public void constructFaShi(Builder builder) {
        // 射手出装：移速装-攻击装-防御装
        builder.buildSpeed();
        builder.buildAttact();
        builder.buildDefense();
    }

    public void constructTanKe(Builder builder) {
        // 坦克出装：防御装-移速装-攻击装
        builder.buildDefense();
        builder.buildSpeed();
        builder.buildAttact();
    }
}

客户端调用

好了，建造者模式的四大类已经全部完工，接着我们就可以在客户端里进行非常舒服地调用了。

Director director = new director();

SheShouBuilder sheShouBuilder = new SheShouBuilder();
director.constructSheShou(sheShouBuilder);
// 射手后羿
Hero houYi = sheShouBuilder.getHero();

FaShiBuilder faShiBuilder = new FaShiBuilder();
director.constructFaShi(faShiBuilder);
// 法师妲己
Hero daJi = faShiBuilder.getHero();

TankeBuilder tankeBuilder = new TankeBuilder();
director.constructTanKe(tankeBuilder);
// 坦克亚瑟
Hero yaSe = tankeBuilder.getHero();

输出结果如下：

D/Chen: 射手类英雄通用出装如下：
D/Chen: 第1件装备出攻击装--闪电匕首
D/Chen: 第2件装备出移速装--影忍之足
D/Chen: 第3件装备出防御装--魔女斗篷
D/Chen: ------------------------
D/Chen: 法师类英雄通用出装如下：
D/Chen: 第1件装备出移速装--秘法之靴
D/Chen: 第2件装备出攻击装--痛苦面具
D/Chen: 第3件装备出防御装--极寒风暴
D/Chen: ------------------------
D/Chen: 坦克类英雄通用出装如下：
D/Chen: 第1件装备出防御装--红莲斗篷
D/Chen: 第2件装备出移速装--抵抗之靴
D/Chen: 第3件装备出攻击装--暗影战斧
D/Chen: ------------------------

总结

真的只是王者荣耀的总结~不管你信不信，反正我信了。

优点

封装性：使用建造者模式可以使客户端不必知道产品内部组成的细节。
易扩展：建造者是独立的，对系统的扩展非常有利。
规避风险：建造的过程不会对其他模块产生影响。

使用场景

需要生产的产品对象有复杂的内部结构，这些产品对象具备共性。
需要隔离复杂对象的创建和使用。
产品类中不同的调用顺序会产生不同的效能。

建造者模式（也叫做生成器模式）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。