码迷,mamicode.com
首页 > 其他好文 > 详细

设计模式学习-建造者模式

时间:2016-05-07 23:51:19      阅读:281      评论:0      收藏:0      [点我收藏+]

标签:

1.定义

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

2.类图

技术分享

3.代码示例

 1 package com.zhaoyangwoo.builder;
 2 
 3 /**
 4  * Created by john on 16/5/7.
 5  * 场景类
 6  */
 7 public class Builder {
 8 
 9     public static void Main(){
10         BuilderInterface bi = new ConceptBuilder();
11         Director director = new Director();
12         director.construct(bi);
13     }
14 
15 }
16 
17 /**
18  * 导演类
19  */
20 class Director {
21     Product construct(BuilderInterface bi){
22         bi.setProductPartA();
23         bi.setProductPartB();
24         return bi.getProduct();
25     }
26 }
27 
28 /**
29  * 抽象建造者
30  */
31 interface BuilderInterface{
32     void setProductPartA();
33     void setProductPartB();
34     Product getProduct();
35 }
36 
37 /**
38  * 具体建造者
39  */
40 class ConceptBuilder implements BuilderInterface{
41 
42     private Product product = new Product();
43 
44     @Override
45     public void setProductPartA() {
46         product.setName("产品A");
47     }
48 
49     @Override
50     public void setProductPartB() {
51         product.setPrice(1.111);
52     }
53 
54     @Override
55     public Product getProduct() {
56         return product;
57     }
58 }
59 
60 
61 /**
62  * 具体产品
63  */
64 class Product{
65     public String getName() {
66         return name;
67     }
68 
69     public void setName(String name) {
70         this.name = name;
71     }
72 
73     String name;
74 
75     public double getPrice() {
76         return price;
77     }
78 
79     public void setPrice(double price) {
80         this.price = price;
81     }
82 
83     double price;
84 }

 

4.应用场景举例

  • 创建更复杂对象,隔离对象创建的具体过程 

5.JAVA源码中的模式实现

  Calendar.Builder静态类就是典型的建造者模式,我们来看源码  

技术分享
 1 public Calendar build() {
 2             if (locale == null) {
 3                 locale = Locale.getDefault();
 4             }
 5             if (zone == null) {
 6                 zone = TimeZone.getDefault();
 7             }
 8             Calendar cal;
 9             if (type == null) {
10                 type = locale.getUnicodeLocaleType("ca");
11             }
12             if (type == null) {
13                 if (locale.getCountry() == "TH"
14                     && locale.getLanguage() == "th") {
15                     type = "buddhist";
16                 } else {
17                     type = "gregory";
18                 }
19             }
20             switch (type) {
21             case "gregory":
22                 cal = new GregorianCalendar(zone, locale, true);
23                 break;
24             case "iso8601":
25                 GregorianCalendar gcal = new GregorianCalendar(zone, locale, true);
26                 // make gcal a proleptic Gregorian
27                 gcal.setGregorianChange(new Date(Long.MIN_VALUE));
28                 // and week definition to be compatible with ISO 8601
29                 setWeekDefinition(MONDAY, 4);
30                 cal = gcal;
31                 break;
32             case "buddhist":
33                 cal = new BuddhistCalendar(zone, locale);
34                 cal.clear();
35                 break;
36             case "japanese":
37                 cal = new JapaneseImperialCalendar(zone, locale, true);
38                 break;
39             default:
40                 throw new IllegalArgumentException("unknown calendar type: " + type);
41             }
42             cal.setLenient(lenient);
43             if (firstDayOfWeek != 0) {
44                 cal.setFirstDayOfWeek(firstDayOfWeek);
45                 cal.setMinimalDaysInFirstWeek(minimalDaysInFirstWeek);
46             }
47             if (isInstantSet()) {
48                 cal.setTimeInMillis(instant);
49                 cal.complete();
50                 return cal;
51             }
52 
53             if (fields != null) {
54                 boolean weekDate = isSet(WEEK_YEAR)
55                                        && fields[WEEK_YEAR] > fields[YEAR];
56                 if (weekDate && !cal.isWeekDateSupported()) {
57                     throw new IllegalArgumentException("week date is unsupported by " + type);
58                 }
59 
60                 // Set the fields from the min stamp to the max stamp so that
61                 // the fields resolution works in the Calendar.
62                 for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
63                     for (int index = 0; index <= maxFieldIndex; index++) {
64                         if (fields[index] == stamp) {
65                             cal.set(index, fields[NFIELDS + index]);
66                             break;
67                         }
68                     }
69                 }
70 
71                 if (weekDate) {
72                     int weekOfYear = isSet(WEEK_OF_YEAR) ? fields[NFIELDS + WEEK_OF_YEAR] : 1;
73                     int dayOfWeek = isSet(DAY_OF_WEEK)
74                                     ? fields[NFIELDS + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
75                     cal.setWeekDate(fields[NFIELDS + WEEK_YEAR], weekOfYear, dayOfWeek);
76                 }
77                 cal.complete();
78             }
79 
80             return cal;
81         }
View Code

  另外StringBuilder也同样是建造者模式的典型应用

6.思考

  • 建造者模式和工厂模式
   两者非常相似,把握异同的关键点在于:建造者关注的是基本方法(零件)的组装顺序,所有基本操作都已经实现。而工厂模式关注的是零件的创建。
  

   技术分享


  • 建造者模式和模版方法模式

    1.这两个模式解决问题的类型不一样,建造者模式是创建对象,模版方法是将实现推迟到子类中

     2.如果建造者模式省掉导演类,那么builder构建方法就应该是模版方法

7.参考

  1.模板方法模式VS建造者模式

  2.建造者模式

 

设计模式学习-建造者模式

标签:

原文地址:http://www.cnblogs.com/zhaoyanghoo/p/5463775.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!