【设计模式】（八）--创建型模式--建造者模式

【设计模式】（八）–创建型模式–建造者模式

建造者模式定义

Separate the construction of a complex object from its representation so that the same construction process an create different representations.

意思就是：讲一个复杂对象的构建与它的表示分离，使得同样的构造过程可以创建不同的描述。
建造者一般有以下四个角色：

• 抽象构造者（Builder） 对于实际类的组成部分进行抽象，定义各种构造逻辑
• 具体构造者 实现抽象构造者的方法，能够返回一个构建好的实际类对象
• 实际类 一般都比较复杂，可能根据不同的构造参数及过程会有不同功能的对象
• 实际执行者 负责调用具体构造者方法的构造顺序，构造出实际需要的类对象

构造者模式的优点

• 封装性，构造者模式可以使使用者不必知道类具体实例化的细节
• 构造者具体事例过程与实际执行者无关，比较容易拓展
• 因为封装性，所以相关类不容易被其他模块入侵。

构造者模式的使用场景

• 需要生成的对象具有复杂的内部结构。
• 需要生成的对象内部属性本身相互依赖。
• 需要生成的对象需要创建实际过程要对外隔离。
• 需要生成的对象方法相同但参数不同，构建方法顺序不同，实例化的对象功能不同时。

构造者模式和工厂模式区别

	工厂模式	构造者模式
关注点	构造出实际类对象	构造方式类型、构建顺序 等不同产生的类的实例对象不同，着重过程

构造者模式简单实现

类图

实现

public class Bread {
    private String breadType;

    public String getBreadType() {
        return breadType;
    }

    public void setBreadType(String breadType) {
        this.breadType = breadType;
    }
}

public class Sandwich {
    private String sandwich;

    private int count;

    public String getSandwich() {
        return sandwich;
    }

    public void setSandwich(String sandwich) {
        this.sandwich = sandwich;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

public class Sauce {
    private String sauce;

    public String getSauce() {
        return sauce;
    }

    public void setSauce(String sauce) {
        this.sauce = sauce;
    }
}

public class Hamburger {
    private Bread bread;

    private Sauce sauce;

    private Sandwich sandwich;

    public Bread getBread() {
        return bread;
    }

    public void setBread(Bread bread) {
        this.bread = bread;
    }

    public Sauce getSauce() {
        return sauce;
    }

    public void setSauce(Sauce sauce) {
        this.sauce = sauce;
    }

    public Sandwich getSandwich() {
        return sandwich;
    }

    public void setSandwich(Sandwich sandwich) {
        this.sandwich = sandwich;
    }
}

public interface HamburgerBuilder {

    void buildBread(String bread);

    void buildSandwich(String sandwich, int count);

    void buildSauce(String sauce);

    Hamburger build();
}

public class HamburgerBuilderImpl implements HamburgerBuilder {

    private Hamburger hamburger = new Hamburger();

    @Override
    public void buildBread(String breadType) {
        Bread bread = new Bread();
        bread.setBreadType(breadType);
        hamburger.setBread(bread);
    }

    @Override
    public void buildSandwich(String sandwichName, int count) {
        Sandwich sandwich = new Sandwich();
        sandwich.setSandwich(sandwichName);
        sandwich.setCount(count);
        hamburger.setSandwich(sandwich);
    }

    @Override
    public void buildSauce(String sauceName) {
        Sauce sauce = new Sauce();
        sauce.setSauce(sauceName);
        hamburger.setSauce(sauce);
    }

    @Override
    public Hamburger build() {
        System.out.println("构建了一个："
                + hamburger.getSandwich().getCount() + "层" + hamburger.getSandwich().getSandwich()
                + hamburger.getSauce().getSauce()
                + hamburger.getBread().getBreadType()
                + "汉堡");
        return hamburger;
    }
}

public class Client {
    public static void main(String[] args) {
        HamburgerBuilder builder = new HamburgerBuilderImpl();
        builder.buildBread("燕麦");
        builder.buildSandwich("猪排", 2);
        builder.buildSauce("芝士");
        //此时就构建了一个双层猪排芝士汉堡
        Hamburger hamburger = builder.build();
    }
}

执行结果如下，此时一个双层猪排芝士燕麦汉堡就构建好了，只要出入不同的夹层如鸡排那就是鸡扒汉堡。