日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網營銷解決方案
如何在Java中創(chuàng)建優(yōu)雅的對象來提升程序性能

 其實這個問題很多人都進行過解答，也有很多小伙伴在Java四大名著之一的《Effective Java》中的第1～5小節(jié)了解過，不過我還是想結合自己的理解對這個問題進行總結和歸納，談談為什么會最終選擇構建器來實現我們的目的。

在 Java 中有多種方式可以創(chuàng)建對象，總結起來主要有下面的 4 種方式：

正常創(chuàng)建：通過 new 操作符

反射創(chuàng)建：調用 Class 或 java.lang.reflect.Constructor 的 newInstance()方法

克隆創(chuàng)建：調用現有對象的 clone()方法

發(fā)序列化：調用 java.io.ObjectInputStream 的 getObject()方法反序列化

Java 對象的創(chuàng)建方式是其語法明確規(guī)定，用戶不可能從外部改變的。本文仍然要使用上面的方式來創(chuàng)建對象，所以本文只能說是構建對象，而非創(chuàng)建對象也。

假設有這樣一個場景，現在要構建一個大型的對象，這個對象包含許多個參數的對象，有些參數有些是必填的，有些則是選填的。那么如何構建優(yōu)雅、安全地構建這個對象呢?

01 單一構造函數

通常，我們第一反應能想到的就是單一構造函數方式。直接 new 的方式構建，通過構造函數來傳遞參數，見下面的代碼：

 
 
 
      
  
  
  1. /*** 
    2.   
  
  
  2. * 單一構造函數 
    3.   
  
  
  3. */ 
    4.   
  
  
  4. public class Person { 
    5.   
  
  
  5. // 姓名（必填） 
    6.   
  
  
  6. private String name; 
    7.   
  
  
  7. // 年齡（必填） 
    8.   
  
  
  8. private int age; 
    9.   
  
  
  9. // 身高（選填） 
    10.   
  
  
  10. private int height; 
    11.   
  
  
  11. // 畢業(yè)學校（選填） 
    12.   
  
  
  12. private String school; 
    13.   
  
  
  13. // 愛好（選填） 
    14.   
  
  
  14. private String hobby; 
    15.   
  
  
  15. public Person(String name, int age, int height, String school, String hobby) { 
    16.   
  
  
  16. this.name = name; 
    17.   
  
  
  17. this.age = age; 
    18.   
  
  
  18. this.height = height; 
    19.   
  
  
  19. this.school = school; 
    20.   
  
  
  20. this.hobby = hobby; 
    21.   
  
  
  21. } } 
    22.

上面的構建方式有下面的缺點：

有些參數是可以選填的（如 height, school），在構建 Person 的時候必須要傳入可能并不需要的參數。

現在上面才 5 個參數，構造函數就已經非常長了。如果是 20 個參數，構造函數都可以直接上天了！

構建的這樣的對象非常容易出錯。

客戶端必須要對照 Javadoc 或者參數名來講實參傳入對應的位置。如果參數都是 String 類型的，一旦傳錯參數，編譯是不會報錯的，但是運行結果卻是錯誤的。

02 多構造函數

對于第 1 個問題，我們可以通過構造函數重載來解決。見下面的代碼：

 
 
 
      
  
  
  1. /*** 
    2.   
  
  
  2. * 多構造函數 
    3.   
  
  
  3. */ 
    4.   
  
  
  4. public class Person { 
    5.   
  
  
  5. // 姓名（必填） 
    6.   
  
  
  6. private String name; 
    7.   
  
  
  7. // 年齡（必填） 
    8.   
  
  
  8. private int age; 
    9.   
  
  
  9. // 身高（選填） 
    10.   
  
  
  10. private int height; 
    11.   
  
  
  11. // 畢業(yè)學校（選填） 
    12.   
  
  
  12. private String school; 
    13.   
  
  
  13. // 愛好（選填） 
    14.   
  
  
  14. private String hobby; 
    15.   
  
  
  15. public Person(String name, int age) { 
    16.   
  
  
  16. this.name = name; 
    17.   
  
  
  17. this.age = age; 
    18.   
  
  
  18. } 
    19.   
  
  
  19. public Person(String name, int age, int height) { 
    20.   
  
  
  20. this.name = name; 
    21.   
  
  
  21. this.age = age; 
    22.   
  
  
  22. this.height = height; 
    23.   
  
  
  23. } 
    24.   
  
  
  24. public Person(String name, int age, int height, String school) { 
    25.   
  
  
  25. this.name = name; 
    26.   
  
  
  26. this.age = age; 
    27.   
  
  
  27. this.height = height; 
    28.   
  
  
  28. this.school = school; 
    29.   
  
  
  29. } 
    30.   
  
  
  30. public Person(String name, int age, String hobby, String school) { 
    31.   
  
  
  31. this.name = name; 
    32.   
  
  
  32. this.age = age; 
    33.   
  
  
  33. this.hobby = hobby; 
    34.   
  
  
  34. this.school = school; 
    35.   
  
  
  35. } } 
    36.

