设计模式之建造者模式

 

背景：需要建造一个房子，建造的房子过程有打地基、砌墙、封顶。建造的类型有普通的房子、高楼。

思路：需要有一个抽象类，里面有建造房子过程的三个方法，然后具体类继承这个抽象类。

关系图如下：

 

 代码实现如下：

AbstractHouse.java

public abstract class AbstractHouse {
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();
    public AbstractHouse(){
        buildBasic();
        buildWalls();
        roofed();
    }
}

CommonHouse.java

public class CommonHouse extends AbstractHouse{
    @Override
    public void buildBasic() {
        System.out.println("CommonHouse 建造地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("CommonHouse 建造墙");
    }

    @Override
    public void roofed() {
        System.out.println("CommonHouse 建造房顶");
    }
}

Client:

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

 

优点：代码十分好理解，简单实现。

缺点：这种做法把产品(即房子)和创建产品的过程(建房子流程)封装在一起，耦合性随之增强。

 

引入建造者模式，把创建的对象和创建的过程分离。

建造者模式的四个角色：

Product: 一个具体的产品对象

Builder:创建一个Product对象的各个部件指定的接口。

ConcreteBuilder:实现接口，构建和装配各个部件。

Director:构建一个使用builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程。二是：负责控制产品对象的生产过程。

 

类图：

 

House.java (产品)

public class House {
    private String basic;
    private String wall;
    private String roof;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

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

    public String getRoof() {
        return roof;
    }

    public void setRoof(String roof) {
        this.roof = roof;
    }
}

 

 HouseBuilder.java (聚合一个House，把建造过程抽象出来)

public abstract class HouseBuilder {
    protected House house = new House();
    public abstract void buildBasic();
    public abstract void buildWall();
    public abstract void buildRoof();
    public  House buildHouse(){
        return house;
    }
}

 

CommonHouse.java (实现houseBuilder中抽象方法)

public class CommonHouse extends HouseBuilder{

    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基");
    }

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

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

 

HouseDirector.java (聚合一个具体的builder，进行创建房子)

public class HouseDirector {
    HouseBuilder houseBuilder = null;
    public HouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder = houseBuilder;
    }
    public House constructHouse(){
        houseBuilder.buildBasic();
        houseBuilder.buildWall();
        houseBuilder.buildRoof();
        return houseBuilder.buildHouse();
    }
}

 

Client.java

public class Client {
    public static void main(String[] args) {
        CommonHouse commonHouse = new CommonHouse();
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        House house = houseDirector.constructHouse();
    }
}

 

output:

普通房子打地基
普通房子砌墙
普通房子盖屋顶

 

建造者模式适用场景：建造者模式所创建的产品一般具有较多的共同点其组成部分相似，如果产品之间的差异很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。