理解23种设计模式-创建模式-建造者模式

首先介绍一下建造者模式
指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

相当于你买配台式机箱，需要各种零件，这些零件需要你自己去购买，购买成功以后，把这些零件交给专业的人员来帮你组装，这个机箱就是产品，这个产品也是很复杂的

优点
1.封装性好，构建和表示分离。
2.扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
3.客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点
1.产品的组成部分必须相同，这限制了其使用范围。
2.如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

建造者模式的实现
结构
产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口
具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

建造者模式的应用场景
时隔三日如隔春秋，张老板的生意靠张师傅的炒鸡蛋是越来越好，张师傅也是成了远近闻名的“蛋王”，张老板决定给他找个改刀的，帮助张师傅做的更快，让张师傅更方便简单的完成一盘炒鸡蛋！

产品角色：在我们的例子里就是炒鸡蛋！他需要各种食材，我们往复杂一点想，把他当做大工程，需要改刀小弟准备好这些食材
抽象建造者：改刀小弟具体是哪个也不知道
具体建造者：这里是刚来应聘的小李，负责准备食材
指挥者：蛋王张师傅，负责添加食材烹饪出绝品炒鸡蛋

//食材
abstract class Ingredient {
    private String weight;
    protected String name;


    public String getWeight() {
        return weight;
    }

    public void setWeight(String weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return name+weight;
    }
}

class Egg extends Ingredient {
    {
        name="鸡蛋";
    }
}

class Salt extends Ingredient {
    {
        name="盐";
    }
}

class Oil extends Ingredient {
    {
        name="豆油";
    }
}

//产品角色
class Fry_egg {
//有很多食材
   private List<Ingredient> fry_eggList = new ArrayList<>();

    public List<Ingredient> getFry_eggList() {
        return fry_eggList;
    }

    public void show() {
        System.out.println("食材展示");
        for (Ingredient ingredient : fry_eggList) {
            System.out.print(ingredient+"\t");
        }
    }
}

//改刀的人
abstract class Chef {
    Fry_egg fry_egg;

    public abstract Ingredient ready_egg();

    public abstract Ingredient ready_salt();

    public abstract Ingredient ready_Oil();


}
//小李
class LiSer extends Chef {
    @Override
    public Ingredient ready_egg() {
        Egg egg = new Egg();
        egg.setWeight("五个");
        return egg;
    }

    @Override
    public Ingredient ready_salt() {
        Salt salt = new Salt();
        salt.setWeight("半勺");
        return salt;
    }

    @Override
    public Ingredient ready_Oil() {
        Oil oil = new Oil();
        oil.setWeight("一滴哒");
        return oil;
    }
}
//张大厨
class Cook1 {
    Chef chef;

    public Cook1(Chef chef) {
        this.chef = chef;
    }

    public Fry_egg cooking() throws InterruptedException {
        Fry_egg fry_egg = new Fry_egg();
        List<Ingredient> fry_eggList = fry_egg.getFry_eggList();
        System.out.println("放入豆油");
        fry_eggList.add(chef.ready_Oil());
        System.out.println("放入鸡蛋");
        fry_eggList.add(chef.ready_egg());
        System.out.println("放半勺盐");
        fry_eggList.add(chef.ready_salt());
        Thread.sleep(1000*2);
        System.out.println("出锅");
        return fry_egg;
    }
}
public class BuilderPattern {
    public static void main(String[] args) {
        LiSer liSer = new LiSer();
        Cook1 cook1 = new Cook1(liSer);
        Fry_egg cooking = null;
        try {
            cooking = cook1.cooking();
        } catch (InterruptedException e) {
            System.out.println("炒糊了");
            e.printStackTrace();
        }
        cooking.show();
    }
}

输出结果

放入豆油
放入鸡蛋
放半勺盐
出锅
食材展示
豆油一滴哒 鸡蛋五个 盐半勺

小结：
Builder模式是为了创建一个复杂的对象，需要多个步骤完成创建，或者需要多个零件组装的场景，且创建过程中可以灵活调用不同的步骤或组件。