最佳实践02：用Builder代替多参Constructor（二）

概述

在具有继承关系的类中，也可以使用Builder替换多参Constructor。

抽象父类

• Builder<T extends Builder<T>>的语法很古怪，T指的是Builder的自类型，这是对Java缺少自类型的暂时解决方案；
• Objects.requireNonNull(T obj)是JDK提供的（不同于SpringMVC中用注解的方式对请求参数做非空限制），用于校验方法的参数是否为null；
• T self()很有意思，builder在构建完自身的一部分后，通过调用该方法，返回builder自身，从而实现链式调用；

package effective.java.item02.hierarchies;

import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;

public abstract class Pizza {

    public enum Topping {
        HAM, MUSHROOM, ONION, PEPPER, SAUSAGE
    }

    final Set<Topping> toppings;

    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        abstract Pizza build();

        // Subclass must override this method to return "this"
        protected abstract T self();
    }

    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone();
    }

}

具体子类

• 子类继承自父类，那么子类除了拥有自己的成员变量和方法，还有继承来的父类的成员变量和方法；
• 继承了抽象类，就要重写抽象类中所有的抽象元素，在抽象类Pizza中，抽象元素只有一个抽象静态内部类（我勒个去！抽象类里的抽象静态内部类！），那就在具体类中创建一个静态内部类继承这个抽象静态内部类；
• 同样的，具体类中的静态内部类，除了有自己的成员变量和方法（size，Builder(Size size)），还有继承自抽象静态内部类的成员变量和方法（toppings，addTopping(Topping topping)）；
• 具体类中的静态内部类还要实现抽象静态内部类中定义的抽象方法（build()，self()）；
• 注意Builder<T extends Builder<T>>和Pizza.Builder<Builder>的对应；

package effective.java.item02.hierarchies;

import java.util.Objects;

public class NyPizza extends Pizza {

    public enum Size { SMALL, MEDIUM, LARGE }
    private final Size size;

    public static class Builder extends Pizza.Builder<Builder> {
        private final Size size;

        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }

        @Override
        public NyPizza build() {
            return new NyPizza(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }


    private NyPizza(Builder builder) {
        super(builder);
        this.size = builder.size;
    }

}

package effective.java.item02.hierarchies;

public class Calzone extends Pizza {

    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder> {
        private boolean sauceInside = false; // Default

        public Builder sauceInside() {
            sauceInside = true;
            return this;
        }

        @Override
        public Calzone build() {
            return new Calzone(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private Calzone(Builder builder) {
        super(builder);
        this.sauceInside = builder.sauceInside;
    }

}

客户端代码

• NyPizza.Builder(SMALL)构建出的具体builder，除了有自身的size用以构建NyPizza中的size，还有抽象Builder的toppings用以构建抽象类中的toppings；

package effective.java.item02.hierarchies;

import static effective.java.item02.hierarchies.NyPizza.Size.*;
import static effective.java.item02.hierarchies.Pizza.Topping.*;

public class PizzaClient {

    public static void main(String[] args) {
        NyPizza nyPizza = new NyPizza.Builder(SMALL)
                .addTopping(SAUSAGE).addTopping(ONION).build();
        Calzone calzone = new Calzone.Builder()
                .addTopping(HAM).sauceInside().build();
    }

}