在新建对象时，若需要对大量可选参数进行赋值，最常见的做法是JavaBeans模式，即调用一个无参构造方法创建对象，然后调用setter方法来设置每个必要的参数，以及每个相关的可选参数。代码示例如下：

Copypublic class Complex {    private int size;    private int color;    private int range = 0;    private int num = 0;    public Complex(int size, int color) {        this.size = size;        this.color = color;
    }    public void setRange(int range) {        this.range = range;
    }    public void setNum(int num) {        this.num = num;
    }
}

这种模式需要的代码语句繁琐，而且这种做法阻止了把类做成不可变的可能。更加简洁的一种方式是通过多个构造方法去新建对象。比如下面的代码：

Copypublic class Complex {    private int size;    private int color;    private int range = 0;    private int num = 0;    public Complex(int size, int color) {        this.size = size;        this.color = color;
    }    public Complex(int size, int color, int range) {        this.size = size;        this.color = color;        this.range = range;
    }    // public Complex(int size, int color, int num) {
    //     this.size = size;
    //     this.color = color;
    //     this.num = num;
    // }

    public Complex(int size, int color, int range, int num) {        this.size = size;        this.color = color;        this.range = range;        this.num = num;
    }
    
}

当参数越来越多时，这种方式就会使类的结构变得臃肿，难以维护，在使用时也需要去逐个理解每种构造方法的参数意义。并且在上述示例中，也是无法打开被注释掉的构造方法。

有没有一种更好的创建大量可选参数对象的方式？答案是Builder模式。先来看下面的示例代码：

Copypublic class NutritionFacts {    private final int size;    private final int color;    private final int num;    private final int range;    public static class Builder {        private int size;        private int color;        private int range = 0;        private int num = 0;        public Builder(int size, int color) {            this.size = size;            this.color = color;
        }        public Builder num(int num) {            this.num = num;            return this;
        }        public Builder range(int range) {            this.range = range;            return this;
        }        public NutritionFacts build() {            return new NutritionFacts(this);
        }
    }    private NutritionFacts(Builder builder) {        this.color = builder.color;        this.num = builder.num;        this.size = builder.size;        this.range = builder.range;
    }    public static void main(String[] args) {
        NutritionFacts build = new NutritionFacts.Builder(2, 1)
                .num(3).range(4).build();
    }
}

通过观察示例代码，不难发现。这种模式的本质是不直接生成想要的对象，而是通过链式编程构建一个参数完备的构造器对象，最终通过调用构造器对象的build()方法来生成不可变的目标对象。

显而易见，链式编程的秘诀在于从实例化对象开始，每次调用成员方法都会返回自身对象。

上述示例略微繁琐，若是追求简便，似乎有更好的另一种写法，示例代码如下：

Copypublic class NutritionFacts {    private int size;    private int color;    private int num;    private int range;    public static class Builder {        private NutritionFacts nutritionFacts = new NutritionFacts();        public Builder(int size, int color) {            this.nutritionFacts.size = size;            this.nutritionFacts.color = color;
        }        public Builder num(int num) {            this.nutritionFacts.num = num;            return this;
        }        public Builder range(int range) {            this.nutritionFacts.range = range;            return this;
        }        public NutritionFacts build() {            return nutritionFacts;
        }
    }    public static void main(String[] args) {
        NutritionFacts facts = new NutritionFacts.Builder(2, 1)
                .num(3).range(4).build();
    }
}

写到这里，笔者打算扩展下内部类与静态内部类的相关知识。

内部类与静态内部类

观察下面的静态内部类的声明，static关键字位于class关键字之前（顺序颠倒会报错），说明static的规则优先于class的规则。理解了这一点，就不难理解如何使用静态内部类。

Copypublic class InnerClass {    public class Inner{        public Inner(){            //..
        }
    }    public static class StaticInner{        static int i = 10;        public StaticInner(){            //..
        }
    }

}

对于内部类的实例化：

因为内部类属于外部类的非静态成员，所以首先需要实例化外部类，其次因为内部类也属于类，使用之前故也需要实例化。

Copy    public static void main(String[] args) {        new InnerClass().new Inner();

    }

对于静态内部类的实例化：

因为static关键字必须声明在class之前，所以可知static的规则优先于class的规则。在处理类的静态成员时，优先使用“类名.静态成员”的形式，其次，再考虑实例化或其它变量引用。

Copy    public static void main(String[] args) {        new InnerClass.StaticInner();        int i = InnerClass.StaticInner.i;
    }