天天看點
傳回

《Effective java中文第2版》讀書筆記1

第2條：遇到多個構造器參數時要考慮用建構器   

    某個類的屬性較多，初始化的時候又有一些是必須初始化的，而且類型有形同，  

    比如new Contact("姓名","顯示名","手機号","飛信号","所在地",年齡,性别);   

    前5個屬性是String 類型，後2個是int類型，在填寫構造方法的時候很容易填寫錯位，或者少填寫，或者颠倒了屬性，   

    如下方法可以減少這種錯誤發生的幾率，   

     
  1.  Contact contact = new Contact();            
    2.       
  2.      contact.setName("姓名");            
    3.       
  3.      contact.setDisplayName("顯示名");            
    4.       
  4.      contact.setPhoneNumber("手機号");            
    5.       
  5.      contact.setFetionNumber("飛信号");            
    6.       
  6.      contact.setHometown("所在地");            
    7.       
  7.      contact.setAge(23);            
    8.       
  8.      contact.setGender(0);            
    9.

這麼寫是通常的做法，看起來還不夠清晰，我們在每個set方法裡retrun一個Contact類型，比如

     
  1.  public Contact setName(String name)            
    2.       
  2.     {            
    3.       
  3.         this.name = name;            
    4.       
  4.         return this;            
    5.       
  5.     }           
    6.

這樣上面的構造Contact的代碼就可以這麼寫了

     
  1.  Contact contact = new Contact() .setName("姓名")            
    2.       
  2.                                      .setDisplayName("顯示名")            
    3.       
  3.                                      .setPhoneNumber("手機号")            
    4.       
  4.                                      .setFetionNumber("飛信号")            
    5.       
  5.                                      .setHometown("所在地")            
    6.       
  6.                                      .setAge(23)            
    7.       
  7.                                      .setGender(0);           
    8.

    這樣寫是不是更清爽了！屬性不會再填寫錯誤了！而且閱讀代碼的時候也一目了然，都給Contact初始化了那些屬性，和屬性的值是什麼！   

第3條：用私有構造器或者枚舉類型強化Singleton屬性   

 建議使用如下方法建立單例類   

     
  1.  public final class Elvis            
    2.       
  2.      {            
    3.       
  3.          private static Elvis INSTANCE;            
    4.       
  4.          private Elvis(){};            
    5.       
  5.          synchronized public static Elvis getInstance()            
    6.       
  6.          {            
    7.       
  7.              if( INSTANCE == null )            
    8.       
  8.              {            
    9.       
  9.                  INSTANCE = new Elvis();            
    10.       
  10.              }            
    11.       
  11.              return INSTANCE;            
    12.       
  12.          }            
    13.       
  13.          //執行其他操作            
    14.       
  14.          private Object readResolve()            
    15.       
  15.          {            
    16.       
  16.              return INSTANCE;            
    17.       
  17.          }            
    18.       
  18.      }           
    19.

    這種建構方法好處，組成類的成員聲明很清楚地表明了這個類是個Singleton，并且也解決了INSTANCE的同步問題，   

    沒有暴露共有的INSTANCE變量，這樣更有力于隐藏類的内部實作，   

    另外，改做法也很容易就可以修改成非單例模式，加上的readResolve方法可以保證反序列化時也是同一個對象。   

第4條：通過私有構造器強化不可執行個體化的能力   

    我們軟體中常用的常量集(Constants)，工具集(Tool,Utility)都應該是不可執行個體化的類，那麼他們應該如下建構   

     
  1.  public final class Constants            
    2.       
  2.      {            
    3.       
  3.          private Constants()            
    4.       
  4.          {            
    5.       
  5.              throw new AssertionError();            
    6.       
  6.          }            
    7.       
  7.          //其他常量的定義，或者靜态方法的實作；            
    8.       
  8.      }           
    9.

這樣可以防止被繼承，被執行個體化。   

第5條：避免建立不必要的對象   

    建立一個String對象，最佳方式如下

     
  1.  String str = "初始化值";            
    2.       
  2.      如果一個String在建立的時候我們不确定他的值，建議如下建立            
    3.       
  3.      String str = "";            
    4.       
  4.      強烈反對            
    5.       
  5.      String str = null;            
    6.       
  6.      這種寫法，因為會有NullPointerException這個異常的危險，另外主要還有潛在隐患，比如做了如下操作            
    7.       
  7.      str += "ABC";            
    8.       
  8.      那麼str = nullABC;了這個不是想要的結果。            
    9.       
  9.      str = "";的初始化方式也有他的不足之處，在判斷str是否有效的時候就要多加一個長度的判斷如下            
    10.       
  10.      if( str==null||str.length()<=0 ){}           
    11.
讀書筆記 移動開發 休閑 effective java 中文第2版 遊戲開發 虛幻引擎 UE4 遊戲引擎
上一篇: 十月機房考核
下一篇: 深度神經網絡（DNN）反向傳播算法(BP)

繼續閱讀