java的builder模式

太过爱你忘了你带给我的痛 2022-01-29 08:59 312阅读 0赞

什么是Builder模式：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示；

但是看完这个定义，并没有什么卵用，你依然不知道什么是Builder设计模式。在此个人的态度是学习设计模式这种东西，不要过度在意其定义，定义往往是比较抽象的，学习它最好的例子就是通过样例代码。

我们通过一个例子来引出Builder模式。假设有一个Person类，我们通过该Person类来构建一大批人，这个Person类里有很多属性，最常见的比如name，age，weight，height等等，并且我们允许这些值不被设置，也就是允许为null，该类的定义如下。

1.  `public class Person {`
2.  `private String name;`
3.  `private int age;`
4.  `private double height;`
5.  `private double weight;`
6.   
7.  `public String getName() {`
8.  `return name;`
9.  `}`
10.  
11. `public void setName(String name) {`
12. `this.name = name;`
13. `}`
14.  
15. `public int getAge() {`
16. `return age;`
17. `}`
18.  
19. `public void setAge(int age) {`
20. `this.age = age;`
21. `}`
22.  
23. `public double getHeight() {`
24. `return height;`
25. `}`
26.  
27. `public void setHeight(double height) {`
28. `this.height = height;`
29. `}`
30.  
31. `public double getWeight() {`
32. `return weight;`
33. `}`
34.  
35. `public void setWeight(double weight) {`
36. `this.weight = weight;`
37. `}`
38. `}`

然后我们为了方便可能会定义一个构造方法：

public Person(String name, int age, double height, double weight) {
    	this.name = name;
    	this.age = age;
    	this.height = height;
    	this.weight = weight;
    }

或许为了方便new对象，你还会定义一个空的构造方法

1.  `public Person() {`
2.  `}`

甚至有时候你很懒，只想传部分参数，你还会定义如下类似的构造方法。

public Person(String name) {
    	this.name = name;
    }
    
    public Person(String name, int age) {
    	this.name = name;
    	this.age = age;
    }
    
    public Person(String name, int age, double height) {
    	this.name = name;
    	this.age = age;
    	this.height = height;
    }

于是你就可以这样创建各个需要的对象

1.  `Person p1=new Person();`
2.  `Person p2=new Person("张三");`
3.  `Person p3=new Person("李四",18);`
4.  `Person p4=new Person("王五",21,180);`
5.  `Person p5=new Person("赵六",17,170,65.4);`

可以想象一下这样创建的坏处，最直观的就是四个参数的构造函数的最后面的两个参数到底是什么意思，可读性不怎么好，如果不点击看源码，鬼知道哪个是weight哪个是height。还有一个问题就是当有很多参数时，编写这个构造函数就会显得异常麻烦，这时候如果换一个角度，试试Builder模式，你会发现代码的可读性一下子就上去了。

我们给Person增加一个静态内部类Builder类，并修改Person类的构造函数，代码如下。

1.  `public class Person {`
2.  `private String name;`
3.  `private int age;`
4.  `private double height;`
5.  `private double weight;`
6.   
7.  `privatePerson(Builder builder) {`
8.  `this.name=builder.name;`
9.  `this.age=builder.age;`
10. `this.height=builder.height;`
11. `this.weight=builder.weight;`
12. `}`
13. `public String getName() {`
14. `return name;`
15. `}`
16.  
17. `public void setName(String name) {`
18. `this.name = name;`
19. `}`
20.  
21. `public int getAge() {`
22. `return age;`
23. `}`
24.  
25. `public void setAge(int age) {`
26. `this.age = age;`
27. `}`
28.  
29. `public double getHeight() {`
30. `return height;`
31. `}`
32.  
33. `public void setHeight(double height) {`
34. `this.height = height;`
35. `}`
36.  
37. `public double getWeight() {`
38. `return weight;`
39. `}`
40.  
41. `public void setWeight(double weight) {`
42. `this.weight = weight;`
43. `}`
44.  
45. `static class Builder{`
46. `private String name;`
47. `private int age;`
48. `private double height;`
49. `private double weight;`
50. `public Builder name(String name){`
51. `this.name=name;`
52. `return this;`
53. `}`
54. `public Builder age(int age){`
55. `this.age=age;`
56. `return this;`
57. `}`
58. `public Builder height(double height){`
59. `this.height=height;`
60. `return this;`
61. `}`
62.  
63. `public Builder weight(double weight){`
64. `this.weight=weight;`
65. `return this;`
66. `}`
67.  
68. `public Person build(){`
69. `return new Person(this);`
70. `}`
71. `}`
72. `}`

从上面的代码中我们可以看到，我们在Builder类里定义了一份与Person类一模一样的变量，通过一系列的成员函数进行设置属性值，但是返回值都是this，也就是都是Builder对象，最后提供了一个build函数用于创建Person对象，返回的是Person对象，对应的构造函数在Person类中进行定义，也就是构造函数的入参是Builder对象，然后依次对自己的成员变量进行赋值，对应的值都是Builder对象中的值。此外Builder类中的成员函数返回Builder对象自身的另一个作用就是让它支持链式调用，使代码可读性大大增强。

于是我们就可以这样创建Person类。

1.  `Person.Builder builder=new Person.Builder();`
2.  `Person person=builder`
3.  `.name("张三")`
4.  `.age(18)`
5.  `.height(178.5)`
6.  `.weight(67.4)`
7.  `.build();`

有没有觉得创建过程一下子就变得那么清晰了。对应的值是什么属性一目了然，可读性大大增强。

其实在Android中， Builder模式也是被大量的运用。比如常见的对话框的创建

1.  `AlertDialog.Builder builder=new AlertDialog.Builder(this);`
2.  `AlertDialog dialog=builder.setTitle("标题")`
3.  `.setIcon(android.R.drawable.ic_dialog_alert)`
4.  `.setView(R.layout.myview)`
5.  `.setPositiveButton(R.string.positive, new DialogInterface.OnClickListener() {`
6.  `@Override`
7.  `public void onClick(DialogInterface dialog, int which) {`
8.   
9.  `}`
10. `})`
11. `.setNegativeButton(R.string.negative, new DialogInterface.OnClickListener() {`
12. `@Override`
13. `public void onClick(DialogInterface dialog, int which) {`
14.  
15. `}`
16. `})`
17. `.create();`
18. `dialog.show();`

各大框架中大量的运用了Builder模式。最后总结一下

*  定义一个静态内部类Builder，内部的成员变量和外部类一样
 *  Builder类通过一系列的方法用于成员变量的赋值，并返回当前对象本身（this）
 *  Builder类提供一个build方法或者create方法用于创建对应的外部类，该方法内部调用了外部类的一个私有构造函数，该构造函数的参数就是内部类Builder
 *  外部类提供一个私有构造函数供内部类调用，在该构造函数中完成成员变量的赋值，取值为Builder对象中对应的值