设计模式--创造者模式

创造者模式

定义：属于创建者模式，它提供了创建对象的最佳方式。将一个复杂对象的创建与他的表示分离，使得同样的构建过程可以创建不同的表示。

主要作用：在用户不知道对象的创建过程和细节的情况下就可以直接创建复杂的对象。用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象。

例子：比如盖房子，先找一个建筑公司或工程承包商（指挥者），承包商指挥工人（具体建造者）过来造房子（产品）。

图示：

package com.offcn.designpattern.builderpattern;

public class BuilderPatternDemo {
    public static void main(String[] args) {
        //指挥
        Director director = new Director();
        //指挥具体的工人完成产品
        HouseProduct build = director.build(new Worker());
        System.out.println(build);
    }
}
//指挥者：核心，负责指挥构建一个工程，工程如何构建，由它决定
class Director{
    public HouseProduct build(Builder builder){
        builder.buildA();
        builder.buildB();
        builder.buildC();
        builder.buildD();
        return builder.getHouseProduct();
    }
}
//抽象的建造者
abstract class Builder{
    abstract void buildA();//地基
    abstract void buildB();//钢件工程
    abstract void buildC();//铺电线
    abstract void buildD();//粉刷

    abstract HouseProduct getHouseProduct();
}
//具体的建造者：工人
class Worker extends Builder{
    private HouseProduct houseProduct;
    public Worker(){
        houseProduct = new HouseProduct();
    }
    @Override
    void buildA() {
        houseProduct.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void buildB() {
        houseProduct.setBuildB("钢件工厂");
        System.out.println("钢件工厂");
    }

    @Override
    void buildC() {
        houseProduct.setBuildC("铺电线");
        System.out.println("铺电线");
    }

    @Override
    void buildD() {
        houseProduct.setBuildD("粉刷");
        System.out.println("粉刷");
    }

    @Override
    HouseProduct getHouseProduct() {
        return houseProduct;
    }
}
//产品，房子
class HouseProduct{
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "HouseProduct{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

输出：

分析：上面示例是创造者模式的常规用法，指挥者Director在Builder模式中具有很重要的作用，它用于指导具体构建者（worker）如何构建产品，控制调用先后次序，

　　　　并向调用者返回完整的产品类，但有些情况下需要简化系统结构，可以把Director和抽象创造者进行结合。

自定义创造者模式

定义：通过静态内部类方法实现零件无需装配构造，这种方式使用更加灵活，更符合定义，内部有复杂对象的默认实现，使用时可以根据用户需求自有定义更改内容，并且无需

　　　改变具体的构造方式就可以生产出不同复杂产品。

例子：麦当劳的套餐，服务员（具体建造者）可以随意搭配任意几种产品组成一款套餐（产品），然后出售给客户，比第一种方式少了指挥者，主要是因为第二种方式把指挥者

　　　交给用户来操作，使产品的创建更加简单灵活。

图示：

package com.offcn.designpattern.builderpattern;

public class BuilderPatternDemo2 {
    public static void main(String[] args) {
        //具体创造者，服务员
        FoodWork foodWork = new FoodWork();
        //默认
        FoodProduct foodProduct = foodWork.getFoodProduct();
        System.out.println(foodProduct);
        //自定义,链式编程
        FoodProduct foodProduct1 = foodWork.buildA("全家桶").buildB("大杯雪碧").buildC("牛奶").buildD("披萨").getFoodProduct();
        System.out.println(foodProduct1);



    }
}
//创造者
abstract class Builder2{
    abstract Builder2 buildA(String msg);//汉堡
    abstract Builder2 buildB(String msg);//可乐
    abstract Builder2 buildC(String msg);//薯条
    abstract Builder2 buildD(String msg);//牛奶
    abstract FoodProduct getFoodProduct();
}
//具体创造者
class FoodWork extends Builder2{
    private FoodProduct foodProduct;
    public FoodWork(){
        foodProduct = new FoodProduct();
    }
    @Override
    Builder2 buildA(String msg) {
        foodProduct.setBuildA(msg);
        return this;
    }

    @Override
    Builder2 buildB(String msg) {
        foodProduct.setBuildB(msg);
        return this;
    }

    @Override
    Builder2 buildC(String msg) {
        foodProduct.setBuildC(msg);
        return this;
    }

    @Override
    Builder2 buildD(String msg) {
        foodProduct.setBuildD(msg);
        return this;
    }

    @Override
    FoodProduct getFoodProduct() {
        return foodProduct;
    }
}
//产品
class FoodProduct{
    private String BuildA = "汉堡";
    private String BuildB = "可乐";
    private String BuildC = "薯条";
    private String BuildD = "牛奶";

    public void setBuildA(String buildA) {
        BuildA = buildA;
    }

    public void setBuildB(String buildB) {
        BuildB = buildB;
    }

    public void setBuildC(String buildC) {
        BuildC = buildC;
    }

    public void setBuildD(String buildD) {
        BuildD = buildD;
    }

    public String getBuildA() {
        return BuildA;
    }

    public String getBuildB() {
        return BuildB;
    }

    public String getBuildC() {
        return BuildC;
    }

    public String getBuildD() {
        return BuildD;
    }

    @Override
    public String toString() {
        return "FoodProduct{" +
                "BuildA='" + BuildA + '\'' +
                ", BuildB='" + BuildB + '\'' +
                ", BuildC='" + BuildC + '\'' +
                ", BuildD='" + BuildD + '\'' +
                '}';
    }
}

输出：

应用场景：

1）需要生成的对象具有复杂的内部结构

2）需要生成的对象内部属性本身相互依赖

3）与不可变对象配合使用

优点：

1）产品的建造和表示分离，实现了解耦，使用建造者模式可以使客户端不必知道产品内部组成的细节。

2）将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰

3）具体的创建者类之间相互独立，有利系统的扩展，增加新的具体创造者无需修改原有类库的代码，符合开闭原则

缺点：

1）建造者模式所创建的产品一般具有较多的共同点，适用范围受到限制

2）如果产品内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统庞大

设计模式--创造者模式

猜你喜欢