码迷，mamicode.com
首页 > 其他好文 > 详细

Item2: 遇到多个构造器形参时考虑使用构建器

时间：2017-07-03 10:15:14      阅读：210      评论：0      收藏：0      [点我收藏+]

标签：cto   可读性   cts   无法   .com   etc   stack   https   nfa   

Consider a builder when faced with many constructor parameters

引言

遇到多个构造器时要考虑用构建器（builder）
重叠构造器(telescoping constructor)
  1. // Telescoping constructor pattern - does not scale well! - Pages 11-12
  3. /**
  4.  * 营养成分表
  5.  */
  6. public class NutritionFacts {
  7.     private final int servingSize;   // (mL)            required
  8.     private final int servings;      // (per container) required
  9.     private final int calories;      //                 optional
  10.     private final int fat;           // (g)             optional
  11.     private final int sodium;        // (mg)            optional
  12.     private final int carbohydrate;  // (g)             optional
  14.     /**
  15.      * 重叠构造器模式：提供第一个只有必要参数的构造器
  16.      */
  17.     public NutritionFacts(int servingSize, int servings) {
  18.         this(servingSize, servings, 0);
  19.     }
  21.     /**
  22.      * 重叠构造器模式：第二个构造器有一个可选参数
  23.      */
  24.     public NutritionFacts(int servingSize, int servings, int calories) {
  25.         this(servingSize, servings, calories, 0);
  26.     }
  28.     /**
  29.      * 重叠构造器模式：第三个构造器在第二个构造器的基础上，加一个可选参数
  30.      */
  31.     public NutritionFacts(int servingSize, int servings, int calories, int fat) {
  32.         this(servingSize, servings, calories, fat, 0);
  33.     }
  35.     /**
  36.      * 重叠构造器模式：以此类推
  37.      */
  38.     public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
  39.         this(servingSize, servings, calories, fat, sodium, 0);
  40.     }
  42.     /**
  43.      * 重叠构造器模式：以此类推
  44.      */
  45.     public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium, int carbohydrate) {
  46.         this.servingSize  = servingSize;
  47.         this.servings     = servings;
  48.         this.calories     = calories;
  49.         this.fat          = fat;
  50.         this.sodium       = sodium;
  51.         this.carbohydrate = carbohydrate;
  52.     }
  54.     public static void main(String[] args) {
  55.         NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
  56.     }
  57. }
缺点：
① 当有许多参数的时候，客户端代码会很难编写,并且仍然较难以阅读。
② 如果读者想知道那些值是什么意思，必须很仔细地数着这些参数来探个究竟。如果客户端不小心颠倒了其中两个参数的顺序，编译器也不会出错，但是在程序运行时会出现错误行为。

JavaBeans模式
  1. // JavaBeans Pattern - allows inconsistency, mandates mutability - Pages 12-13
  3. public class NutritionFacts {
  4.     // Parameters initialized to default values (if any)
  5.     private int servingSize  = -1;  // Required; no default value
  6.     private int servings     = -1;  //     "     "     "      "
  7.     private int calories     = 0;
  8.     private int fat          = 0;
  9.     private int sodium       = 0;
  10.     private int carbohydrate = 0;
  12.     public NutritionFacts() { }
  14.     // Setters
  15.     public void setServingSize(int val)  {
  16.         servingSize = val;
  17.     }
  19.     public void setServings(int val)     {
  20.         servings = val;
  21.     }
  23.     public void setCalories(int val)     {
  24.         calories = val;
  25.     }
  27.     public void setFat(int val)          {
  28.         fat = val;
  29.     }
  31.     public void setSodium(int val)       {
  32.         sodium = val;
  33.     }
  35.     public void setCarbohydrate(int val) {
  36.         carbohydrate = val;
  37.     }
  39.     public static void main(String[] args) {
  40.         // 调用一个无参构造器来创建对象，然后调用setter()方法来设置
  41.         NutritionFacts cocaCola = new NutritionFacts();
  42.         cocaCola.setServingSize(240);
  43.         cocaCola.setServings(8);
  44.         cocaCola.setCalories(100);
  45.         cocaCola.setSodium(35);
  46.         cocaCola.setCarbohydrate(27);
  47.     }
  48. }
