设计模式 - 建筑者模式

传统方式

抽象: 

public abstract class AbstractHouse {
	
	//打地基
	public abstract void buildBasic();
	//砌墙
	public abstract void buildWalls();
	//封顶
	public abstract void roofed();
	
	public void build() {
		buildBasic();
		buildWalls();
		roofed();
	}

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

实体:

public class CommonHouse extends AbstractHouse {

	@Override
	public void buildBasic() {
		// TODO Auto-generated method stub
		System.out.println(" 普通房子打地基 ");
	}

	@Override
	public void buildWalls() {
		// TODO Auto-generated method stub
		System.out.println(" 普通房子砌墙 ");
	}

	@Override
	public void roofed() {
		// TODO Auto-generated method stub
		System.out.println(" 普通房子封顶 ");
	}

}

优点:

是比较好理解，简单易操作

缺点:

设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展和维护不好. 也就 是说，这种设计方案，把产品(即：房子) 和 创建产品的过程(即：建房子流程) 封 装在一起，耦合性增强了。

建造者模式

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

定义产品:

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;
	}
}

抽象建造者:

public abstract class HouseBuilder {
    private House house = new House();

    // 将构造的流程写好，抽象的方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();

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

具体建造者一:

public class CommomHouse extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("盖普通房子地基");
    }

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

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

具体建造者二:

public class HighHouse extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("盖高房子地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("盖高房子墙");
    }

    @Override
    public void roofed() {
        System.out.println("盖高房子瓦");
    }
}

指挥者:

/**
 * 指挥者，这里去指定制作流程，返回产品
 */
public class HouseDirector {
    HouseBuilder builder = null;

    /**
     * 构造器传入 houseBuilder
     */
    public HouseDirector(HouseBuilder builder) {
        this.builder = builder;
    }

    /**
     * 通过 setter 传入 houseBuilder
     */
    public void setBuilder(HouseBuilder builder) {
        this.builder = builder;
    }

    // 如果处理建造房子的流程，交给指挥者
    public House builder(){
        builder.buildBasic();
        builder.buildWalls();
        builder.roofed();
        return builder.buildHouse();
    }

    public static void main(String[] args) {
        CommomHouse commomHouse = new CommomHouse();
        HouseDirector director = new HouseDirector(commomHouse);
        director.builder();

        HighHouse highHouse = new HighHouse();
        director.setBuilder(highHouse);
        director.builder();
    }
}

优缺点:

• 客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解 耦，使得相同的创建过程可以创建不同的产品对象
• 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替 换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同 的产品对象
• 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法 中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
• 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程， 系统扩展方便，符合 “开闭原则”
• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间 的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制