Java之设计模式:建造者模式

案例

    先看一个具体的案例：此时我们需要建一栋房子，建房子的过程有打桩、砌墙、封顶；房子的样式有各种各样的，比如普通房，高楼，别墅，各种房子的过程虽然一样，但是要求不要相同的。要求编写代码完成盖房的项目：

传统的方法

    传统方法是构造一个房子的抽象类，然后把建房子的打桩、砌墙、封顶过程作为方法写在类中，然后形容各种房子的类(高楼类、普通楼类、别墅楼类等等)来继承这个抽象类，并实现抽象方法：

    代码实现：
    AbstractHouse类：

package builder;

public abstract class AbstractHouse {

    // 打地基
    public abstract void buildBase();
    // 砌墙
    public abstract void buildWalls();
    // 封顶
    public abstract void roofed ();

    public void build(){
        buildBase();
        buildWalls();
        roofed();
    }
}

    CommonHouse类：

package builder;

public class CommonHouse extends AbstractHouse {
    @Override
    public void buildBase() {
        System.out.println("给普通楼打地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("给普通楼砌墙");
    }

    @Override
    public void roofed() {
        System.out.println("给普通楼封顶");
    }
}

    Client类:

package builder;

public class Client {
    public static void main(String[] args) {
        CommonHouse commonHouse = new CommonHouse();
        commonHouse.build();
    }
}

    结果：

    存在的问题：
    没有设计缓存层对象，程序的扩展性和易维护性较差.。也就是说，这种设计方案，把产品(即：房子)和创建产品的过程(即：建房子流程) 封装在一起，耦合性增强了。
    解决方案：将产品和产品建造过程解耦，也就使用到建造者模式。

建造者模式

基本介绍

1. 建造者模式（Builder Pattern） 又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
2. 建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

建造者模式中的四个角色

1. Product(产品角色)： 一个具体的产品对象。
2. Builder(抽象建造者)： 创建一个Product对象的各个部件指定的 接口/抽象类。
3. ConcreteBuilder(具体建造者)： 实现接口，构建和装配各个部件。
4. Director(指挥者)： 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。
   

案例改进

    下面就按照上图的建造者模式中的四个角色来改进案例：
    首先是产品Product：

package builder.improve;

// 产品 ——> Product
public class House {
    private String baise;
    private String wall;
    private String roofed;

    public String getBaise() {
        return baise;
    }

    public void setBaise(String baise) {
        this.baise = baise;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
}

    然后是抽象的建造者HouseBuilder，规定好造房子有哪些流程并返回造好的房子：

package builder.improve;

// 抽象的建造者
public abstract class HouseBuilder {
    protected House house = new House();

    // 将造房子的流程写好
    public abstract void buildBase();
    public abstract void buildWalls();
    public abstract void roofed ();

    // 房子造好，将房子返回
    public House buildHouse(){
        return house;
    }
}

    然后是实现它的两种楼CommonHouse和HighHouse：

package builder.improve;

public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBase() {
        System.out.println("普通房子打地基5米");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙10厘米");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子屋顶");
    }
}

package builder.improve;

public class HighHouse extends HouseBuilder {
    @Override
    public void buildBase() {
        System.out.println("高层房子打地基10米");
    }

    @Override
    public void buildWalls() {
        System.out.println("高层房子砌墙30厘米");
    }

    @Override
    public void roofed() {
        System.out.println("高层房子透明屋顶");
    }
}

    最后是指挥官HouseDirector，指定建造房子的流程：

package builder.improve;

// 指挥官，指定制作流程
public class HouseDirector {
    HouseBuilder houseBuilder = null;
    // 构造器传入 houseBuilder
    public HouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder = houseBuilder;
    }
    // setter传入 houseBuilder
    public void setHouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder = houseBuilder;
    }
    // 造房子的流程，交给指挥官
    public House constructHouse() {
        houseBuilder.buildBase();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

    写一个Client来测试一下：

package builder.improve;


public class Client {
    public static void main(String[] args) {
        // 盖普通房子
        CommonHouse commonHouse = new CommonHouse();
        // 盖高楼房子
        HighHouse highHouse = new HighHouse();
        // new创建房子的指挥官
        HouseDirector houseDirector1 = new HouseDirector(commonHouse);
        HouseDirector houseDirector2 = new HouseDirector(highHouse);
        // 完成盖房子，返回产品(房子)
        House house1 = houseDirector1.constructHouse();
        House house2 = houseDirector2.constructHouse();
    }
}

    结果：