设计模式学习－建造者模式

1.定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2.类图

3.代码示例

package com.zhaoyangwoo.builder;

/**
 * Created by john on 16/5/7.
 * 场景类
 */
public class Builder {

    public static void Main(){
        BuilderInterface bi = new ConceptBuilder();
        Director director = new Director();
        director.construct(bi);
    }

}

/**
 * 导演类
 */
class Director {
    Product construct(BuilderInterface bi){
        bi.setProductPartA();
        bi.setProductPartB();
        return bi.getProduct();
    }
}

/**
 * 抽象建造者
 */
interface BuilderInterface{
    void setProductPartA();
    void setProductPartB();
    Product getProduct();
}

/**
 * 具体建造者
 */
class ConceptBuilder implements BuilderInterface{

    private Product product = new Product();

    @Override
    public void setProductPartA() {
        product.setName("产品A");
    }

    @Override
    public void setProductPartB() {
        product.setPrice(1.111);
    }

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


/**
 * 具体产品
 */
class Product{
    public String getName() {
        return name;
    }

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

    String name;

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    double price;
}

4.应用场景举例

• 创建更复杂对象，隔离对象创建的具体过程 

5.JDK源码中的模式实现

　　Calendar.Builder静态类就是典型的建造者模式，我们来看源码　　

public Calendar build() {
            if (locale == null) {
                locale = Locale.getDefault();
            }
            if (zone == null) {
                zone = TimeZone.getDefault();
            }
            Calendar cal;
            if (type == null) {
                type = locale.getUnicodeLocaleType("ca");
            }
            if (type == null) {
                if (locale.getCountry() == "TH"
                    && locale.getLanguage() == "th") {
                    type = "buddhist";
                } else {
                    type = "gregory";
                }
            }
            switch (type) {
            case "gregory":
                cal = new GregorianCalendar(zone, locale, true);
                break;
            case "iso8601":
                GregorianCalendar gcal = new GregorianCalendar(zone, locale, true);
                // make gcal a proleptic Gregorian
                gcal.setGregorianChange(new Date(Long.MIN_VALUE));
                // and week definition to be compatible with ISO 8601
                setWeekDefinition(MONDAY, 4);
                cal = gcal;
                break;
            case "buddhist":
                cal = new BuddhistCalendar(zone, locale);
                cal.clear();
                break;
            case "japanese":
                cal = new JapaneseImperialCalendar(zone, locale, true);
                break;
            default:
                throw new IllegalArgumentException("unknown calendar type: " + type);
            }
            cal.setLenient(lenient);
            if (firstDayOfWeek != 0) {
                cal.setFirstDayOfWeek(firstDayOfWeek);
                cal.setMinimalDaysInFirstWeek(minimalDaysInFirstWeek);
            }
            if (isInstantSet()) {
                cal.setTimeInMillis(instant);
                cal.complete();
                return cal;
            }

            if (fields != null) {
                boolean weekDate = isSet(WEEK_YEAR)
                                       && fields[WEEK_YEAR] > fields[YEAR];
                if (weekDate && !cal.isWeekDateSupported()) {
                    throw new IllegalArgumentException("week date is unsupported by " + type);
                }

                // Set the fields from the min stamp to the max stamp so that
                // the fields resolution works in the Calendar.
                for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
                    for (int index = 0; index <= maxFieldIndex; index++) {
                        if (fields[index] == stamp) {
                            cal.set(index, fields[NFIELDS + index]);
                            break;
                        }
                    }
                }

                if (weekDate) {
                    int weekOfYear = isSet(WEEK_OF_YEAR) ? fields[NFIELDS + WEEK_OF_YEAR] : 1;
                    int dayOfWeek = isSet(DAY_OF_WEEK)
                                    ? fields[NFIELDS + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
                    cal.setWeekDate(fields[NFIELDS + WEEK_YEAR], weekOfYear, dayOfWeek);
                }
                cal.complete();
            }

            return cal;
        }

　　另外StringBuilder也同样是建造者模式的典型应用

6.思考

• 建造者模式和工厂模式

　  两者非常相似，把握异同的关键点在于：建造者关注的是基本方法（零件）的组装顺序，所有基本操作都已经实现。而工厂模式关注的是零件的创建。
　　

　　　

• 建造者模式和模版方法模式

　　  1.这两个模式解决问题的类型不一样，建造者模式是创建对象，模版方法是将实现推迟到子类中

　　   2.如果建造者模式省掉导演类，那么builder构建方法就应该是模版方法。

7.参考

　　1.模板方法模式VS建造者模式

　　2.建造者模式