[关闭]
@Beeder 2017-07-06T10:11:48.000000Z 字数 15496 阅读 894

Android源码设计模式 学习笔记（三） Builder模式

android

第三章 Builder模式

3.1 定义

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

3.2 使用场景

（1）相同的方法，不同的执行顺序，产生不同的事件结果时。
（2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
（3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个使用建造者模式非常适合。
（4）当初始化一个对象特别复杂时，如参数多，且很多参数有默认值。

3.2 Builder模式 的UML类图

UML类图如图3-1所示。
角色介绍:

贴图库

3.3 简单实现

  1. public interface Builder {
  3. 　　//创建部件A　　比如创建汽车车轮
  4. 　　void buildPartA(); 
  5. 　　//创建部件B   比如创建汽车方向盘
  6. 　　void buildPartB(); 
  7. 　　//创建部件C   比如创建汽车发动机
  8. 　　void buildPartC();
  9. 　　//返回最后组装成品结果 (返回最后装配好的汽车)
  10. 　　Product getResult();
  12. }
  14. public class ConcreteBuilder implements Builder {
  16. 　　Part partA, partB, partC; 
  17. 　　public void buildPartA() {
  18. 　　　　//这里是具体如何构建partA的代码
  19. 　　}; 
  20. 　　public void buildPartB() { 
  21. 　　　　//这里是具体如何构建partB的代码
  22. 　　}; 
  23. 　　 public void buildPartC() { 
  24. 　　　　//这里是具体如何构建partB的代码
  25. 　　}; 
  26. 　　 public Product getResult() { 
  27. 　　　　//返回最后组装成品结果
  28. 　　}; 
  29. }
  31. //Director 类，负责制造
  32. public class Director {
  34. 　　private Builder builder;
  36. 　　public Director( Builder builder ) { 
  37. 　　　　this.builder = builder; 
  38. 　　} 
  39. 　　// 将部件partA partB partC最后组成复杂对象
  40. 　　//这里是将车轮 方向盘和发动机组装成汽车的过程
  41. 　　public void construct() { 
  42. 　　　　builder.buildPartA();
  43. 　　　　builder.buildPartB();
  44. 　　　　builder.buildPartC();
  46. 　　}
  48. }
  51. public interface Product { }//产品
  53. public interface Part { }//部件
  55. //调用
  56. ConcreteBuilder builder = new ConcreteBuilder();
  57. Director director = new Director(builder); 
  59. director.construct(); 
  60. Product product = builder.getResult();

3.4 总结

通常一个类拥有多个角色，将构造函数、字段私有化，把Builder写成内部类，通过builder类的setter方法设置私有函数和方法，如此封装用户就只能通过Builder对象设置属性了。
简单实例如下：

  1. //customView类
  2. public class customView {
  3.     //创建静态config对象
  4.     private int a;
  5.     private int b;
  7.     //私有构造方法
  8.     private customView(){
  9.     }
  11.     //Builder内部类
  12.     public static class Builder{
  13.         int a;
  14.         int b;
  16.         //setter方法，设置config对象参数
  17.         public Builder setA(int a){
  18.             this.a = a;
  19.             return this;
  20.         }
  21.         public Builder setB(int b){
  22.             this.b = b;
  23.             return this;
  24.         }
  26.         void applyConfig(customView view){
  27.             view.a=this.a;
  28.             view.b=this.b;
  29.         }
  31.         //返回view
  32.         public customView create(){
  33.             customView view = new customView();
  34.             applyConfig(view);
  35.             return view;
  36.         }
  38.     }   
  41. }

用户调用如下：

  1.     customView view = new customView.Builder()
  2.                         .setA(0)
  3.                         .setB(0)
  4.                         .create();

3.4 Android源码中的Builder模式

3.4.1 AlertDialog.Builder模式，通过Builder对象组装

在开发过程中，我们经常用到AlertDialog，AlertDialog.Builder就是源码中最常用到的Builder模式，具体示例如下:

  1.     private void showDialogs(Context context){
  2.         AlertDialog.Builder builder= new AlertDialog.Builder(context);
  3.         builder.setIcon(R.drawable.ic_launcher);
  4.         builder.setTitle("title");
  5.         builder.setMessage("message");
  6.         builder.setPositiveButton("Button", new DialogInterface.OnClickListener() {
  8.             @Override
  9.             public void onClick(DialogInterface dialog, int whichButton) {
  10.                 setTitle("点击了对话框上的Button");
  11.             }
  12.         }); 
  13.         builder.create().show();
  14.     }

