我在一個構造方法中寫了30個參數，老闆看了想罵人

本文基於《Effective Java》一書中的第二條；

前言

通常咱們寫參數若是寫個一兩個，那就能夠了，若是寫七八個，那就有點難受了。若是寫十幾個？尼瑪，難受，我要去緩緩。

因而乎，一種新的方法策略運用而生。那就是builder模式，在構造方法的參數過多時，能夠方便的進行建立一個類對象。因此本文的中心主旨一句話總結：當構造方法的參數過多時，推薦使用builder模式

既然推薦使用builder模式，那咱們一個一個來，分析一下若是不使用builder模式有什麼缺點。

1、傳統方式的缺點

一、可伸縮構造方法

可伸縮構造方法就是咱們平時書寫最多見的那種，請看下文代碼；

`public class Student {
 private int id; //必要
 private String name;//必要
 private int age; //可選
 private int sclass; //可選
 private int height;//可選
 private float weight;//可選
 private float score;//可選
 //構造函數1：默認構造方法
 public Student() {};
 //構造方法2：必要字段構造方法
 public Student(int id, String name) {
  this.id = id;
  this.name = name;
 }
 //構造方法3：所有字段構造方法
 public Student(int id, String name, int age, int sclass, int height, float weight, float score) {
  super();
  this.id = id;
  this.name = name;
  this.age = age;
  this.sclass = sclass;
  this.height = height;
  this.weight = weight;
  this.score = score;
 }
}
`

下面若是咱們要建立一個Student類，通常這樣建立，看下面代碼：

`public class Main {
 public static void main(String[] args) {
  //一、可伸縮構造方法
  Student student1 = new Student();
  Student student2 = new Student(1,"愚公要移山");
  Student student3 = new Student(2,"愚公要移山",18,1,175,120,99);
 }
}
`

如今咱們列舉了一個具備七個字段的例子，比較容易理解，如今咱們來分析一下，他有什麼缺點：

缺點1：反轉字段，編譯器不會報錯

好比上面的字段裏面有一個weight和一個score，都是float類型，若是再new一個Student類時，不當心寫反了，編譯器不會察覺。

缺點2：難以理解

這裏只是七個字段，若是有十幾個，咱們就須要不斷地去Student類中去查看，看看第幾個參數應該寫哪些東西，實在是比較麻煩。用戶在看到這個Student(2,"愚公要移山",18,1,175,120,99)沒法理解每個字段屬性表明的是什麼含義。

缺點3：不想設置的參數，卻不得不設置值

有時候咱們的Student只想着設置ID、name和age字段，其餘的可有可無，可是這種模式必需要設置全部的屬性值。

既然上面有這些缺點，咱們可能還想到另一種方式，那就是javaBean。

二、javaBean模式

先看javaBean模式如何寫的。

`public class Student {
 private int id; //必要
 private String name;//必要
 private int age; //可選
 private int sclass; //可選
 private int height;//可選
 private float weight;//可選
 private float score;//可選
 //構造函數1：默認構造方法
 public Student() {}
    //getter和setter方法
 public int getId() {return id;}
 public void setId(int id) {this.id = id;}
 public String getName() {return name;}
 public void setName(String name) {this.name = name;}
 public int getAge() {return age;}
 public void setAge(int age) {this.age = age;}
 public int getSclass() {return sclass;}
 public void setSclass(int sclass) {this.sclass = sclass;}
 public int getHeight() {return height;}
 public void setHeight(int height) {this.height = height;}
 public float getWeight() {return weight;}
 public void setWeight(float weight) {this.weight = weight;}
 public float getScore() {return score;}
 public void setScore(float score) {this.score = score;};
}
`

這種模式，看起來還比較舒服，只是設置了相應的getter和setter方法。再來看看如何使用這種方式去new一個Student類。

`public class Main {
 public static void main(String[] args) {
  //二、javaBean模式
  Student student1 = new Student();
  student1.setId(1);
  student1.setName("愚公要移山");
  student1.setSclass(1);
  student1.setWeight(180);
  student1.setHeight(175);
  student1.setScore(100);
  student1.setAge(20);
 }
}
`

這樣看起來還能夠，不過這只是我本身一個一個敲出來的。實際在用的時候就知道一樣噁心了，如今來總結一波他的缺點。

缺點1：構造過程當中 JavaBean可能處於不一致的狀態

JavaBeans 模式自己有嚴重的缺陷。因爲構造方法在屢次調用中被分割，因此在構造過程當中 JavaBean 可能處於不一致的狀態。該類沒有經過檢查構造參數參數的有效性來執行一致性的選項。在不一致的狀態下嘗試使用對象可能會致使與包含 bug 的代碼截然不同的錯誤，所以很難調試。

