【Effective Java笔记】第2条：遇到多个构造器参数时要考虑用构建器(Builder模式)

Effective Java第二条讲构建器(Builder模式)在成员变量比较多的时候相对于构造器和静态工厂、以及JavaBean模式的一些优势

一、创建对象的三种方法

• 静态工厂和构造器模式
• JavaBean模式
• 构建器(Builder模式)

如题目所说，当遇到多个构造器参数时，考虑用构建器(Builder模式)，先说说另外两者在遇到多个参数是的缺点

二、静态工厂和构造器模式

采用重叠构造模式，提供一个只有必要参数的构造器，第二个构造器有一个可选参数,第三个构造器有两个可选参数….将所有参数传递到构造函数中，这种方式不能很好地扩展到大量的可选参数，如以下代码为例

重叠构造器模式

package linjie.com;
/**
 * @author Linjie
 * 重叠构造器模式
 */
public class NutritionFacts {
    //以下成员变量中servingSize与servings视为必选参数,其他为可选参数
    private final int servingSize; //required
    private final int servings;    //required

    private final int a;           //optional
    private final int b;           //optional
    private final int c;           //optional

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize,servings,0);
    }

    public NutritionFacts(int servingSize, int servings,
            int a) {
        this(servingSize,servings,a,0);
    }

    public NutritionFacts(int servingSize, int servings, 
            int a, int b) {
        this(servingSize,servings,a,b,0);
    }

    public NutritionFacts(int servingSize, int servings, int a, int b, int c) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

启动类代码

package linjie.com;

/**
 * @author Linjie
 * 启动类
 */
public class main {

    public static void main(String[] args) {
        NutritionFacts t = new NutritionFacts(1, 2, 3, 0, 9);
    }

}

这种模式通常需要许多你本不想设置的参数，但还是不得不为它们传值(比如上面代码的b，传递了一个值为0)，如果参数数目增加，很快就会失去控制。

所以重叠构造器可行，但是当有许多参数时，客户端代码会很难编写，并且可读性差，若想知道那些值是什么意义，必须要看参数来探究

三、JavaBean模式

该模式调用一个无参构造器来创建对象，然后通过setter方法来设置每个必要的参数，以及每个相关的可选参数

JavaBean模式

package linjie.com;
/**
 * @author Linjie
 * JavaBean模式
 */
public class NutritionFacts {
    //以下成员变量中servingSize与servings视为必选参数,其他为可选参数
    private int servingSize = -1; //required
    private int servings    = -1; //required

    private int a           = 0;  //optional
    private int b           = 0;  //optional
    private int c           = 0;  //optional

    public NutritionFacts() {}

    //setters
    public void setServingSize(int val) {servingSize = val; }
    public void setServings(int val)    {servings = val;}
    public void setA(int val)           {a=val;}
    public void setB(int val)           {b=val;}
    public void setC(int val)           {c=val;}

    //getters
    public int getServingSize()         {return servingSize;  }
    public int getServings()            {return servings;}
    public int getA()                   {return a;}
    public int getB()                   {return b;}
    public int getC()                   {return c;}
}

启动类代码

package linjie.com;

/**
 * @author Linjie
 * 启动类
 */
public class main {

    public static void main(String[] args) {
        NutritionFacts t = new NutritionFacts();

        //setters
        t.setServingSize(10);
        t.setServings(20);
        t.setA(30);
        t.setB(40);
        t.setC(50);

        //getters
        System.out.println(t.getServingSize());
    }
}

可以看出JavaBean模式解决了可选参数问题，并且代码可读性很高

但是：JavaBean模式自身有着严重的缺点

- 因为构造过程被分到了几个调用中，在构造过程中JavaBean可能处于不一致的状态。类无法仅仅通过检验构造器参数的有效性来保证一致性。试图使用处于不一致状态的对象，将会导致失败，这种失败与包含错误代码很不一样，这种失败调试十分困难
- 还有一点不足在于，JavaBean模式阻止了把类做成不可变的可能(即final类型无法使用)，这就需要程序员付出额外努力来确保线程安全

四、构建器(Builder模式)

该模式不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器(或静态工厂)，得到一个builder对象。然后客户端在builder对象上调用类似于setter的方法，来设置每个相关的可选参数。最后客户端调用无参builder方法来生成不可变的对象。这个builder是它构建的类的静态成员类

Builder模式

package linjie.com;
/**
 * @author Linjie
 * Builder模式
 */
public class NutritionFacts {
    //以下成员变量中servingSize与servings视为必选参数,其他为可选参数
    private final int servingSize;   //required
    private final int servings;      //required

    private final int a;             //optional
    private final int b;             //optional
    private final int c;             //optional

    //静态成员类Builder
    public static class Builder{
        //required
        private final int servingSize;
        private final int servings;

        //optional
        private int a;
        private int b;
        private int c;


        //必要参数构造器
        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        //可选参数方法
        public Builder a(int val)
            { a = val;  return this;}
        public Builder b(int val)
            { b = val;  return this;}
        public Builder c(int val)
            { c = val;  return this;}

        //生成不可变的对象
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        a = builder.a;
        b = builder.b;
        c = builder.c;
    }
}

启动类代码

package linjie.com;

/**
 * @author Linjie
 * 启动类
 */
public class main {

    public static void main(String[] args) {
        NutritionFacts t = new NutritionFacts.Builder(10, 20).
                a(30).b(40).c(50).build();
    }

}

可以看到，Builder类中对可选参数设置的方法都是返回this(返回Builder本身)，以便可以把调用链接起来

可见Builder模式既能保证向重叠构造器模式的安全性，也能保证像JavaBean模式那么好的可读性

总结

Builder模式的确也有自身的不足。为了创建对象，必须先创建它的构建器。虽然创建构建器的开销在实践中可能不那么明显，但是在某些十分注重性能的情况下，可能就成问题了。Builder模式还比重叠构造器更加冗长。因此只有在很多参数是才使用（4个或更多），但是要记住，如果刚开始是采用构造器或静态工厂，等到了参数很多时才添加构建器，那时就好很难控制，并且代码很不协调，所以需要做好代码设计和预测，以便决定是否选择使用构建器，通常一开始使用构建器