建造者模式：设计角度重温游戏中的角色

应用场景

　　假设现在我们要设计DNF中的人物角色(鬼剑士、神枪手、魔法师、圣骑士、格斗家)。然而，利用面对对象的思想，必须先从实体入手，每一个角色都包含各种装备、武器、配饰，这些就当做要建造的零件，然后把装备零件组装起来，那么就是最终人物角色的能量值，然后它就将造成不同的伤害。

　　回忆过程：假设要创建一个角色，先构建装备零件，控制者控制组装装备零件，构建者得到专属角色。

简述实现

　　建造者模式：将一部负责对象的构建分为许多小对象的构建，最后在整合构建的模式。

　　建造者模式适用于构造一个很复杂的对象，将其拆分成很多个小对象，方便管理对象。

　　

　　控制者(Director)：控制整个组合过程，通过调用Builder内部的各组件的生成方法进行组装。

　　构建者(Builder)：构建者接口，定义构建各部件的方法。

　　实际构建者(ConcreteBuilder)：具体构建出各部件对象，获得构造结构。

　　成品(Product):成品类。

　　成品类(Car)

public class Car {
    //车头
    private CarHead carHead;
    //车身
    private CarBody carBody;
    //车轮
    private Wheel wheel;
    
    public Car() {}
    
    public Car(CarHead carHead, CarBody carBody, Wheel wheel) {
        super();
        this.carHead = carHead;
        this.carBody = carBody;
        this.wheel = wheel;
    }
    
    public void run(){
        System.out.println("车开着 嘟嘟嘟嘟！！！");
    }

    public CarHead getCarHead() {
        return carHead;
    }
    public void setCarHead(CarHead carHead) {
        this.carHead = carHead;
    }
    public CarBody getCarBody() {
        return carBody;
    }
    public void setCarBody(CarBody carBody) {
        this.carBody = carBody;
    }
    public Wheel getWheel() {
        return wheel;
    }
    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }
}

class CarHead{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

class CarBody{
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

class Wheel{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

 　　抽象构建者(Builder)

public interface Builder {
    //构造车头
    void builderCarHead();
    //构造车身
    void builderCarBody();
    //构造轮子
    void builderWheel();
    //得到构建成品
    Car getCar();
}

　　实际构造者(CarBuilder)

public class CarBuilder implements Builder{
    Car car=new Car();

    @Override
    public void builderCarHead() {
        System.out.println("构建车头！");
        car.setCarHead(new CarHead());
    }

    @Override
    public void builderCarBody() {
        System.out.println("构建车身！");
        car.setCarBody(new CarBody());
    }

    @Override
    public void builderWheel() {
        System.out.println("构建轮子！");
        car.setWheel(new Wheel());
    }
    
    public Car getCar(){
        return this.car;
    }
}

　　控制者(Director)

public class Director {
    private Builder builder;
    
    public Director(Builder builder) {
        System.out.println("控制车组装");
        this.builder=builder;
        builder.builderCarHead();
        builder.builderCarBody();
        builder.builderWheel();
    }
}

　　客户端(Client)

public class Client {
    public static void main(String[] args) {
        //制造零件
        Builder builder=new CarBuilder();
        //组装汽车
        Director director=new Director(builder);
        //获得制造结果
        Car car=builder.getCar();
        //汽车开始跑
        car.run();
    }
}

　　构建者模式与工厂模式极为相似，建议还是用应用场景去记。而构建者模式相比于工厂模式它多了一个组装过程，而它的应用场景主要是用于构造一个复杂的对象，而工厂模式主要是专注于生产产品或者生产产品系列。当然，他们也可以结合，工厂模式专注于生产产品系列，而构建者模式专注于控制产品的构造流程，从而制造一个复杂的对象。对于设计模式不要拘泥于文字，主要是一种思想在我们运用的时候信手拈来。

版权声明

　　作者：邱勇Aaron

　　出处：http://www.cnblogs.com/qiuyong/

　　您的支持是对博主深入思考总结的最大鼓励。

　　本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，尊重作者的劳动成果。