设计模式之初识建造者设计模式

一、介绍
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。
优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类
使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
详细介绍见菜鸟教程
二、UML图

三、用例介绍（UML图解释）
穿越火线中有很多英雄级武器，这些英雄级武器分为很多种类，这里就举M4A1和AK47这两种，而这些英雄级武器还有很多装饰，比如枪口火焰颜色和枪上挂的娃娃这两种，而装饰品和武器的搭配就会形成很多不同的产品，这些产品的组合也会形成不同的系列。
四、代码
1.创建英雄级武器接口

public interface HeroicGun {
    String name();
    Decorate dress();
    Float cost();
}

2.创建装饰品接口

public interface Decorate {
    String dress();
}

3.创建具体的装饰品
蓝色火焰枪口：

public class FlameMuzzle implements Decorate{
    @Override
    public String dress() {
        return "蓝色火焰枪口";
    }
}

齐天大圣娃娃：

public class Pendant implements Decorate{
    @Override
    public String dress() {
        return "齐天大圣娃娃";
    }
}

4.创建不种类的武器抽象类来实现武器接口,
AK47类用蓝色火焰枪口装饰：

public abstract class AK47 implements HeroicGun{
    @Override
    public Decorate dress() {
        return new FlameMuzzle();
    }

    @Override
    public abstract Float cost();
}

M4A1类用齐天大圣娃娃装饰：

public abstract class M4A1 implements HeroicGun{
    @Override
    public Decorate dress() {
        return new Pendant();
    }

    @Override
    public abstract Float cost();
}

5.创建具体的武器来继承抽象类：
AK47-火麒麟：

public class FlameAK47 extends AK47{
    @Override
    public Float cost() {
        return 888.0f;
    }

    @Override
    public String name() {
        return "AK47-火麒麟";
    }
}

AK47-雷神：

public class ThorAK47 extends AK47{
    @Override
    public Float cost() {
        return 888.0f;
    }

    @Override
    public String name() {
        return "AK47-雷神";
    }
}

M4A1-雷神：

public class ThorM4A1 extends M4A1{
    @Override
    public Float cost() {
        return 888.0f;
    }

    @Override
    public String name() {
        return "M4A1-雷神";
    }
}

M4A1-死神：

public class DeathM4A1 extends M4A1{
    @Override
    public Float cost() {
        return 1288.0f;
    }

    @Override
    public String name() {
        return "M4A1-死神";
    }
}

前面都是为武器系列做准备的，后面才是最重要的两个步骤
6.创建武器系列类，武器系列类会维护一个List集合来使用前面的英雄级武器：

public class Arms {
    private List<HeroicGun> heroicGuns = new ArrayList();

    public void addHeroicGun(HeroicGun heroicGun){
        heroicGuns.add(heroicGun);
    }

    public float getCost(){
        float cost = 0.0f;
        for (HeroicGun heroicGun : heroicGuns) {
            cost += heroicGun.cost();
        }
        return cost;
    }

    public void showHeroicGun(){
        for (HeroicGun heroicGun : heroicGuns) {
            System.out.print("武器 : "+heroicGun.name());
            System.out.print(", 装饰 : "+heroicGun.dress().dress());
            System.out.println(", 价格 : "+heroicGun.cost() + "元");
        }
    }
}

7.创建武器系列构建类，构建类内部封装了各种武器系列的创建

public class ArmsBuilder {
    public Arms buildAk47 (){
        Arms arms = new Arms();
        arms.addHeroicGun(new ThorAK47());
        arms.addHeroicGun(new FlameAK47());
        return arms;
    }

    public Arms buildM4A1 (){
        Arms arms = new Arms();
        arms.addHeroicGun(new DeathM4A1());
        arms.addHeroicGun(new ThorM4A1());
        return arms;
    }

    public Arms buildThor (){
        Arms arms = new Arms();
        arms.addHeroicGun(new ThorAK47());
        arms.addHeroicGun(new ThorM4A1());
        return arms;
    }
}

8.测试

public class Test {
    public static void main(String[] args) {
        ArmsBuilder armsBuilder = new ArmsBuilder();

        Arms m4A1 = armsBuilder.buildM4A1();
        System.out.println("M4A1系列");
        m4A1.showHeroicGun();
        System.out.println("Total Cost: " +m4A1.getCost() + "元");

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

        Arms ak47 = armsBuilder.buildAk47();
        System.out.println("AK47系列");
        ak47.showHeroicGun();
        System.out.println("Total Cost: " +ak47.getCost() + "元");

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

        Arms thor = armsBuilder.buildThor();
        System.out.println("雷神系列");
        thor.showHeroicGun();
        System.out.println("Total Cost: " +thor.getCost() + "元");
    }
}

9.结果