缺点：
① 无法保证一致性：JavaBean模式自身有着很严重的缺点，因为构造过程被分到了几个调用中，在构造过程中JavaBean可能处在不一致的状态。试图使用处于不一致状态的对象，将会导致失败，这种失败调试起来十分困难
② 阻止了把类做成不可变

Builder模式

  1. // Builder Pattern - Pages 14-15
  3. public class NutritionFacts {
  4.     private final int servingSize;
  5.     private final int servings;
  6.     private final int calories;
  7.     private final int fat;
  8.     private final int sodium;
  9.     private final int carbohydrate;
  11.     /**
  12.      * 注意是static修饰, 作为NutritionFacts的静态成员类
  13.      * 详细的讨论请参考：
  14.      *     https://stackoverflow.com/questions/5007355/builder-pattern-in-effective-java
  15.      */
  16.     public static class Builder {
  17.         // Required parameters
  18.         private final int servingSize;
  19.         private final int servings;
  21.         // Optional parameters - initialized to default values
  22.         private int calories      = 0;
  23.         private int fat           = 0;
  24.         private int carbohydrate  = 0;
  25.         private int sodium        = 0;
  27.         public Builder(int servingSize, int servings) {
  28.             System.out.println("NutritionFacts.Builder init this[" + this + "]");
  29.             this.servingSize = servingSize;
  30.             this.servings    = servings;
  31.         }
  33.         // builder的setter()方法返回builder本身，以便可以把调用链接起来
  34.         public Builder calories(int val) {
  35.             calories = val;
  36.             return this;
  37.         }
  38.         public Builder fat(int val) {
  39.             fat = val;
  40.             return this;
  41.         }
  42.         public Builder carbohydrate(int val) {
  43.             carbohydrate = val;
  44.             return this;
  45.         }
  46.         public Builder sodium(int val) {
  47.             sodium = val;
  48.             return this;
  49.         }
  51.         /**
  52.          * build()方法可以检验这些约束条件
  53.          * 如果违反了任何约束条件build方法就应该抛出IllegalSelectorException
  54.          */
  55.         public NutritionFacts build() {
  56.             return new NutritionFacts(this);
  57.         }
  58.     }
  60.     /**
  61.      * 注意这是private修饰的
  62.      */
  63.     private NutritionFacts(Builder builder) {
  64.         servingSize  = builder.servingSize;
  65.         servings     = builder.servings;
  66.         calories     = builder.calories;
  67.         fat          = builder.fat;
  68.         sodium       = builder.sodium;
  69.         carbohydrate = builder.carbohydrate;
  70.     }
  72.     public static void main(String[] args) {
  73.         // 不直接生成想要的对象，而是让客户端利用所有必要的参数调用NutritionFacts.Builder(int, int)创建一个builder对象
  74.         // 然后客户端在builder对象调用类似于setter的方法,来设置每个相关的可选参数
  75.         // 最后客户端调用无参的build()方法来生成不可变的对象NutritionFacts
  76.         NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).calories(100).sodium(35).carbohydrate(27).build();
  77.         NutritionFacts cocaCola2 = new NutritionFacts.Builder(240, 8).calories(100).sodium(35).carbohydrate(27).fat(7).build();
  78.     }
  79. }
优点：
① Builder方式创建的对象，在调用 build() 方法之前是不会创建NutritionFacts 对象的，所有的属性设置都必须在 build() 方法之前，而且创建了NutritionFacts 对象后就不可以更改其属性了，这就保证了对象状态的唯一性，而且代码的可读性也提高了。
② 如果有些参数是必填的，可以加到 Builder 的构造函数中
缺点：
Builder模式的确也有自身不足，为了创建对象，必须先创建它的构建器，在某些十分注重性能的情况下，可能就成为问题了。

参考

Item2: 遇到多个构造器形参时考虑使用构建器

标签：cto   可读性   cts   无法   .com   etc   stack   https   nfa   

原文地址：http://www.cnblogs.com/fireway/p/7109349.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！