上面的方式確實能在一定程度上降低構造函數的長度，但是卻有下面的缺陷：

導致類過長。這種方式會使得 Person 類的構造函數成階乘級增長。按理來說，應該要寫的構造函數數是可選成員變量的組合數（實際并沒有這么多，原因見第 2 點）。如果讓我調用這樣的類，絕對會在心里默念 xx!!

有些參數組合無法重構。因為 Java 中重載是有限制的，相同方法簽名的方法不能構成重載，編譯時無法通過。譬如包含（name, age, school）和(name, age, hobby)的構造函數是不能重載的，因為 shcool 和 hobby 同為 String 類型。Java 只認變量的類型，管你變量是什么含義呢。

03 JavaBean方式

上面的方法不行，莫急！還有法寶——JavaBean。一個對象的構建通過多個方法來完成。直接見下面的代碼：

 
 
 
      
  
  
  1. public class Person { 
    2.   
  
  
  2. // 姓名（必填） 
    3.   
  
  
  3. private String name; 
    4.   
  
  
  4. // 年齡（必填） 
    5.   
  
  
  5. private int age; 
    6.   
  
  
  6. // 身高（選填） 
    7.   
  
  
  7. private int height; 
    8.   
  
  
  8. // 畢業(yè)學校（選填） 
    9.   
  
  
  9. private String school; 
    10.   
  
  
  10. // 愛好（選填） 
    11.   
  
  
  11. private String hobby; 
    12.   
  
  
  12. public Person(String name, int age) { 
    13.   
  
  
  13. this.name = name; 
    14.   
  
  
  14. this.age = age; 
    15.   
  
  
  15. } 
    16.   
  
  
  16. public void setHeight(int height) { 
    17.   
  
  
  17. this.height = height; 
    18.   
  
  
  18. } 
    19.   
  
  
  19. public void setSchool(String school) { 
    20.   
  
  
  20. this.school = school; 
    21.   
  
  
  21. } 
    22.   
  
  
  22. public void setHobby(String hobby) { 
    23.   
  
  
  23. this.hobby = hobby; 
    24.   
  
  
  24. } } 
    25.   
  
  
  25. 客戶端使用這個對象的代碼如下： 
    26.   
  
  
  26. public class Client { 
    27.   
  
  
  27. public static void main(String[] args) { 
    28.   
  
  
  28. Person person = new Person("james", 12); 
    29.   
  
  
  29. person.setHeight(170); 
    30.   
  
  
  30. person.setHobby("reading"); 
    31.   
  
  
  31. person.setSchool("xxx university"); 
    32.   
  
  
  32. } } 
    33.

這樣看起來完美的解決了 Person 對象構建的問題，使用起來非常優(yōu)雅便捷。確實，在單一線程的環(huán)境中這確實是一個非常好的構建對象的方法，但是如果是在多線程環(huán)境中仍有其致命缺陷。在多線程環(huán)境中，這個對象不能安全地被構建，因為它不是不可變對象。一旦Person 對象被構建，我們隨時可通過 setXXX()方法改變對象的內部狀態(tài)。假設有一個線程正在執(zhí)行與 Person 對象相關的業(yè)務方法，另外一個線程改變了其內部狀態(tài)，這樣得到莫名其妙的結果。由于線程運行的無規(guī)律性，使得這問題有可能不能重現，這個時候真的就只能哭了。