說一下我對其的理解，在上面的例子中，咱們的student1對象被屢次調用了set方法，可是可能有時候在用到這個bean時，剩下的setter方法尚未作完，因而再次調用時發現同一個javaBean呈現出了兩種狀態。因而處於一種不一致的狀態。

缺點2：沒法保證javaBean的不可變性

使用第一種模式可伸縮構造方法實例化以後不會更改可變性，全部的數據都是肯定好了的。也能夠保證線程安全。可是提供了setter方法，就不能保證了。好比：

`public class Main {
 public static void main(String[] args) {
  //二、javaBean模式
  Student student1 = new Student();
  student1.setId(1);
  student1.setName("愚公要移山");
  student1.setSclass(1);
  student1.setWeight(180);
  student1.setHeight(175);
  student1.setScore(100);
  student1.setAge(20);
  System.out.println(student1.getName());
  student1.setName("馮鼕鼕");
  System.out.println(student1.getName());
 }
}
//輸出結果：愚公要移山  馮鼕鼕
`

能夠看到，咱們能夠對Student對象設置屢次name，先後是不一致的狀態。

既然前面兩種都存在各類各樣的問題。如今咱們再來看今天的主題builder模式，

2、builder模式

仍是老樣子，咱們先看看builder模式長得什麼樣子。再來分析一下他的優缺點。

`public class Student {
 private int id; // 必要
 private String name;// 必要
 private int age; // 可選
 private int sclass; // 可選
 private int height;// 可選
 private float weight;// 可選
 private float score;// 可選
 public Student(Builder builder) {
  this.id = builder.id;
  this.name = builder.name;
  this.age = builder.age;
  this.sclass = builder.sclass;
  this.height = builder.height;
  this.weight = builder.weight;
  this.score = builder.score;
 }
 public static class Builder {
  private int id; // 必要
  private String name;// 必要
  private int age; // 可選
  private int sclass; // 可選
  private int height;// 可選
  private float weight;// 可選
  private float score;// 可選
  // 必要參數的構造方法
  public Builder(int id, String name) {
   this.id = id;
   this.name = name;
  }
  public Builder setId(int id) {
   this.id = id;
   return this;
  }
  public Builder setName(String name) {
   this.name = name;
   return this;
  }
  public Builder setAge(int age) {
   this.age = age;
   return this;
  }
  public Builder setSclass(int sclass) {
   this.sclass = sclass;
   return this;
  }
  public Builder setHeight(int height) {
   this.height = height;
   return this;
  }
  public Builder setWeight(float weight) {
   this.weight = weight;
   return this;
  }
  public Builder setScore(float score) {
   this.score = score;
   return this;
  }
  // 對外提供的
  public Student build() {
   return new Student(this);
  }
 }
}
`

上面的代碼是在內部構造了一個Builder類，而後咱們看看如何去使用。

``public class Main {
 public static void main(String[] args) {
  //三、Builder模式
  Student stu = new Student.Builder(1, "愚公要移山")
    .setAge(20)
    .setHeight(175)
    .setSclass(1)
    .setScore(100)
    .setWeight(100).build();
 }
}
``

這本書中對其的缺點也進行了介紹，很直觀能夠看到，Student類中的代碼量增長了不少。可是Student類，咱們只須要寫一次，這卻爲咱們建立對象帶來了方便。

優勢1：不存在反轉字段的狀況

上面能夠看出，每次添加新字段值的時候是經過set方式進行的。具備javaBean的優勢。

優勢2：靈活構造參數

咱們把必要的字段一寫，那些非必要的字段咱們能夠本身選擇是否是要set。

優勢3：不存在不一致狀態

使用builder模式，對象的建立必需要等到build完成才能夠。

優勢4：使用靈活

單個 builder 能夠重複使用來構建多個對象。 builder 的參數能夠在構建方法的調用之間進行調整，以改變建立的對象。 builder 能夠在建立對象時自動填充一些屬性，例如每次建立對象時增長的序列號。

缺點：

爲了建立對象，首先必須建立它的 builder。雖然建立這個 builder 的成本在實踐中不太可能被注意到，但在性能關鍵的狀況下可能會出現問題。並且，builder 模式比伸縮構造方法模式更冗長，所以只有在有足夠的參數時才值得使用它，好比四個或更多。

可是，若是從構造方法或靜態工廠開始，並切換到 builder，當類演化到參數數量失控的時候，過期的構造方法或靜態工廠就會面臨尷尬的處境。所以，因此，最好從一開始就建立一個 builder。

總結

若是咱們的參數比較多時，builder模式是一個不錯的選擇，若是比較少時，因爲Builder自己也是個對象佔用必定的資源，因此仍是使用可伸縮或者是javaBean的那種模式比較好。