Java中Builder模式的使用

今天在上课的时候老师给我们讲解了一下如何使用Builder来减少类的构造器重载，以及如何使用Builder来缓存常用对象的。

Part I

首先我们来看看以下一段代码：

1: import java.util.Date;

2:

3: public class Customer {

4:

5:     private String name;

6:     private Boolean gender;

7:     private Date birth;

8:     private Double salary;

9:

10:

11:     public Customer(String name) {

12:         this.name = name;

13:     }

14:

15:     public Customer(Boolean gender) {

16:         this.gender = gender;

17:     }

18:

19:     public Customer(Date birth, Double salary) {

20:         this.birth = birth;

21:         this.salary = salary;

22:     }

23:

24:     /*

25:      * 这里还应该有N多的构造方法被省略。

26:      */

27:

28:     public Customer(Boolean gender, Date birth, Double salary) {

29:         this.gender = gender;

30:         this.birth = birth;

31:         this.salary = salary;

32:     }

33:

34:     public Customer(String name, Boolean gender, Date birth, Double salary) {

35:         this.name = name;

36:         this.gender = gender;

37:         this.birth = birth;

38:         this.salary = salary;

39:     }

40:

41: }

看到上面的代码了吧……仅仅是四个属性就可以衍生出那么多的构造器，实在是对程序员的折磨，而且如果遇到相同类型的属性，那就会产生歧义（因为重载是根据参数列表中的参数类型来判断方法）。

接下来我们再看看下面这段代码：

1: import java.util.Date;

2:

3: public class Customer {

4:

5:     private String name;

6:     private Boolean gender;

7:     private Date birth;

8:     private Double salary;

9:

10:private Customer() {

11:         // 将构造器私有化，换句话说外部类不能实例化Customer。

12:     }

13:

14:/*

15:      * 省略了get方法

16:      */

17:

18:/**

19:      * 重写了toString方法，方便观察效果

20:      */

21:     @Override

22:     public String toString() {

23:    return "Customer [birth=" + birth + ", gender=" + gender + ", name=" + name + ", salary=" + salary + "]";

24:     }

25:

26:     public static final class CustomerBuilder {

27:    

28:         private String name;

29:         private Boolean gender;

30:         private Date birth;

31:         private Double salary;

32:

33:       public CustomerBuilder() {

34:             name = "default";

35:             gender = true;

36:             birth = new Date();

37:             salary = 0d;

38:         }

39:

40:    public Customer getCustomer() {

41:             Customer customer = new Customer();

42:             customer.name = name;

43:             customer.gender = gender;

44:             customer.birth = birth;

45:             customer.salary = salary;

46:             return customer;

47:         }

48:

49:         public CustomerBuilder setDefaultName(String name) {

50:             this.name = name;

51:             return this;

52:         }

53:

54:         public CustomerBuilder setDefaultGender(Boolean gender) {

55:             this.gender = gender;

56:             return this;

57:         }

58:

59:         public CustomerBuilder setDefaultBirth(Date birth) {

60:             this.birth = birth;

61:             return this;

62:         }

63:

64:         public CustomerBuilder setDefaultSalary(Double salary) {

65:             this.salary = salary;

66:             return this;

67:         }

68:

69:     }

70:

71: }

1: public class CustomerTester {

2:   

3:     public static void main(String[] args) {

4:    

5:         // 测试一：新建一个完全由默认值指定的对象

6:         Customer.CustomerBuilder builder = new Customer.CustomerBuilder();

7:         Customer customer = builder.getCustomer();

8:         System.out.println(customer);

9:    

10:    // 测试二：更改默认值

11:         builder.setDefaultName("Kent").setDefaultSalary(5000d); // 有点贪心

12:         Customer kent = builder.getCustomer();

13:    System.out.println(kent);

14:    

15:     }

16:

17: }

运行效果：

Customer [birth=Wed Jun 30 18:57:41 CST 2010, gender=true, name=default, salary=0.0]
Customer [birth=Wed Jun 30 18:57:41 CST 2010, gender=true, name=Kent, salary=5000.0]

通过以上的代码，我们可以看出，使用Builder来创建一个对象，可以很大程度的减少构造器的编写，并且也可以使得创建对象的时候，尽可能的减少相同参数的传递。

Part II

关于对象的缓存问题，今天老师提出了一个方案，先把今天展示的方案的代码贴出来：

1: import java.util.HashMap;

2: import java.util.Map;

3:

4: public class Grade {

5:

6:     private static Map<String, Grade> map = new HashMap<String, Grade>();

7:

8:     private String name;

9:

10:private Grade(String name) {

11:         this.name = name;

12:     }

13:

14:public static Grade getInstance(String name) {

15:         if (map.containsKey(name)) {

16:        return map.get(name);

17:    }

18:    Grade grade = new Grade(name);

19:         map.put(name, grade);

20:         return grade;

21:     }

22:

23: }

1: public class GradeTester {

2:

3:     public static void main(String[] args) {

4:    Grade grade1 = Grade.getInstance("A");

5:       Grade grade2 = Grade.getInstance("B");

6:         Grade grade3 = Grade.getInstance("A");

7:       

8:         // 结果为false，证明grade1和grade3是不同的实例对象

9:    System.out.println(grade1 == grade2);

10:    // 结果为true，证明grade1和grade3是同一个实例对象

11:         System.out.println(grade1 == grade3);

12:     }

13:

14: }

上述代码可以看出，我们已经可以把A这个等级所对应的实例对象取出来，而并不会产生两个等级相同的实例对象，这样的好处就是在同一个运行环境中只存在一个name为A的实例对象，避免重复创建相同作用的对象，减少内存开销。