04 Builder方式

為了完美地解決這個問題，下面引出本文中的主角（等等等等?。Ｎ覀兪褂脴嫿ㄆ鳎˙uilder）來優(yōu)雅、安全地構建 Person 對象。廢話不說，直接代碼：

 
 
 
      
  
  
  1. /** 
    2.   
  
  
  2. * 待構建的對象。該對象的特點： 
    3.   
  
  
  3. * 
         
  
  
    1. * 
    2. 需要用戶手動的傳入多個參數，并且有多個參數是可選的、順序隨意
      3.    
  
  
    3. * 
    4. 該對象是不可變的（所謂不可變，就是指對象一旦創(chuàng)建完成，其內部狀態(tài)不可變， 
      5.   
  
  
    5. 更通俗的說是其成員變量不可改變）。* 不可變對象本質上是線程安全的。
      6.    
  
  
    6. * 
    7. 對象所屬的類不是為了繼承而設計的。
      8.    
  
  
    8. * 
     
    4.   
  
  
  4. * 滿足上面特點的對象的構建可是使用下面的 Build 方式構建。這樣構建對象有下面的好 
    5.   
  
  
  5. 處： 
    6.   
  
  
  6. * 
         
  
  
    1. * 
    2. 不需要寫多個構造函數，使得對象的創(chuàng)建更加便捷
      3.    
  
  
    3. * 
    4. 創(chuàng)建對象的過程是線程安全的
      5.    
  
  
    5. * 
     
    7.   
  
  
  7. * @author xiaoyu 
    8.   
  
  
  8. * @date 2020-10-25 
    9.   
  
  
  9. */ 
    10.   
  
  
  10. public class Person { 
    11.   
  
  
  11. // 姓名（必填），final 修飾 name 一旦被初始化就不能再改變，保證了對象的不可變 
    12.   
  
  
  12. 性。 
    13.   
  
  
  13. private final String name; 
    14.   
  
  
  14. // 年齡（必填） 
    15.   
  
  
  15. private final int age; 
    16.   
  
  
  16. // 身高（選填） 
    17.   
  
  
  17. private final int height; 
    18.   
  
  
  18. // 畢業(yè)學校（選填） 
    19.   
  
  
  19. private final String school; 
    20.   
  
  
  20. // 愛好（選填） 
    21.   
  
  
  21. private final String hobby; 
    22.   
  
  
  22. /** 
    23.   
  
  
  23. * 這個私有構造函數的作用： 
    24.   
  
  
  24. * 
         
  
  
    1. * 
    2. 成員變量的初始化。final 類型的變量必須進行初始化，否則無法編譯成功
      3.    
  
  
    3. * 
    4. 私有構造函數能夠保證該對象無法從外部創(chuàng)建，并且 Person 類無法被繼承
      5.    
  
  
    5. * 
     
    25.   
  
  
  25. */ 
    26.   
  
  
  26. private Person(String name, int age, int height, String school, String hobby) { 
    27.   
  
  
  27. this.name = name; 
    28.   
  
  
  28. this.age = age; 
    29.   
  
  
  29. this.height = height; 
    30.   
  
  
  30. this.school = school; 
    31.   
  
  
  31. this.hobby = hobby; 
    32.   
  
  
  32. } 
    33.   
  
  
  33. /** 
    34.   
  
  
  34. * 要執(zhí)行的動作 
    35.   
  
  
  35. */ 
    36.   
  
  
  36. public void doSomething() { 
    37.   
  
  
  37. // TODO do what you want!! 
    38.   
  
  
  38. } 
    39.   
  
  
  39. /** 
    40.   
  
  
  40. * 構建器。為什么 Builder 是內部靜態(tài)類？ 
    41.   
  
  
  41. * 
         
  
  
    1. * 
    2. 必須是 Person 的內部類。否則，由于 Person 的構造函數私有，不能通過 new 的 
      3.   
  
  
    3. 方式創(chuàng)建 Person 對象
      4.    
  
  
    4. * 
    5. 必須是靜態(tài)類。由于 Person 對象無法從外部創(chuàng)建，如果不是靜態(tài)類，則外部無 
      6.   
  
  
    6. 法引用 Builder 對象。
      7.    
  
  
    7. * 
     
    42.   
  
  
  42. * 注意：Builder 內部成員變量要與 Person 的成員變量保持一致。 
    43.   
  
  
  43. * @author xiaoyu 
    44.   
  
  
  44. * 
    45.   
  
  
  45. */ 
    46.   
  
  
  46. public static class Builder { 
    47.   
  
  
  47. // 姓名（必填）。注意：這里不能是 final 的 
    48.   
  
  
  48. private String name; 
    49.   
  
  
  49. // 年齡（必填） 
    50.   
  
  
  50. private int age; 
    51.   
  
  
  51. // 身高（選填） 
    52.   
  
  
  52. private int height; 
    53.   
  
  
  53. // 畢業(yè)學校（選填） 
    54.   
  
  
  54. private String school; 
    55.   
  
  
  55. // 愛好（選填） 
    56.   
  
  
  56. private String hobby; 
    57.   
  
  
  57. public Builder(String name, int age) { 
    58.   
  
  
  58. this.name = name; 
    59.   
  
  
  59. this.age = age; 
    60.   
  
  
  60. } 
    61.   
  
  
  61. public Builder setHeight(int height) { 
    62.   
  
  
  62. this.height = height; 
    63.   
  
  
  63. return this; 
    64.   
  
  
  64. } 
    65.   
  
  
  65. public Builder setSchool(String school) { 
    66.   
  
  
  66. this.school = school; 
    67.   
  
  
  67. return this; 
    68.   
  
  
  68. } 
    69.   
  
  
  69. public Builder setHobby(String hobby) { 
    70.   
  
  
  70. this.hobby = hobby; 
    71.   
  
  
  71. return this; 
    72.   
  
  
  72. } 
    73.   
  
  
  73. /** 
    74.   
  
  
  74. * 構建對象 
    75.   
  
  
  75. * @return 返回待構建的對象本身 
    76.   
  
  
  76. */ 
    77.   
  
  
  77. public Person build() { 
    78.   
  
  
  78. return new Person(name, age, height, school, hobby); 
    79.   
  
  
  79. } } } 
    80.

