Java设计模式——建造者模式

一、引入

1.1、例子1.2、传统方法1.3、传统方式分析 二、建造者模式

2.1、基本介绍2.2、建造者模式的四个角色2.3、 使用建造者模式盖房

2.3.1、类图设计2.3.1、代码实现

建造不同的房子，例如高楼房、别墅、普通楼房。建造步骤是：打地基、垒墙、盖屋顶。 1.2、传统方法

房子的抽象类

public abstract class AbstractHouse {
    
    public abstract void buildbase();
    public abstract void buildWalls();
    public abstract void roofer();
    
    public void build() {
        buildbase();
        buildWalls();
        roofer();
    }
}

继承房子类，从而建造不同的房子

public class CommonHouse extends AbstractHouse{
    @Override
    public void buildbase() {
        System.out.println("开始打地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("开始垒墙");
    }

    @Override
    public void roofer() {
        System.out.println("开始建屋顶");
    }
}

开始建房子

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

优点是简单好理解、容易操作。设计的结构过于简单，没有设计缓存层对象，程序的扩展性和可维护性不好。也就是说，这种方式没有将房子对象和建造房子的过程进行分离，使得程序的耦合性很高。 二、建造者模式 2.1、基本介绍

建造者模式：又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同属性的对象。建造者模式是一步一步创建一个复杂对象，他允许用户通过指定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。 2.2、建造者模式的四个角色

Prodect（产品对象）：一个具体的产品对象；Builder（抽象建造者）：创建一个Product对象的各个部件指定的接口。ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件。Director（指挥者）：构建一个使用Builder接口的对象。他主要用于创建一个复杂的对象，他主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。 2.3、 使用建造者模式盖房 2.3.1、类图设计

产品类

public class Home {
    private String base;
    private String walls;
    private String footer;

    public String getbase() {
        return base;
    }

    public void setbase(String base) {
        this.base = base;
    }

    public String getWalls() {
        return walls;
    }

    public void setWalls(String walls) {
        this.walls = walls;
    }

    public String getFooter() {
        return footer;
    }

    public void setFooter(String footer) {
        this.footer = footer;
    }

    @Override
    public String toString() {
        return "Home{" +
                "base='" + base + ''' +
                ", walls='" + walls + ''' +
                ", footer='" + footer + ''' +
                '}';
    }
}

抽象建造者

public abstract class AbstractBuilder {
    public Home home = new Home();

    public abstract void buildbase();
    public abstract void buildWalls();
    public abstract void footer();

    public Home build() {
        return this.home;
    }

}

具体建造者

public class CommonHome extends AbstractBuilder {

    @Override
    public void buildbase() {
        home.setbase("普通地基");
        System.out.println("地基5米");
    }

    @Override
    public void buildWalls() {
        home.setWalls("普通墙");
        System.out.println("红色墙");
    }

    @Override
    public void footer() {
        home.setFooter("普通屋顶");
        System.out.println("盖屋顶");
    }
}

指挥者

public class HomeDirector {
    AbstractBuilder ab;

    public HomeDirector(AbstractBuilder ab) {
        this.ab = ab;
    }

    public void setAb(AbstractBuilder ab) {
        this.ab = ab;
    }

    public Home builder() {
        ab.buildbase();
        ab.buildWalls();
        ab.footer();

        return ab.build();
    }
}

开始建造房屋

public class Client {
    public static void main(String[] args) {
        CommonHome commonHome = new CommonHome();

        HomeDirector director = new HomeDirector(commonHome);
        Home home = director.builder();
        System.out.println(home);
    }
}

如果，被建造的对象只有一种，那么则可以使用传统的方式替代建造者模式，那样做会更方便