从类名就可以看出这就是一个Builder模式，通过Builder对象组装Dialog的各个部分，如Icon、Title、Message等，将Dialog的构造和表示进行分离。相关源码如下:

  1. //路径：frameworks/base/core/java/android/app/AlertDialog.java
  3. public class AlertDialog extends Dialog implements DialogInterface {
  4.     //AlertController 接收Builder成员变量p中的各个参数  实现类
  5.     private AlertController mAlert;
  7.     //构造函数
  8.     protected AlertDialog(Context context, @StyleRes int themeResId) {
  9.         this(context, themeResId, true);
  10.     }
  12.     //构造AlertDialog
  13.     AlertDialog(Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
  14.         super(context, createContextThemeWrapper ? resolveDialogTheme(context, themeResId) : 0,createContextThemeWrapper);
  15.         mWindow.alwaysReadCloseOnTouchAttr();
  16.         //构造AlertController
  17.         mAlert = new AlertController(getContext(), this, getWindow());
  18.     }
  20.     //实际上调用的是mAlert的setTitle方法
  21.     @Override
  22.     public void setTitle(CharSequence title) {
  23.         super.setTitle(title);
  24.         mAlert.setTitle(title);
  25.     }
  27.     //实际上调用的是mAlert的setCustomTitle方法
  28.     public void setCustomTitle(View customTitleView) {
  29.         mAlert的.setCustomTitle(customTitleView);
  30.     }
  32.     public void setMessage(CharSequence message) {
  33.         mAlert.setMessage(message);
  34.     }
  36.     //省略
  40.      //AlertDialog的内部类
  41.      public static class Builder {
  42.         //1、储存AlertDialog的各个参数，Title、message、icon等
  43.         private final AlertController.AlertParams P;
  45.         //属性省略
  47.         public Builder(Context context) {
  48.             this(context, resolveDialogTheme(context, 0));
  49.         }
  51.         public Builder(Context context, int themeResId) {
  52.             P = new AlertController.AlertParams(new ContextThemeWrapper(
  53.                     context, resolveDialogTheme(context, themeResId)));
  54.         }
  57.         //Builder的其他代码省略
  58.         //2、设置各种参数
  59.         public Builder setTitle(CharSequence title) {
  60.             P.mTitle = title;
  61.             return this;
  62.         }
  63.         public Builder setMessage(@StringRes int messageId) {
  64.             P.mMessage = P.mContext.getText(messageId);
  65.             return this;
  66.         }
  67.         public Builder setIcon(Drawable icon) {
  68.             P.mIcon = icon;
  69.             return this;
  70.         }
  72.         //3、构建AlertDialog，传递参数
  73.         public AlertDialog create() {
  74.             // 4、new AlertDialog对象，并且将参数传递给AlertDialog实例dialog
  75.             // Context has already been wrapped with the appropriate theme.
  76.             final AlertDialog dialog = new AlertDialog(P.mContext, 0, false);
  77.             //5、将p中的参数应用到dialog中的mAlert对象中去
  78.             P.apply(dialog.mAlert);
  79.             dialog.setCancelable(P.mCancelable);
  80.             if (P.mCancelable) {
  81.                 dialog.setCanceledOnTouchOutside(true);
  82.             }
  83.             dialog.setOnCancelListener(P.mOnCancelListener);
  84.             dialog.setOnDismissListener(P.mOnDismissListener);
  85.             if (P.mOnKeyListener != null) {
  86.                 dialog.setOnKeyListener(P.mOnKeyListener);
  87.             }
  88.             return dialog;
  89.         }
  90.      }
  91. }

