建造者模式

学习建造者模式前，我们来实现一个汉堡的制作流程

汉堡制作的大致流程：
首先是加入两个面包片
加入肉饼
加入蔬菜
加热
打包

代码：

public class Builder1 {
    public static void main(String[] args) {
        Hamburger hamburger1 = new Hamburger("巨无霸", "吐司", "莴笋", "牛肉饼");
        hamburger1.setBread();
        hamburger1.setMeatPie();
        hamburger1.setVegetableLeaf();
        hamburger1.heating(10);
        hamburger1.pack();
    }
}

class Hamburger {
    private String name;//汉堡包名字
    private String bread;//面包片
    private String vegetableLeaf;//菜叶名
    private String meatPie;//肉饼名

    Hamburger(String name, String bread, String vegetableLeaf, String meatPie) {
        this.name = name;
        this.bread = bread;
        this.vegetableLeaf = vegetableLeaf;
        this.meatPie = meatPie;
    }

    void setBread() {
        System.out.println("加入面包片：" + this.bread);
    }

    void setVegetableLeaf() {
        System.out.println("向汉堡加入" + this.vegetableLeaf);
    }

    void setMeatPie() {
        System.out.println("向汉堡加入" + this.meatPie);
    }


    void heating(int minute) {
        System.out.println("汉堡加热时间" + minute + "分钟");
    }

    void pack() {
        System.out.println(this.name + "汉堡加工完成,打包！");
    }
}

运行的结果：

功能实现啦，看起来也像一个“面向对象”的程序，把汉堡抽象出来了，同时汉堡中封装他独有的方法和属性。
但是仔细看看客户端代码，我们在客户端新建了一个汉堡，然后对他进行了一系列的操作，最后完成了汉堡。

建造者模式就是将一些列操作封装起来的一种模式

但是出现了最大的问题：代码不可复用，每一次客户端需要汉堡的时候都需要加工一次
不可复用的结果就可能导致每一次加工出来的汉堡都不一样，不是流水化作业
比如工序的顺序颠倒了，比如多一个工序或者少一个工序，导致加工出来的汉堡都不是我们想要的汉堡，不是我们想要的对象。

让我们来看看建造者模式时怎么实现这段代码

public class Builder2 {
    public static void main(String[] args) {
        Hamburger1 hamburger1 = new KFCHamburger("鸡肉汉堡", "面包", "韭菜", "鸡肉饼");
        HamburgerBuilder hamburgerBuilder = new HamburgerBuilder(hamburger1);
        hamburgerBuilder.buildHamburger();
    }
}

abstract class Hamburger1 {
    String name;
    String bread;//面包片
    String vegetableLeaf;//菜叶名
    String meatPie;//肉饼名
    private int heatingTime;//加热时间

    Hamburger1(String name, String bread, String vegetableLeaf, String meatPie) {
        this.name = name;
        this.bread = bread;
        this.vegetableLeaf = vegetableLeaf;
        this.meatPie = meatPie;
        this.heatingTime = 0;
    }

    abstract void setBread();

    abstract void setVegetableLeaf();

    abstract void setMeatPie();

    abstract void heating(int minute);

    abstract void pack();
}

class KFCHamburger extends Hamburger1 {
    public KFCHamburger(String name, String bread, String vegetableLeaf, String meatPie) {
        super(name, bread, vegetableLeaf, meatPie);
    }

    @Override
    void setBread() {
        System.out.println("加入面包片：" + this.bread);
    }

    @Override
    void setVegetableLeaf() {
        System.out.println("向汉堡加入" + this.vegetableLeaf);
    }

    @Override
    void setMeatPie() {
        System.out.println("向汉堡加入" + this.meatPie);
    }

    @Override
    void heating(int minute) {
        System.out.println("汉堡加热时间" + minute + "分钟");
    }

    @Override
    void pack() {
        System.out.println(this.name + "汉堡加工完成,打包！");
    }
}

class HamburgerBuilder {
    private Hamburger1 hamburger1;

    HamburgerBuilder(Hamburger1 hamburger1) {
        this.hamburger1 = hamburger1;
    }

    Hamburger1 buildHamburger() {
        hamburger1.setBread();
        hamburger1.setMeatPie();
        hamburger1.setVegetableLeaf();
        hamburger1.heating(10);
        hamburger1.pack();
        return this.hamburger1;
    }
}

看完这段代码是不是觉得建造者模式也很厉害

UML图

建造者模式UML

product：我们需要的产品对象

Builder：对产品对象的加工方法

Director：封装生产对象的过程，返回一个加工好的对象。

（类似于工厂模式，将对象的生产过程封装起来，只返回一个立即可用的对象）

更正一下：应该把生成对象的方法抽象到建造类中，而不是放在对象之中，所以看起会和建造者UML的图看起来有点点不一样

我写的HamburgerBuilder其实对应的Director导演的位置，而建造者的方法我全部封装在Product中了。

有时间会修改我的代码的

分析下：
解决了代码不能复用的问题了 （可复用）
同时如果我们现在要把汉堡的的加热时间修改下，或者把肉片和蔬菜放置的顺序换一下。只需要到建造类中修改时间即可。
如果我们将代码写在客户端，那么维护起来就是种灾难！（可维护）
如果我们现在要加入一个巨无霸汉堡，他有三层肉片，2层蔬菜，加热20分钟怎么办呢
我们只需要到建造类中加入生产巨无霸汉堡的代码即可（可谓可扩展，灵活性高）

public static void main(String[] args) {
    Hamburger1 hamburger1 = new KFCHamburger("巨无霸", "面包", "韭菜", "鸡肉饼");
    HamburgerBuilder hamburgerBuilder = new HamburgerBuilder(hamburger1);
    hamburgerBuilder.buildBigBigBigHamburger();//修改建造的方法即可
}

Hamburger1 buildBigBigBigHamburger() {
    hamburger1.setBread();
    hamburger1.setMeatPie();//肉片1
    hamburger1.setVegetableLeaf();//蔬菜1
    hamburger1.setMeatPie();//肉片2
    hamburger1.setVegetableLeaf();//蔬菜2
    hamburger1.setMeatPie();//肉片3
    hamburger1.heating(20);
    hamburger1.pack();
    return this.hamburger1;
}

我们来看看结果吧

建造者面膜是和工厂模式同属于创建型模式（创建型模式：负责对象的创建）

什么场景下使用建造者模式

1.产品对象内部具有复杂的结构，产品对象包含多个成员属性，适用建造者模式可以隔离复杂对象的创建和适用，并使得相同的 创建过程可以创建不同的对象；
2.相同的方法，不同的执行顺序，产生不同的事件结果时；（汉堡的加工顺序）

简单来说，建造者模式就是一步步创建一个对象，它对用户屏蔽了里面构建的细节（顺序，调用次数...），但却可以精细地控制对象的构造过程。

代码地址：https://gitee.com/gang_bryant/DesignMode1