设计模式之建造者模式

一、建造者模式
1.建造者模式定义：讲一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2.建造者模式UML

3.建造者模式示例

import java.util.ArrayList;
import java.util.List;

/**
 *  产品类
 * @author shier
 *
 */
class Product{
    List<String> parts = new ArrayList<String>();

    public void add(String part){
        parts.add(part);
    }

    public void show(){
        System.out.println("\n产品 创建 ----");
        for(String part : parts){
            System.out.print(" "+part);
        }
    }
}

/**
 * 抽象建造者类，提供创建产品1，产品2，和获取创建产品的方法
 * 建造者模式是在当创建复杂对象时候使用
 * @author shier
 *
 */
abstract class Builder{
    public abstract void BuildPartA();
    public abstract void BuildPartB();

    public abstract Product getResult();
}

/**
 * 具体建造者类
 * @author shier
 *
 */
class ConcreteBuilder extends Builder{
    private Product product = new Product();
    @Override
    public void BuildPartA() {
        product.add("部件A");

    }

    @Override
    public void BuildPartB() {
        product.add("部件B");

    }

    @Override
    public Product getResult() {
        return product;
    }

}

/**
 * 具体建造者类
 * @author shier
 *
 */
class ConcreteBuilder2 extends Builder{
    private Product product = new Product();
    @Override
    public void BuildPartA() {
        product.add("部件X");

    }

    @Override
    public void BuildPartB() {
        product.add("部件Y");

    }

    @Override
    public Product getResult() {
        return product;
    }

}

/**
 * 指挥者类，提供创建产品的共同方法
 * @author shier
 *
 */
public class Director {

    public void Construct(Builder builder){
        builder.BuildPartA();
        builder.BuildPartB();
    }

    public static void main(String[] args) {
        Director d = new Director();
        Builder b1 = new ConcreteBuilder();
        Builder b2 = new ConcreteBuilder2();

        d.Construct(b1);
        Product p1 = b1.getResult();
        p1.show();

        d.Construct(b2);
        Product p2 = b2.getResult();
        p2.show();

    }
}

/**
 * 营养成分标签
 * @author shier
 * effective java中的一个示例
 * 如果类的构造器或者静态工厂中具有多个参数，设计这种类时，builder模式是种不错的选择，特别当大多数
 * 参数都是可选的时候，与使用传统的重叠构造器模式相比，使用builder模式，客户端代码更好读，也比javabean
 * 模式更加安全（当构造参数大于4个的时候，可以使用）
 */
public class NutritionFacts {
    private final int servingSize;//建议含量

    private final int servings;//内含量

    private final int calories;//卡路里

    private final int fat;//脂肪

    private final int sodium;//钠含量

    private final int carbohydrate;//碳水化合物

    public static class Builder{
        /**
         * 必须要的
         */
        private final int servingSize;//建议含量

        private final int servings;//内含量

        /**
         * 可以选择的
         */

        private int calories = 0;//卡路里

        private int fat = 0;//脂肪

        private int sodium = 0;//钠含量

        private int carbohydrate = 0;//碳水化合物

        public Builder(int servingSize,int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val){
            calories = val;
            return this;
        }

        public Builder fat(int val){
            fat = val;
            return this;
        }

        public Builder sodium(int val){
            sodium = val;
            return this;
        }

        public Builder carbohydrate(int val){
            carbohydrate = val;
            return this;
        }

        public NutritionFacts build(){
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder){
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }

    @Override
    public String toString() {
        return "servingSize : "+servingSize+",servings:"+servings+",calories : "
                +calories+", fat : "+fat+",sodium : "+sodium+",carbohydrate : "+carbohydrate;
    }
}