Builder类可以设置AlertDialog中的title、message、button等参数，这些参数都存储在类型为AlertController.AlertParams的变量p中,AlertController.AlertParams中包含了与AlertDialog识图中对应的成员变量。
在调用Builder类的create函数时会创建AlertDialog,并将Builder成员变量p中保存的参数应用到AlertDialog的nAlert对象中，即p.apply(dialog.mAlert)代码段。
apply函数实现如下：

  1. //代码：frameworks/base/core/java/com/android/internal/app/AlertController.java
  2. public class AlertController {
  3.     //省略
  4.     public static class AlertParams {
  5.         public void apply(AlertController dialog) {
  6.                     if (mCustomTitleView != null) {
  7.                         dialog.setCustomTitle(mCustomTitleView);
  8.                     } else {
  9.                         if (mTitle != null) {
  10.                             dialog.setTitle(mTitle);
  11.                         }
  12.                         if (mIcon != null) {
  13.                             dialog.setIcon(mIcon);
  14.                         }
  15.                         if (mIconId != 0) {
  16.                             dialog.setIcon(mIconId);
  17.                         }
  18.                         if (mIconAttrId != 0) {
  19.                             dialog.setIcon(dialog.getIconAttributeResId(mIconAttrId));
  20.                         }
  21.                     }
  22.                     if (mMessage != null) {
  23.                         dialog.setMessage(mMessage);
  24.                     }
  25.                     if (mPositiveButtonText != null) {
  26.                         dialog.setButton(DialogInterface.BUTTON_POSITIVE, mPositiveButtonText,
  27.                                 mPositiveButtonListener, null);
  28.                     }
  29.                     if (mNegativeButtonText != null) {
  30.                         dialog.setButton(DialogInterface.BUTTON_NEGATIVE, mNegativeButtonText,
  31.                                 mNegativeButtonListener, null);
  32.                     }
  33.                     if (mNeutralButtonText != null) {
  34.                         dialog.setButton(DialogInterface.BUTTON_NEUTRAL, mNeutralButtonText,
  35.                                 mNeutralButtonListener, null);
  36.                     }
  37.                     if (mForceInverseBackground) {
  38.                         dialog.setInverseBackgroundForced(true);
  39.                     }
  40.                     //如果设置了mItems，则表示是单选或多选列表，此时创建一个ListView
  41.                     // For a list, the client can either supply an array of items or an
  42.                     // adapter or a cursor
  43.                     if ((mItems != null) || (mCursor != null) || (mAdapter != null)) {
  44.                         createListView(dialog);
  45.                     }
  47.                     //将mView设置给Dialog
  48.                     if (mView != null) {
  49.                         if (mViewSpacingSpecified) {
  50.                             dialog.setView(mView, mViewSpacingLeft, mViewSpacingTop, mViewSpacingRight,
  51.                                     mViewSpacingBottom);
  52.                         } else {
  53.                             dialog.setView(mView);
  54.                         }
  55.                     } else if (mViewLayoutResId != 0) {
  56.                         dialog.setView(mViewLayoutResId);
  57.                     }
  60.                 }
  61.     }
  62. }

在apply函数中，只是将AlertParams参数设置到AlertController中。例如，将标题设置到Dialog对应的标题识图中，将Message设置到内容视图中等。当我们获取到AlertDialog对象后，通过show函数就可以显示这个对话框。
AlertDialog中相关代码如下:

  1. //路径：frameworks/base/core/java/android/app/AlertDialog.java
  2. public class AlertDialog extends Dialog implements DialogInterface {
  4.     public static class Builder {
  6.           public AlertDialog create() {
  7.                 // Context has already been wrapped with the appropriate theme.
  8.                 final AlertDialog dialog = new AlertDialog(P.mContext, 0, false);
  9.                 //将参数设置到AlertController对象dialog中
  10.                 P.apply(dialog.mAlert);
  11.                 dialog.setCancelable(P.mCancelable);
  12.                 if (P.mCancelable) {
  13.                     dialog.setCanceledOnTouchOutside(true);
  14.                 }
  15.                 dialog.setOnCancelListener(P.mOnCancelListener);
  16.                 dialog.setOnDismissListener(P.mOnDismissListener);
  17.                 if (P.mOnKeyListener != null) {
  18.                     dialog.setOnKeyListener(P.mOnKeyListener);
  19.                 }
  20.                 return dialog;
  21.             }
  23.             /**
  24.              * Creates an {@link AlertDialog} with the arguments supplied to this
  25.              * builder and immediately displays the dialog.
  26.              * <p>
  27.              * Calling this method is functionally identical to:
  28.              * <pre>
  29.              *     AlertDialog dialog = builder.create();
  30.              *     dialog.show();
  31.              * </pre>
  32.              */
  35.             public AlertDialog show() {
  36.                 final AlertDialog dialog = create();
  37.                 dialog.show();
  38.                 return dialog;
  39.             }
  40.     }
  41. }

