如何在Java中创建优雅的对象来提升程序性能

 其实这个问题很多人都进行过解答，也有很多小伙伴在Java四大名著之一的《Effective Java》中的第1～5小节了解过，不过我还是想结合自己的理解对这个问题进行总结和归纳，谈谈为什么会最终选择构建器来实现我们的目的。

在 Java 中有多种方式可以创建对象，总结起来主要有下面的 4 种方式：

正常创建：通过 new 操作符

反射创建：调用 Class 或 java.lang.reflect.Constructor 的 newInstance()方法

克隆创建：调用现有对象的 clone()方法

发序列化：调用 java.io.ObjectInputStream 的 getObject()方法反序列化

Java 对象的创建方式是其语法明确规定，用户不可能从外部改变的。本文仍然要使用上面的方式来创建对象，所以本文只能说是构建对象，而非创建对象也。

假设有这样一个场景，现在要构建一个大型的对象，这个对象包含许多个参数的对象，有些参数有些是必填的，有些则是选填的。那么如何构建优雅、安全地构建这个对象呢?

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. // 毕业学校（选填） 
    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. // 毕业学校（选填） 
    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. // 毕业学校（选填） 
    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 对象构建的问题，使用起来非常优雅便捷。确实，在单一线程的环境中这确实是一个非常好的构建对象的方法，但是如果是在多线程环境中仍有其致命缺陷。在多线程环境中，这个对象不能安全地被构建，因为它不是不可变对象。一旦Person 对象被构建，我们随时可通过 setXXX()方法改变对象的内部状态。假设有一个线程正在执行与 Person 对象相关的业务方法，另外一个线程改变了其内部状态，这样得到莫名其妙的结果。由于线程运行的无规律性，使得这问题有可能不能重现，这个时候真的就只能哭了。

04 Builder方式

为了完美地解决这个问题，下面引出本文中的主角（等等等等！）。我们使用构建器（Builder）来优雅、安全地构建 Person 对象。废话不说，直接代码：

 
 
 
      
  
  
  1. /** 
    2.   
  
  
  2. * 待构建的对象。该对象的特点： 
    3.   
  
  
  3. * 
         
  
  
    1. * 
    2. 需要用户手动的传入多个参数，并且有多个参数是可选的、顺序随意
      3.    
  
  
    3. * 
    4. 该对象是不可变的（所谓不可变，就是指对象一旦创建完成，其内部状态不可变， 
      5.   
  
  
    5. 更通俗的说是其成员变量不可改变）。* 不可变对象本质上是线程安全的。
      6.    
  
  
    6. * 
    7. 对象所属的类不是为了继承而设计的。
      8.    
  
  
    8. * 
     
    4.   
  
  
  4. * 满足上面特点的对象的构建可是使用下面的 Build 方式构建。这样构建对象有下面的好 
    5.   
  
  
  5. 处： 
    6.   
  
  
  6. * 
         
  
  
    1. * 
    2. 不需要写多个构造函数，使得对象的创建更加便捷
      3.    
  
  
    3. * 
    4. 创建对象的过程是线程安全的
      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. // 毕业学校（选填） 
    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. 私有构造函数能够保证该对象无法从外部创建，并且 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. * 要执行的动作 
    35.   
  
  
  35. */ 
    36.   
  
  
  36. public void doSomething() { 
    37.   
  
  
  37. // TODO do what you want!! 
    38.   
  
  
  38. } 
    39.   
  
  
  39. /** 
    40.   
  
  
  40. * 构建器。为什么 Builder 是内部静态类？ 
    41.   
  
  
  41. * 
         
  
  
    1. * 
    2. 必须是 Person 的内部类。否则，由于 Person 的构造函数私有，不能通过 new 的 
      3.   
  
  
    3. 方式创建 Person 对象
      4.    
  
  
    4. * 
    5. 必须是静态类。由于 Person 对象无法从外部创建，如果不是静态类，则外部无 
      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. // 毕业学校（选填） 
    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. * 通过链式调用的方式创建 Person 对象，非常优雅！ 
    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 对 象

总结

至此，我们就相对完美地解决这一类型的对象创建问题！下面来总结一下本文的重点。待创建的对象特点：

需要用户手动的传入多个参数，并且有多个参数是可选的、顺序任意

对象不可变

对象所属的类不是为了继承而设计的。即类不能被继承

依次使用的对象构建方法：

单一构造函数

多构造函数

JavaBean 方式

Builder 方式

最终，通过比较得出 Builder 方法最为合适的解决。

文章题目：如何在Java中创建优雅的对象来提升程序性能
文章URL：http://www.shufengxianlan.com/qtweb/news18/316568.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站排名知识

各行业网站

app软件开发公司　　 　重庆服务器托管　　 　交互设计　　 　网站制作　　 　重庆网站建设　　 　网站制作　　 　品牌网站建设公司　　 　成都康明斯发电机　　 　复盛机电设备　　 　成都VI设计　　 　app开发　　 　手机网站制作　　 　路面机械及配件　　 　橡塑板　　 　成都网站建设公司　　 　尊格展览　　 　红光高低压开关厂　　 　抖音短视频　　 　绵阳服务器托管　　 　成都移动服务器托管