设计模式之建造者模式

Builder(建造者模式)

一、建造者模式简介

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

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

注意：

• 1、一些基本部件不会变，而其组合经常变化的时候。
• 2、建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
• 3、肯德基组合套餐、StringBuilder
• 4、核心作用：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示

二、建造者模式优缺点比较

优点：

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

缺点：

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

使用场景：

• 1、StringBuilder类的append方法
• 2、SQL中的PreparedStatement
• 3、JDOM中，DomBuilder、SAXBuilder

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

三、实现UML类图

 

四、实现

   步骤1：创建复杂产品的实体类

public class McDonaldMeal {
    
    private Bacon bacon;
    
    private Chicken chicken;
    
    private CoCoCoLe coco;

    public Bacon getBacon() {
        return bacon;
    }

    public void setBacon(Bacon bacon) {
        this.bacon = bacon;
    }

    public Chicken getChicken() {
        return chicken;
    }

    public void setChicken(Chicken chicken) {
        this.chicken = chicken;
    }

    public CoCoCoLe getCoco() {
        return coco;
    }

    public void setCoco(CoCoCoLe coco) {
        this.coco = coco;
    }

    @Override
    public String toString() {
        return "McDonaldMeal [bacon=" + bacon + ", chicken=" + chicken + ", coco=" + coco + "]";
    }
    
}

 步骤2：创建复杂简单产品的实体类

class  Bacon{
    private String name;

    public Bacon(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Bacon [name=" + name + "]";
    }
    
}

class  Chicken{
    private String name;
    
    private Integer count;

    public Chicken(String name, Integer count) {
        this.name = name;
        this.count = count;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getCount() {
        return count;
    }

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

    @Override
    public String toString() {
        return "Chicken [name=" + name + ", count=" + count + "]";
    }
    
}


class  CoCoCoLe{
    private String size;
    
    private String warm;

    public CoCoCoLe(String size, String warm) {
        super();
        this.size = size;
        this.warm = warm;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }

    public String getWarm() {
        return warm;
    }

    public void setWarm(String warm) {
        this.warm = warm;
    }

    @Override
    public String toString() {
        return "CoCoCoLe [size=" + size + ", warm=" + warm + "]";
    }
    
}

 步骤3：创建MealBuilder接口

public interface MealBuilder {
    
    MealBuilder produceBacon(String name);
    MealBuilder produceChicken(String name,Integer count);
    MealBuilder produceCoCoCoLe(String size,String warm);
    McDonaldMeal build();

}

步骤4：创建MealBuilder接口实现类

public class DiscountMealBuilder implements MealBuilder {
    McDonaldMeal meal = new McDonaldMeal();

    @Override
    public MealBuilder produceBacon(String name) {
        Bacon bacon = new Bacon(name);
        meal.setBacon(bacon);
        return this;
    }

    @Override
    public MealBuilder produceChicken(String name, Integer count) {
        Chicken chicken = new Chicken(name, count);
        meal.setChicken(chicken);
        return this;
    }

    @Override
    public MealBuilder produceCoCoCoLe(String size, String warm) {
        CoCoCoLe coco = new CoCoCoLe(size, warm);
        meal.setCoco(coco);
        return this;
    }

    @Override
    public McDonaldMeal build() {
        return meal;
    }
    
}

 步骤5：调用者调用builder创建复杂对象

public class BuilderDemo01 {
    
    public static void main(String[] args) {

        MealBuilder builder = new DiscountMealBuilder();
        McDonaldMeal meal = builder.produceBacon("A").produceChicken("A", 2).build();
        System.out.println(meal.toString());
        meal = builder.produceBacon("A").produceChicken("B", 5).produceCoCoCoLe("C", "A").build();
        System.out.println(meal.toString());
    }

}

步骤6：运行程序，观察结果

McDonaldMeal [bacon=Bacon [name=A], chicken=Chicken [name=A, count=2], coco=null]
McDonaldMeal [bacon=Bacon [name=A], chicken=Chicken [name=B, count=5], coco=CoCoCoLe [size=C, warm=A]]

 

来源：https://www.cnblogs.com/vincentYw/p/12584317.html