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

小灰灰 2022-05-27 05:42 143阅读 0赞

> 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个或更多），但是要记住，如果刚开始是采用构造器或静态工厂，等到了参数很多时才添加构建器，那时就好很难控制，并且代码很不协调，所以需要做好代码设计和预测，以便决定是否选择使用构建器，通常一开始使用构建器**