客戶端構建對象的方式見下面的代碼：

 
 
 
      
  
  
  1. /** 
    2.   
  
  
  2. * 使用 Person 對象的客戶端 
    3.   
  
  
  3. * @author xiaoyu 
    4.   
  
  
  4. * @date 2020-10-25 
    5.   
  
  
  5. */ 
    6.   
  
  
  6. public class Client { 
    7.   
  
  
  7. public static void main(String[] args) { 
    8.   
  
  
  8. /* 
    9.   
  
  
  9. * 通過鏈式調用的方式創(chuàng)建 Person 對象，非常優(yōu)雅！ 
    10.   
  
  
  10. */ 
    11.   
  
  
  11. Person person = new Person.Builder("james", 12) 
    12.   
  
  
  12. .setHeight(170) 
    13.   
  
  
  13. .setHobby("reading") 
    14.   
  
  
  14. .build(); 
    15.   
  
  
  15. person.doSomething(); 
    16.   
  
  
  16. } } 
    17.

如果不想看代碼，可看下面對于上面代碼的總結：

通過 private Person(..)使得 Person 類不可被繼承

通過將 Person 類的成員變量設置為 final 類型，使得其不可變

通過 Person 內部的 static Builder 類來構建 Person 對象

通過將 Builder 類內部的 setXXX()方法返回 Builder 類型本身，實現鏈式調用構建 Person 對 象

總結

至此，我們就相對完美地解決這一類型的對象創(chuàng)建問題！下面來總結一下本文的重點。待創(chuàng)建的對象特點：

需要用戶手動的傳入多個參數，并且有多個參數是可選的、順序任意

對象不可變

對象所屬的類不是為了繼承而設計的。即類不能被繼承

依次使用的對象構建方法：

單一構造函數

多構造函數

JavaBean 方式

Builder 方式

最終，通過比較得出 Builder 方法最為合適的解決。


文章名稱：如何在Java中創(chuàng)建優(yōu)雅的對象來提升程序性能
本文鏈接：http://m.5511xx.com/article/cdocoos.html