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

作者: 132xin | 来源:发表于2020-03-12 00:00 被阅读0次

设计模式
Android中涉及的模式
Java设计模式教程
java建造者模式
java单例模式
java外观模式
java适配器模式
java观察者模式
java代理模式
java策略模式

1.定义

建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。这种类型设计模式属于创建型模式，它提供了一种创建对象的最佳方式。一个Builder类会一步一步构造最终的对象。

2.介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程创建不同的表示。
主要解决：主要解决在软件系统中，有时面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成。
何时使用：一些基本部件不会变，而其组合经常变化的时候。
如何解决：将变与不变分离开。
关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
注意事项：与工厂模式的区别是：建造者模式更加关注与零件转配的顺序。

3.优缺点

建造者独立，易扩展，便于控制细节风险。
缺点：产品必须有共同点，范围有限制，如内部变化负责，会有很多的建造类。

4.使用场景

1.需要生成的对象具有复杂的内部结构。2.需要生成的对象的内部属性本身相互依赖。

5.建造实现的两种方式

(1)通过Client、Director、Builder和Product形式的建造者模式（比较常见）

抽象建造者（builder）：描述具体建造者的公共接口，一般用来定义建造细节的方法，并不涉及具体的对象部件的创建。
具体构建者（ConcreteBuilder）:描述具体构建者，并实现抽象建造者公共接口。
指挥者（Director）：调用具体建造者来创建复杂对象（产品）的各个部分，并按照一定顺序来建造复杂对象。
产品（Product）：描述一个由一系列部件组成较为复杂的对象。

6.方式一的实现例子：

既然是建造者模式，那么我们还是继续造房吧，其实我也想不到更简单的例子。假设造房简化为如下步骤：（1）地基（2）钢筋工程（3）铺电线（4）粉刷
“如果”要盖一座房子，首先要找一个建筑公司或工程承包商（指挥者）。承包商指挥工人（具体建造者）过来造房子（产品），最后验收。
具体步骤：

1.创建抽象建造者定义造房步骤。
2.创建工人具体实现造房步骤。
3.创建承包商指挥工人施工。
4.验收、检查是否建造完成。

代码：

public class BuilderPattern {
    public static void main(String[] args) {
        
        Director dirctor=new Director();
        Product  product=dirctor.creat(new ConcreteBuilder());
        System.out.println(product.toString());
        
    }

}
/**
 * @author xin
 *建造者
 */
abstract class Builder{ 
    //地基
    abstract void buildFoundation();
    //钢筋工程
    abstract void buildSteelBar();
    //电线
    abstract void buildWire();
    //粉刷
    abstract void buildPainting();
    //产品
    abstract Product build();
}

/**
 * @author xin
 *产品
 */
class Product{
    private String buildFoundation;
    private String buildSteelBar;
    private String buildWire;
    private String buildPainting;
    @Override
    public String toString() {
        
        return buildFoundation+","+buildSteelBar+","+buildWire+","+buildPainting+"房子已完成";
    }
    public String getBuildFoundation() {
        return buildFoundation;
    }
    public String getBuildSteelBar() {
        return buildSteelBar;
    }
    public String getBuildWire() {
        return buildWire;
    }
    public String getBuildPainting() {
        return buildPainting;
    }
    public void setBuildFoundation(String buildFoundation) {
        this.buildFoundation = buildFoundation;
    }
    public void setBuildSteelBar(String buildSteelBar) {
        this.buildSteelBar = buildSteelBar;
    }
    public void setBuildWire(String buildWire) {
        this.buildWire = buildWire;
    }
    public void setBuildPainting(String buildPainting) {
        this.buildPainting = buildPainting;
    }
    
}
/**
 * @author xin
 *具体的建造者，实现抽象类
 */
class ConcreteBuilder extends Builder{
    private Product product;
    public ConcreteBuilder(){
        product=new Product();
    }
    @Override
    void buildFoundation() {
        product.setBuildFoundation("地基");
    }

    @Override
    void buildSteelBar() {
        product.setBuildSteelBar("钢筋");
    }

    @Override
    void buildWire() {
        product.setBuildWire("电线");
    }

    @Override
    void buildPainting() {
        product.setBuildPainting("刷墙");
    }

    @Override
    Product build() {
        //返回产品
        return product;
    }
    
}

/**
 * @author xin
 *指挥者
 */
class Director{
    //按顺序建房
    public Product creat(Builder builder) {
        builder.buildFoundation();
        builder.buildSteelBar();
        builder.buildWire();
        builder.buildPainting();
        return builder.build();
        
    }
    
}

7.方式二实现例子

通过内部类方式实现零件无序装配构造。这种方式使用更加灵活，更符合定义。内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体的构造方式，这样就可以生产出不同复杂产品。
主要有是哪个角色：抽象建造者，具体建造者，产品。

例子：如麦当劳的套餐，服务员（具体建造者）可以随意搭配任意几种产品组成一款套餐产品，然后出售给客户。

步骤：
1.创建建造者定义麦当劳的产品
2.创建服务员实现具体产品
3.服务员随意搭配套餐出售给客户。

代码：

public class BuilderPatternStaticClass {

    public static void main(String[] args) {
        Product product=new ConcreteBuilder().bulidA("汉堡")
                .bulidB("可乐").bulidC("冰淇淋").bulidD("鸡翅").build();
        System.out.println("第一位顾客的套餐"+product.toString());
        Product product1=new ConcreteBuilder().bulidA("米饭")
                .bulidB("雪碧").build();
        System.out.println("第二位顾客的套餐"+product1.toString());
    }

}
/*Builder.java
*建造者
*/
abstract class Builder{
    //主食
    abstract Builder bulidA(String mes);
    //饮料
    abstract Builder bulidB(String mes);
    //甜品
    abstract Builder bulidC(String mes);
    //小吃
    abstract Builder bulidD(String mes);
    //获取套餐
    abstract Product build();
}
class Product{
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;
    public String getBuildA() {
        return buildA;
    }
    public String getBuildB() {
        return buildB;
    }
    public String getBuildC() {
        return buildC;
    }
    public String getBuildD() {
        return buildD;
    }
    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }
    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }
    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }
    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }
    @Override
    public String toString() {
        
        return "套餐："+buildA+","+buildB+","+buildC+","+buildD;
    }
    
}
class ConcreteBuilder extends Builder{
    private Product product;
    
    public ConcreteBuilder() {
        super();
        product =new Product();
        
    }

    @Override
    Builder bulidA(String mes) {
        product.setBuildA(mes);
        return this;
    }

    @Override
    Builder bulidB(String mes) {
        product.setBuildB(mes);
        return this;
    }

    @Override
    Builder bulidC(String mes) {
        product.setBuildC(mes);
        return this;
    }

    @Override
    Builder bulidD(String mes) {
        product.setBuildD(mes);
        return this;
    }

    @Override
    Product build() {
        
        return product;
    }
    
}