我们再看看Dialog的show函数(该函数在Dialog类中):

  1. //路径：frameworks/base/core/java/android/app/Dialog.java
  5.     /**
  6.      * Start the dialog and display it on screen.  The window is placed in the
  7.      * application layer and opaque.  Note that you should not override this
  8.      * method to do initialization when the dialog is shown, instead implement
  9.      * that in {@link #onStart}.
  10.      */
  11.      //显示Dialog
  12.     public void show() {
  13.         if (DBG) {
  14.             Log.d(TAG, "show");
  15.         }
  16.         //已经是显示状态，则return
  17.         if (mShowing) {
  18.             if (mDecor != null) {
  19.                 if (mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
  20.                     mWindow.invalidatePanelMenu(Window.FEATURE_ACTION_BAR);
  21.                 }
  22.                 mDecor.setVisibility(View.VISIBLE);
  23.             }
  24.             return;
  25.         }
  27.         mCanceled = false;
  28.         //1、onCreate调用
  29.         if (!mCreated) {
  30.             dispatchOnCreate(null);
  31.         }
  32.         //2、onStart
  33.         onStart();
  34.         //3、获取DecorView
  35.         mDecor = mWindow.getDecorView();
  37.         //省略  
  38.         //4、获取布局参数
  39.         WindowManager.LayoutParams l = mWindow.getAttributes();
  40.         if ((l.softInputMode
  41.                 & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
  42.             WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
  43.             nl.copyFrom(l);
  44.             nl.softInputMode |=
  45.                     WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
  46.             l = nl;
  47.         }
  49.         try {  
  50.             //5、将mDecor添加到mWindowManager中
  51.             mWindowManager.addView(mDecor添加到, l);
  52.             mShowing = true;
  53.             //发送一个显示Dialog的消息
  54.             sendShowMessage();
  55.         } finally {
  56.         }
  57.     }

在show函数中主要做了如下几个事情:

很明显，这就是一系列的典型的生命周期函数。按照惯例，AlertDialog的内容视图构建按理应该在onCreate函数中，我们来看看是不是:

  1. //路径：frameworks/base/core/java/android/app/AlertDialog.java
  3. public class AlertDialog extends Dialog implements DialogInterface {
  5.    @Override
  6.     protected void onCreate(Bundle savedInstanceState) {
  7.         super.onCreate(savedInstanceState);
  8.         //调用了AlertController的installContent方法
  9.         mAlert.installContent();
  10.     }
  11. }

在onCreate函数中主要调用了AlertController的installContent方法，Dialog中的onCreate函数只是一个空实现而已，可以忽略他。那么AlertDialog的内容视图必然就在installContent函数中。

  1. //路径：frameworks/base/core/java/com/android/internal/app/AlertController.java
  3. public class AlertController {
  5.     public void installContent() {
  6.         /* We use a custom title so never request a window title */
  7.         mWindow.requestFeature(Window.FEATURE_NO_TITLE);
  8.         int contentView = selectContentView();
  9.         mWindow.setContentView(contentView);
  10.         setupView();
  11.         setupDecor();
  12.     }
  14.     private int selectContentView() {
  15.         if (mButtonPanelSideLayout == 0) {
  16.             return mAlertDialogLayout;
  17.         }
  18.         if (mButtonPanelLayoutHint == AlertDialog.LAYOUT_HINT_SIDE) {
  19.             return mButtonPanelSideLayout;
  20.         }
  21.         // TODO: use layout hint side for long messages/lists
  22.         return mAlertDialogLayout;
  23.     }
  26. }

installContent函数的代码，但极为重要，它调用了Window对象的setContentView，这个setContentView就与Activity中的一模一样，实际上Activity最终也是调用Window对象的setContentView函数。因此，这里就是设置AlertDialog的内容布局，这个布局就是mAlertDialogLayout的值。这个值在AlertController的构造函数中进行了初始化，具体代码如下:

  1. //路径：frameworks/base/core/java/com/android/internal/app/AlertController.java
  3. public class AlertController {
  5. public AlertController(Context context, DialogInterface di, Window window) {
  6.         mContext = context;
  7.         mDialogInterface = di;
  8.         mWindow = window;
  9.         mHandler = new ButtonHandler(di);
  11.         final TypedArray a = context.obtainStyledAttributes(null,
  12.                 R.styleable.AlertDialog, R.attr.alertDialogStyle, 0);
  13.         //AlertController的布局id，也就是alert_dialog.xml布局
  14.         mAlertDialogLayout = a.getResourceId(
  15.                 R.styleable.AlertDialog_layout, R.layout.alert_dialog);
  16.         mButtonPanelSideLayout = a.getResourceId(
  17.                 R.styleable.AlertDialog_buttonPanelSideLayout, 0);
  18.         mListLayout = a.getResourceId(
  19.                 R.styleable.AlertDialog_listLayout, R.layout.select_dialog);
  20.         //省略
  21.         a.recycle();
  22.     }
  23. }

从AlertController的构造函数中可以看到，AlertDialog的布局资源就是select_dialog.xml这个布局，我们直接大致看他的结构如下:
贴图库
当通过Builder对象的setTitle、setMessage等方法设置具体内容时，就是将这些内容填充到对应的视图中。而AlertDialog也允许你通过setView传入内容视图，这个内容视图就是替换掉图中的内容视图(蓝色区域)，AlertDialog预留了一个costomPanel区域用来显示用户自定义的内容视图。我们来看看setupView函数：

  1. public class AlertController {
  4.     private void setupView() {
  6.         final View parentPanel = mWindow.findViewById(R.id.parentPanel);
  7.         final View defaultTopPanel = parentPanel.findViewById(R.id.topPanel);
  8.         //1、获取内容区域
  9.         final View defaultContentPanel = parentPanel.findViewById(R.id.contentPanel);
  10.         //1、获取按钮
  11.         final View defaultButtonPanel = parentPanel.findViewById(R.id.buttonPanel);
  13.         // Install custom content before setting up the title or buttons so
  14.         // that we can handle panel overrides.
  15.         final ViewGroup customPanel = (ViewGroup) parentPanel.findViewById(R.id.customPanel);
  16.         //自定义内容视图区域
  17.         setupCustomContent(customPanel);
  19.         final View customTopPanel = customPanel.findViewById(R.id.topPanel);
  20.         final View customContentPanel = customPanel.findViewById(R.id.contentPanel);
  21.         final View customButtonPanel = customPanel.findViewById(R.id.buttonPanel);
  23.         // Resolve the correct panels and remove the defaults, if needed.
  24.         final ViewGroup topPanel = resolvePanel(customTopPanel, defaultTopPanel);
  25.         final ViewGroup contentPanel = resolvePanel(customContentPanel, defaultContentPanel);
  26.         final ViewGroup buttonPanel = resolvePanel(customButtonPanel, defaultButtonPanel);
  27.         //2、初始化内容
  28.         setupContent(contentPanel);
  29.         setupButtons(buttonPanel);
  30.         //2、初始化标题
  31.         setupTitle(topPanel);
  33.         //自定义视图可见性
  34.         final boolean hasCustomPanel = customPanel != null
  35.                 && customPanel.getVisibility() != View.GONE;
  36.         final boolean hasTopPanel = topPanel != null
  37.                 && topPanel.getVisibility() != View.GONE;
  38.         final boolean hasButtonPanel = buttonPanel != null
  39.                 && buttonPanel.getVisibility() != View.GONE;
  41.         // Only display the text spacer if we don't have buttons.
  42.         if (!hasButtonPanel) {
  43.             if (contentPanel != null) {
  44.                 final View spacer = contentPanel.findViewById(R.id.textSpacerNoButtons);
  45.                 if (spacer != null) {
  46.                     spacer.setVisibility(View.VISIBLE);
  47.                 }
  48.             }
  49.             mWindow.setCloseOnTouchOutsideIfNotSet(true);
  50.         }
  52.         if (hasTopPanel) {
  53.             // Only clip scrolling content to padding if we have a title.
  54.             if (mScrollView != null) {
  55.                 mScrollView.setClipToPadding(true);
  56.             }
  58.             // Only show the divider if we have a title.
  59.             final View divider;
  60.             if (mMessage != null || mListView != null || hasCustomPanel) {
  61.                 divider = topPanel.findViewById(R.id.titleDivider);
  62.             } else {
  63.                 divider = topPanel.findViewById(R.id.titleDividerTop);
  64.             }
  66.             if (divider != null) {
  67.                 divider.setVisibility(View.VISIBLE);
  68.             }
  69.         }
  71.         // Update scroll indicators as needed.
  72.         if (!hasCustomPanel) {
  73.             final View content = mListView != null ? mListView : mScrollView;
  74.             if (content != null) {
  75.                 final int indicators = (hasTopPanel ? View.SCROLL_INDICATOR_TOP : 0)
  76.                         | (hasButtonPanel ? View.SCROLL_INDICATOR_BOTTOM : 0);
  77.                 content.setScrollIndicators(indicators,
  78.                         View.SCROLL_INDICATOR_TOP | View.SCROLL_INDICATOR_BOTTOM);
  79.             }
  80.         }
  82.         final TypedArray a = mContext.obtainStyledAttributes(
  83.                 null, R.styleable.AlertDialog, R.attr.alertDialogStyle, 0);
  84.         //设置背景
  85.         setBackground(a, topPanel, contentPanel, customPanel, buttonPanel,
  86.                 hasTopPanel, hasCustomPanel, hasButtonPanel);
  87.         a.recycle();
  88.     }
  92.     //自定义内容视图区域
  93.     private void setupCustomContent(ViewGroup customPanel) {
  94.         final View customView;
  95.         //如果用户设置了内容视图，那么将它显示在customPanel的custom布局里面
  96.         if (mView != null) {
  97.             customView = mView;
  98.         } else if (mViewLayoutResId != 0) {
  99.             final LayoutInflater inflater = LayoutInflater.from(mContext);
  100.             customView = inflater.inflate(mViewLayoutResId, customPanel, false);
  101.         } else {
  102.             customView = null;
  103.         }
  105.         final boolean hasCustomView = customView != null;
  106.         if (!hasCustomView || !canTextInput(customView)) {
  107.             mWindow.setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
  108.                     WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
  109.         }
  111.         if (hasCustomView) {
  112.             final FrameLayout custom = (FrameLayout) mWindow.findViewById(R.id.custom);
  113.             //显示用户设置的视图
  114.             custom.addView(customView, new LayoutParams(MATCH_PARENT, MATCH_PARENT));
  116.             if (mViewSpacingSpecified) {
  117.                 custom.setPadding(
  118.                         mViewSpacingLeft, mViewSpacingTop, mViewSpacingRight, mViewSpacingBottom);
  119.             }
  121.             if (mListView != null) {
  122.                 ((LinearLayout.LayoutParams) customPanel.getLayoutParams()).weight = 0;
  123.             }
  124.         } else {
  125.             customPanel.setVisibility(View.GONE);
  126.         }
  127.     }
  129. }

这个setupView顾名思义就是初始化AlertDialog布局中的各个部分，如标题区域、按钮区域、内容区域等，在该函数调用之后整个Dialog的视图内容全部设置完毕。而这些各区域的视图都属于mAlertDialogLayout布局中的子元素，Window对象又关联了mAlertDialogLayout的整个布局树，当调用完setupView之后整个视图树的数据都填充完毕。当用户调用了show函数时，WindosManager会将Window对象的DecorView(也就是mAlertDialogLayout对应的视图)，添加到用户的窗口上，并且显示出来。至此，整个Dialog就会出现在用户的视野中了。

在AlertDialog的Builder模式中并没有看到Director角色的出现(其实在很多场景中，Android并没有按照《设计模式:可复用面向对象软件的基础》一书中描述的经典模式来实现，而是做了些修改，使得更易于使用)。这里的AlertDialog.Builder同时扮演了builder、ConcreteBuilder、Dirctor的角色，简化了Builder模式的设计。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注