effective java 第2条：构建器 以及内部类

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;
     //外部类的非static成员必须依赖于对象的调用，静态成员则可以直接使用类调用，
     // 不必依赖于外部类的对象，所以静态内部类只能访问静态的外部属性和方法。
    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.servings = servings;
            this.servingSize = servingSize;
        }

        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(){
           //外部类的非static成员必须依赖于对象的调用（唯一用到的外部类方法）
            return new NutritionFacts(this);
        }
    }
    private NutritionFacts(Builder builder){
        this.servings = builder.servings;
        this.servingSize = builder.servingSize;
        this.calories = builder.calories;
        this.fat = builder.fat;
        this.sodium = builder.sodium;
        this.carbohydrate = builder.carbohydrate;
    }
}

class test{
    public static void main(String[] args) {
        // NutritionFacts.Builder 因为是static所以可以直接点，即没有外部类对象也可以直接
        //创建内部静态类对象
       
        NutritionFacts.Builder builder = new NutritionFacts.Builder(240, 100);
        NutritionFacts build = new NutritionFacts.Builder(240, 8) //到这个代码为止是new了个Builder类
                .calories(100) 
                .sodium(35)
                .carbohydrate(27) //这边是给builder类添加属性，到这边为止返回的都是builder类
                .build();//通过builder类构建需要目标类
    }
}

延伸问题：当内部类不是静态类，即非静态内部类

1）：最大优点 ，我在外部类里面，我可以访问到外部类的所有东西。

//初始化方法 需先创建外部类对象
outClass a  = new outClass();
outClass.innerClass b = a.new innerClass();

摘自知乎：

静态内部类就是个独立的类。

之所以要弄这么个东西，只是起到一个注释的效果，而且这个注释可静态检查。

比如有A，B两个类，B有点特殊，虽然可以独立存在，但只被A使用。

这时候怎么办？如果把B并入A里，复杂度提高，搞得A违反单一职责。如果B独立，又可能被其他类（比如同一个包下的C）依赖，不符合设计的本意。所以不如将其变成A.B，等于添加个注释，告诉其他类别使用B了，它只跟A玩。

非静态的才是真正的内部类，对其外部类有个引用。