23种设计模式之创建型模式：建造者模式

一：什么是建造者模式？

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

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

二：进一步了解建造者模式

目的：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，Boss：管理建造出来的实例的依赖关系。

优点：
1、建造者独立，易扩展。
2、便于控制细节风险。

缺点：
1、产品必须有共同点，范围有限制。
2、如内部变化复杂，会有很多的建造类。

使用场景：
1、需要生成的对象具有复杂的内部结构。
2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

三：实现

抽象产品类 Drinks

public abstract class Drinks {
    protected String Wash;
    protected String kinds;
    protected String assemble;

    public Drinks() {
    }

    public void setWash(String wash) {
        Wash = wash;
    }

    public abstract void setKinds();

    public void setAssemble(String assemble) {
        this.assemble = assemble;
    }

    @Override
    public String toString() {
        return "Drinks{" +
                "Wash='" + Wash + '\'' +
                ", kinds='" + kinds + '\'' +
                ", assemble='" + assemble + '\'' +
                '}';
    }
}

具体产品 雪碧

//具体产品 雪碧
public class Sprite extends Drinks {
    public Sprite() {
    }

    @Override
    public void setKinds() {
        kinds = "雪碧，透心凉，心飞扬";
    }
}

抽象Builder

public abstract class Builder {
    abstract void buildWash(String wash);
    abstract void buildKinds();
    abstract void buildAssemble(String assemble);

    abstract Drinks build();
}

具体的builder

//具体的builder
public class SpriteBuild extends Builder {
    private Drinks sprite= new Sprite();
    @Override
    void buildWash(String wash) {
        sprite.setWash(wash);
    }

    @Override
    void buildKinds() {
        sprite.setKinds();
    }

    @Override
    void buildAssemble(String assemble) {
        sprite.setAssemble(assemble);
    }

    @Override
    Drinks build() {
        return sprite;
    }
}

Director类，负责具体的构造 Drinks

//Director类，负责具体的构造 Drinks
public class Director {
    Builder builder = null;

    public Director(Builder builder){
        this.builder = builder;
    }
    public void command(String wash,String assemble){
        builder.buildWash(wash);
        builder.buildKinds();
        builder.buildAssemble(assemble);
    }
}

测试

//测试
public class BuilderTest {
    public static void main(String[] args) {
        // 一个雪碧建造者
        Builder builder = new SpriteBuild();
        // 一个boss 指挥 建造者
        Director boss = new Director(builder);
        // boss 根据需求 要求建造者 如何清洗和装配（默认饮料是雪碧）
        boss.command("用洗洁精水洗瓶子","用机器打包封装");
        // 老板下达命令后 建造者就可以开始生产了
        Drinks drinks = builder.build();
        System.out.println(drinks);

        //由于今年行情不好 洗瓶子节省一点，改用自来水清洗
        boss.command("用自来水清洗瓶子","用机器打包封装");
        // 老板下达命令后 建造者就可以开始生产了
        drinks = builder.build();
        System.out.println(drinks);
    }
}

结果：

代码的分析流程详解