android中的自定义封装易用的Dialog

这几天在写dialog，从网上找到了比较好的文章供自己学习。

原文地址：http://blog.csdn.net/u013064109/article/details/51990526

整体思路:定义一个类然后去继承Dialog类，然后重写相应的构造器方法．大家都知道一般的对话框的创建过程都是来一个AlertDialog.Builder对象，然后使用一些set方法来设置标题内容以及设置一些自定义的view和点击的Button以及相应的点击事件并且可以采用链式编程一连串设置一些属性．但是有没有想过这些都是套路，都是很多类似的操作，只是数据不一样而已．以至于如果在一个项目中用到多次对话框，可能对话框样式有一些不一样，难道我们每一个对话框都要去走一个类似甚至相同的操作吗？这样貌似代码的冗余太强了．所以既然学了面向对象编程思想，我们不妨来试着封装一下，并且可以简化代码和实现复用代码,可以实现一次封装，以后只要拿来用即可．

既然要使用封装的面向对象思想，为了更好地体现封装优点，我们就一起来对比一下一般正常的套路和使用封装的不一样的套路两种方式实现:

首先，我们需要简单定义一下对话框的样式(注意:自定义对话框样式思想来源于网上的一名大神，必须尊重别人成果，然后个人在其基础上更多加入了封装使得使用起来非常方便)，先定义一个主题styles.xml:

[html] view plain copy print ?

1. <resources>  
2.   
3.     <!-- Base application theme. -->  
4.     <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">  
5.         <!-- Customize your theme here. -->  
6.         <item name="colorPrimary">@color/colorPrimary</item>  
7.         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>  
8.         <item name="colorAccent">@color/colorAccent</item>  
9.     </style>  
10.     <style name="text_18_ffffff">  
11.         <item name="android:textSize">18.0dip</item>  
12.         <item name="android:textColor">#ffffffff</item>  
13.     </style>  
14.   
15.     <style name="text_16_666666">  
16.         <item name="android:textSize">16.0dip</item>  
17.         <item name="android:textColor">#ff666666</item>  
18.     </style>  
19.   
20.     <style name="sdw_white">  
21.         <item name="android:shadowColor">#7fffffff</item>  
22.         <item name="android:shadowDx">0.0</item>  
23.         <item name="android:shadowDy">0.65</item>  
24.         <item name="android:shadowRadius">1.0</item>  
25.     </style>  
26.   
27.     <style name="sdw_79351b">  
28.         <item name="android:shadowColor">#ff79351b</item>  
29.         <item name="android:shadowDx">0.0</item>  
30.         <item name="android:shadowDy">1.0</item>  
31.         <item name="android:shadowRadius">1.0</item>  
32.     </style>  
33.   
34.     <style name="text_15_ffffff_sdw" parent="@style/sdw_79351b">  
35.         <item name="android:textSize">15.0dip</item>  
36.         <item name="android:textColor">#ffffffff</item>  
37.     </style>  
38.   
39.     <style name="text_15_666666_sdw" parent="@style/sdw_white">  
40.         <item name="android:textSize">15.0dip</item>  
41.         <item name="android:textColor">#ff666666</item>  
42.     </style>  
43.   
44.     <style name="Dialog" parent="android:style/Theme.Dialog">  
45.         <item name="android:background">#00000000</item>  
46.         <item name="android:windowBackground">@android:color/transparent</item>  
47.         <item name="android:windowNoTitle">true</item>  
48.         <item name="android:windowIsFloating">true</item>  
49.     </style>  
50.     <style name="weekName">  
51.         <item name="android:layout_width">0.0dip</item>  
52.         <item name="android:layout_height">wrap_content</item>  
53.         <item name="android:layout_gravity">center</item>  
54.         <item name="android:layout_weight">1.0</item>  
55.         <item name="android:gravity">center</item>  
56.         <item name="android:textColor">#ffffffff</item>  
57.         <item name="android:textSize">14sp</item>  
58.     </style>  
59.   
60.     <style name="main_bar_text_style">  
61.         <item name="android:textColor">#ffffffff</item>  
62.         <item name="android:textStyle">bold</item>  
63.         <item name="android:textSize">18sp</item>  
64.     </style>  
65. </resources>  

再来四个drawable资源文件，两个是确定和取消按钮的样式，其他的两个用于弹出框整体浮层的背景和对话框整体的一个样式

[html] view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <selector  
3.   xmlns:android="http://schemas.android.com/apk/res/android">  
4.     <item android:state_pressed="true"  
5.         android:drawable="@drawable/btn_ok_pressed" />  
6.     <item android:drawable="@drawable/btn_ok_normal" />  
7. </selector>  

[html] view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <selector  
3.   xmlns:android="http://schemas.android.com/apk/res/android">  
4.     <item android:state_enabled="true" android:state_pressed="true" android:drawable="@drawable/btn_cancel_pressed" />  
5.     <item android:state_enabled="true" android:drawable="@drawable/btn_cancel_normal" />  
6. </selector>  

[html] view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <layer-list  
3.   xmlns:android="http://schemas.android.com/apk/res/android">  
4.     <item>  
5.         <shape android:shape="rectangle">  
6.             <gradient android:startColor="#ffe7e7e7" android:endColor="#ffe7e7e7" android:angle="0.0" />  
7.             <corners android:topLeftRadius="0.0dip" android:topRightRadius="0.0dip" android:bottomLeftRadius="5.0px" android:bottomRightRadius="5.0px" />  
8.         </shape>  
9.     </item>  
10. </layer-list>  

[html] view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <shape xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:shape="rectangle" >  
4.   
5.     <solid android:color="#56abe4" />  
6.   
7.     <stroke  
8.         android:width="0.5dp"  
9.         android:color="#56abe4" />  
10.   
11.     <corners android:radius="15dp" />  
12.   
13. </shape>  

布局文件:

[html] view plain copy print ?

1. <pre name="code" class="html"><?xml version="1.0" encoding="utf-8"?>  
2. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="fill_parent"  
4.     android:layout_height="fill_parent"  
5.     android:clickable="true"  
6.     android:orientation="vertical"  
7.     android:padding="20.0dip" >  
8.   
9.     <LinearLayout  
10.         android:layout_width="fill_parent"  
11.         android:layout_height="wrap_content"  
12.         android:layout_gravity="center"  
13.         android:background="@drawable/bg_bombbox"  
14.         android:orientation="vertical" >  
15.   
16.         <TextView  
17.             android:id="@+id/title"  
18.             style="@style/text_18_ffffff"  
19.             android:layout_width="fill_parent"  
20.             android:layout_height="40.0dip"  
21.             android:gravity="center"  
22.             android:text="@string/title_alert"  
23.             android:visibility="visible" />  
24.   
25.         <LinearLayout  
26.             android:id="@+id/content"  
27.             android:layout_width="fill_parent"  
28.             android:layout_height="wrap_content"  
29.             android:gravity="center" >  
30.   
31.             <TextView  
32.                 android:id="@+id/message"  
33.                 style="@style/text_16_666666"  
34.                 android:layout_width="fill_parent"  
35.                 android:layout_height="wrap_content"  
36.                 android:gravity="left|center"  
37.                 android:lineSpacingMultiplier="1.5"  
38.                 android:minHeight="120.0dip"  
39.                 android:paddingBottom="15.0dip"  
40.                 android:paddingLeft="20.0dip"  
41.                 android:paddingRight="20.0dip"  
42.                 android:paddingTop="15.0dip" />  
43.         </LinearLayout>  
44.   
45.         <View  
46.             android:layout_width="fill_parent"  
47.             android:layout_height="1.0px"  
48.             android:background="#ffd0d0d0" />  
49.   
50.         <LinearLayout  
51.             android:layout_width="fill_parent"  
52.             android:layout_height="60.0dip"  
53.             android:layout_gravity="bottom"  
54.             android:background="@drawable/dialog_bottom_bg"  
55.             android:gravity="center"  
56.             android:orientation="horizontal" >  
57.   
58.             <Button  
59.                 android:id="@+id/positiveButton"  
60.                 style="@style/text_15_ffffff_sdw"  
61.                 android:layout_width="114.0dip"  
62.                 android:layout_height="40.0dip"  
63.                 android:background="@drawable/btn_ok_selector"  
64.                 android:gravity="center"  
65.                 android:text="@string/ok" />  
66.   
67.             <Button  
68.                 android:id="@+id/negativeButton"  
69.                 style="@style/text_15_666666_sdw"  
70.                 android:layout_width="114.0dip"  
71.                 android:layout_height="40.0dip"  
72.                 android:layout_marginLeft="20.0dip"  
73.                 android:background="@drawable/btn_cancel_selector"  
74.                 android:gravity="center"  
75.                 android:text="@string/cancel" />  
76.         </LinearLayout>  
77.     </LinearLayout>  
78.   
79. </FrameLayout>  

当然你可以去自定义你的对话框的样式和布局，可以根据个人喜好来定，但是这不是今天的重点．

CustomDialog自定义View类:

[java] view plain copy print ?

1. package com.mikyou.myguardian.myview;  
2.   
3. import android.app.Dialog;  
4. import android.content.Context;  
5. import android.content.DialogInterface;  
6. import android.view.LayoutInflater;  
7. import android.view.View;  
8. import android.view.ViewGroup.LayoutParams;  
9. import android.widget.Button;  
10. import android.widget.LinearLayout;  
11. import android.widget.TextView;  
12.   
13.   
14.   
15. public class CustomDialog extends Dialog {  
16.   
17.     public CustomDialog(Context context) {  
18.         super(context);  
19.     }  
20.   
21.     public CustomDialog(Context context, int theme) {  
22.         super(context, theme);  
23.     }  
24.   
25.     public static class Builder {  
26.         private Context context;  
27.         private String title;  
28.         private String message;  
29.         private String positiveButtonText;  
30.         private String negativeButtonText;  
31.         private View contentView;  
32.         private OnClickListener positiveButtonClickListener;  
33.         private OnClickListener negativeButtonClickListener;  
34.   
35.         public Builder(Context context) {  
36.             this.context = context;  
37.         }  
38.   
39.         public Builder setMessage(String message) {  
40.             this.message = message;  
41.             return this;  
42.         }  
43.   
44.         /** 
45.          * Set the Dialog message from resource 
46.          *  
47.          * @param title 
48.          * @return 
49.          */  
50.         public Builder setMessage(int message) {  
51.             this.message = (String) context.getText(message);  
52.             return this;  
53.         }  
54.   
55.         /** 
56.          * Set the Dialog title from resource 
57.          *  
58.          * @param title 
59.          * @return 
60.          */  
61.         public Builder setTitle(int title) {  
62.             this.title = (String) context.getText(title);  
63.             return this;  
64.         }  
65.   
66.         /** 
67.          * Set the Dialog title from String 
68.          *  
69.          * @param title 
70.          * @return 
71.          */  
72.   
73.         public Builder setTitle(String title) {  
74.             this.title = title;  
75.             return this;  
76.         }  
77.   
78.         public Builder setContentView(View v) {  
79.             this.contentView = v;  
80.             return this;  
81.         }  
82.   
83.         /** 
84.          * Set the positive button resource and it's listener 
85.          *  
86.          * @param positiveButtonText 
87.          * @return 
88.          */  
89.         public Builder setPositiveButton(int positiveButtonText,  
90.                 OnClickListener listener) {  
91.             this.positiveButtonText = (String) context  
92.                     .getText(positiveButtonText);  
93.             this.positiveButtonClickListener = listener;  
94.             return this;  
95.         }  
96.   
97.         public Builder setPositiveButton(String positiveButtonText,  
98.                 OnClickListener listener) {  
99.             this.positiveButtonText = positiveButtonText;  
100.             this.positiveButtonClickListener = listener;  
101.             return this;  
102.         }  
103.   
104.         public Builder setNegativeButton(int negativeButtonText,  
105.                 OnClickListener listener) {  
106.             this.negativeButtonText = (String) context  
107.                     .getText(negativeButtonText);  
108.             this.negativeButtonClickListener = listener;  
109.             return this;  
110.         }  
111.   
112.         public Builder setNegativeButton(String negativeButtonText,  
113.                 OnClickListener listener) {  
114.             this.negativeButtonText = negativeButtonText;  
115.             this.negativeButtonClickListener = listener;  
116.             return this;  
117.         }  
118.   
119.         public CustomDialog create() {  
120.             LayoutInflater inflater = (LayoutInflater) context  
121.                     .getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
122.             // instantiate the dialog with the custom Theme  
123.             final CustomDialog dialog = new CustomDialog(context, R.style.Dialog);  
124.             View layout = inflater.inflate(R.layout.dialog_normal_layout, null);  
125.             dialog.addContentView(layout, new LayoutParams(  
126.                     LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT));  
127.             // set the dialog title  
128.             ((TextView) layout.findViewById(R.id.title)).setText(title);  
129.             // set the confirm button  
130.             if (positiveButtonText != null) {  
131.                 ((Button) layout.findViewById(R.id.positiveButton))  
132.                         .setText(positiveButtonText);  
133.                 if (positiveButtonClickListener != null) {  
134.                     ((Button) layout.findViewById(R.id.positiveButton))  
135.                             .setOnClickListener(new View.OnClickListener() {  
136.                                 public void onClick(View v) {  
137.                                     positiveButtonClickListener.onClick(dialog,  
138.                                             DialogInterface.BUTTON_POSITIVE);  
139.                                 }  
140.                             });  
141.                 }  
142.             } else {  
143.                 // if no confirm button just set the visibility to GONE  
144.                 layout.findViewById(R.id.positiveButton).setVisibility(  
145.                         View.GONE);  
146.             }  
147.             // set the cancel button  
148.             if (negativeButtonText != null) {  
149.                 ((Button) layout.findViewById(R.id.negativeButton))  
150.                         .setText(negativeButtonText);  
151.                 if (negativeButtonClickListener != null) {  
152.                     ((Button) layout.findViewById(R.id.negativeButton))  
153.                             .setOnClickListener(new View.OnClickListener() {  
154.                                 public void onClick(View v) {  
155.                                     negativeButtonClickListener.onClick(dialog,  
156.                                             DialogInterface.BUTTON_NEGATIVE);  
157.                                 }  
158.                             });  
159.                 }  
160.             } else {  
161.                 // if no confirm button just set the visibility to GONE  
162.                 layout.findViewById(R.id.negativeButton).setVisibility(  
163.                         View.GONE);  
164.             }  
165.             // set the content message  
166.             if (message != null) {  
167.                 ((TextView) layout.findViewById(R.id.message)).setText(message);  
168.             } else if (contentView != null) {  
169.                 // if no message set  
170.                 // add the contentView to the dialog body  
171.                 ((LinearLayout) layout.findViewById(R.id.content))  
172.                         .removeAllViews();  
173.                 ((LinearLayout) layout.findViewById(R.id.content)).addView(  
174.                         contentView, new LayoutParams(  
175.                                 LayoutParams.FILL_PARENT,  
176.                                 LayoutParams.FILL_PARENT));  
177.             }  
178.             dialog.setContentView(layout);  
179.             return dialog;  
180.         }  
181.   
182.     }  
183. }  

到这里一个自定义View大体工作就完成了，可以测试了，然后通过测试编码过程然后一步一步优化即可．

测试Activity的布局只有三个Button,用于点击后弹出三个不一样的对话框，所以布局很简单就贴了，那么我们还是来一起看下MainActivity

这种使用一般普通的方法．

[java] view plain copy print ?

1. package com.mikyou.dialogdemo;  
2.   
3. import android.content.DialogInterface;  
4. import android.os.Bundle;  
5. import android.support.v7.app.AppCompatActivity;  
6. import android.view.View;  
7. import android.widget.Toast;  
8.   
9. import com.mikyou.dialogdemo.myview.CustomDialog;  
10.   
11. public class MainActivity extends AppCompatActivity {  
12.   
13.     public void dialog1(View view){//弹出第一个对话框  
14.         CustomDialog.Builder dialog=new CustomDialog.Builder(this);  
15.         dialog.setTitle("测试一")  
16.                 .setMessage("普通文本提示信息对话框")  
17.                 .setPositiveButton("确定", new DialogInterface.OnClickListener() {  
18.                     @Override  
19.                     public void onClick(DialogInterface dialogInterface, int i) {  
20.                         dialogInterface.dismiss();  
21.                         Toast.makeText(MainActivity.this, "确定", Toast.LENGTH_SHORT).show();  
22.                     }  
23.                 }).setNegativeButton("取消", new DialogInterface.OnClickListener() {  
24.             @Override  
25.             public void onClick(DialogInterface dialogInterface, int i) {  
26.                 dialogInterface.dismiss();  
27.                 Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
28.             }  
29.         }).create().show();  
30.     }  
31.     public void dialog2(View view){//弹出第二个对话框  
32.         CustomDialog.Builder dialog=new CustomDialog.Builder(this);  
33.         dialog.setTitle("测试二")  
34.                 .setMessage("密码错误")  
35.                 .setPositiveButton("重新输入", new DialogInterface.OnClickListener() {  
36.                     @Override  
37.                     public void onClick(DialogInterface dialogInterface, int i) {  
38.                         dialogInterface.dismiss();  
39.                         Toast.makeText(MainActivity.this, "重新输入", Toast.LENGTH_SHORT).show();  
40.                     }  
41.                 }).setNegativeButton("取消", new DialogInterface.OnClickListener() {  
42.             @Override  
43.             public void onClick(DialogInterface dialogInterface, int i) {  
44.                 dialogInterface.dismiss();  
45.                 Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
46.             }  
47.         }).create().show();  
48.     }  
49.     public void dialog3(View view){//弹出第三个对话框  
50.         View customView =View.inflate(this,R.layout.input_text_dialog,null);  
51.         CustomDialog.Builder dialog=new CustomDialog.Builder(this);  
52.         dialog.setTitle("测试三带有自定义View的布局")  
53.                 .setContentView(customView)//设置自定义customView  
54.                 .setPositiveButton("确定", new DialogInterface.OnClickListener() {  
55.                     @Override  
56.                     public void onClick(DialogInterface dialogInterface, int i) {  
57.                         dialogInterface.dismiss();  
58.                         Toast.makeText(MainActivity.this, "确定", Toast.LENGTH_SHORT).show();  
59.                     }  
60.                 }).setNegativeButton("取消", new DialogInterface.OnClickListener() {  
61.             @Override  
62.             public void onClick(DialogInterface dialogInterface, int i) {  
63.                 dialogInterface.dismiss();  
64.                 Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
65.             }  
66.         }).create().show();  
67.     }  
68.     @Override  
69.     protected void onCreate(Bundle savedInstanceState) {  
70.         super.onCreate(savedInstanceState);  
71.         setContentView(R.layout.activity_main);  
72.         initView();  
73.     }  
74.   
75.     private void initView() {  
76.     }  
77. }  

运行结果:

注意：我们可以很清楚从测试的activity中可以发现，这三个方法中的代码几乎是一样的，只是设置内容和布局不一样，写了这么多代码实际上更多是的毫无技术含量，有的人说不碍事粘贴复制呗，粘贴复制这种最傻的方式我们就不说了．所以我们能不能想想将他们共同的部分抽取出来，把不一样或者会变化的内容作为参数传进去．

封装的思路:

看到这个第一时间就是写一个类利用设计模式中的组合模式的思想，在我们的自定义的类中保存CustomDialog引用，然后就去操作这个类．

然后仔细想下需要注意几点:

第一点，我们可以看到确定和取消按钮都有一个点击事件的回调监听器，这个监听器的设计的初衷就是为了让用户点击确定后去实现确定的逻辑代码，点击取消后去实现取消的逻辑代码，所以必须将该接口抛给用户去处理，因为确定和取消后的逻辑并不是我们所能控制的．所以最后就可以得出就是我们必须要去自定义一个事件监听器，让我们自定义这个监听器去绑定和联系确定和取消点击事件，也就是可以理解为把原来在确定和取消点击事件做的业务逻辑委派给我们自己定义事件监听器统一管理和操作．

第二点，就是传数据，具体要传入哪些数据呢？这不是我说了算，也不是你说了算，而是根据里面逻辑具体需要什么，并且传入数据是变化的不是固定的．

所以我们就可以大概罗列一下需要哪些参数:

　　　　　　　　　　　　　　　　　１,首先上下文对象context(因为在初始化CustomDialog.Builder对象需要,以及如果传入一个自定布局加载成一个view对象的时候需要上下文对象)

                                                              2,然后就是传入标题(title),内容(message),布局id，这里需要注意一下，就是message和布局id(用于自定义view对话框)是互斥关系

也就是设置了内容再去设置布局id的view后者是无效有冲突．所以，我们也很容易想到一点就是初始化我们的这个封装的对话框应该有两种方式分别是文本类型和自定义view界面类型，实际上也就引出了我们这个自定义的类中应该两个构造器重载，一个用与初始化文本类型，一个是用于自定义view类型，然后还需要传入两个button需要显示文本内容

第三点，就是是否暴露一些数据接口用于方便用户后期的操作，这里有时候不要，看实际情况．仔细想想我们这里需要吗？实际上是需要就是我们在使用自定义view的对象，因为我们有时候需要去操作自定义布局中的一些控件，就比如上面最后例子就是输入密码，可能我们需要获得EditText中的内容，首先需要拿到EditText对象，所以需要传出一个自定义布局的view对象，所以我就提供一个setter和getter方法留给外部用户使用，这里为了后面的使用方便我就把这个view对象使用回调方法将其回调出去．

那么具体来看下代码的实现:

[java] view plain copy print ?

1. package com.mikyou.dialogdemo.myview;  
2.   
3. import android.content.Context;  
4. import android.content.DialogInterface;  
5. import android.view.View;  
6. import android.widget.Toast;  
7.   
8. /** 
9.  * @自定义封装的通用对话框:MikyouCommonDialog 
10.  * 
11.  * Created by mikyou on 16-7-21. 
12.  * @param dialogTitle 对话框的标题 
13.  * @param dialogMessage 对话框的内容 
14.  * @param positiveText 表示是确定意图的按钮上text文本 
15.  * @param negativeText 表示是取消意图的按钮上text文本 
16.  * @param customeLayoutId 对话框自定义布局的id 若没有自定义布局　　默认传入0 
17.  * @param context 上下文对象 
18.  * @param dialogView 自定义布局的View对象,提供被外界访问的接口get和set方法,并且利用自定义的监听器将view对象回调出去 
19.  * @param listener 监听器　用于将确定和取消意图的两个点击事件监听器，合成一个监听器，并传入一个标记变量区别确定和取消意图 
20.  */  
21. public class MikyouCommonDialog {  
22.     private Context context;  
23.     private int customeLayoutId;  
24.     private String dialogTitle;  
25.     private String dialogMessage;  
26.     private String positiveText;  
27.     private String negativeText;  
28.   
29.     private View dialogView;  
30.     private OnDialogListener listener;  
31.     //带有自定义view的构造器  
32.     public MikyouCommonDialog(Context context, int customeLayoutId, String dialogTitle, String positiveText, String negativeText) {  
33.         this.context = context;  
34.         this.customeLayoutId = customeLayoutId;  
35.         this.dialogTitle = dialogTitle;  
36.         this.positiveText = positiveText;  
37.         this.negativeText = negativeText;  
38.         this.dialogView=View.inflate(context,customeLayoutId,null);  
39.     }  
40.     //不带自定义view的构造器  
41.     public MikyouCommonDialog(Context context, String dialogMessage,String dialogTitle, String positiveText, String negativeText) {  
42.         this.context = context;  
43.         this.dialogTitle = dialogTitle;  
44.         this.dialogMessage = dialogMessage;  
45.         this.positiveText = positiveText;  
46.         this.negativeText = negativeText;  
47.     }  
48.   
49.     public View getDialogView() {  
50.         return dialogView;  
51.     }  
52.   
53.     public void setDialogView(View dialogView) {  
54.         this.dialogView = dialogView;  
55.     }  
56.   
57.     public void showDialog(){  
58.         CustomDialog.Builder dialog=new CustomDialog.Builder(context);  
59.         dialog.setTitle(dialogTitle);//设置标题  
60.         //注意:dialogMessage和dialogView是互斥关系也就是dialogMessage存在dialogView就不存在,dialogView不存在dialogMessage就存在  
61.         if (dialogMessage!=null){  
62.             Toast.makeText(context, "sddsdsds", Toast.LENGTH_SHORT).show();  
63.             dialog.setMessage(dialogMessage);//设置对话框内容  
64.         }else{  
65.   
66.             dialog.setContentView(dialogView);//设置对话框的自定义view对象  
67.         }  
68.         /** 
69.          * 尽管有两个点击事件监听器,可以通过我们自定义的监听器设置一个标记变量,从而可以实现将两个点击事件合并成一个 
70.          * 监听器OnDialogListener 
71.          * */  
72.         //确定意图传入positive标记值  
73.         dialog.setPositiveButton(positiveText, new DialogInterface.OnClickListener() {  
74.             @Override  
75.             public void onClick(DialogInterface dialogInterface, int which) {  
76.                 dialogInterface.dismiss();  
77.                 if (listener!=null){  
78.                     listener.dialogListener("positive",dialogView,dialogInterface,which);  
79.                 }  
80.             }  
81.             //取消意图传入negative标记值  
82.         }).setNegativeButton(negativeText, new DialogInterface.OnClickListener() {  
83.             @Override  
84.             public void onClick(DialogInterface dialogInterface, int which) {  
85.                 dialogInterface.dismiss();  
86.                 if (listener!=null){  
87.                     listener.dialogListener("negative",dialogView,dialogInterface,which);  
88.                 }  
89.             }  
90.         }).create().show();  
91.     }  
92.     //注册监听器方法  
93.     public MikyouCommonDialog setOnDiaLogListener(OnDialogListener listener){  
94.         this.listener=listener;  
95.         return this;//把当前对象返回,用于链式编程  
96.     }  
97.     //定义一个监听器接口  
98.     public interface OnDialogListener{  
99.         //customView　这个参数需要注意就是如果没有自定义view,那么它则为null  
100.         public void dialogListener(String btnType, View customView, DialogInterface dialogInterface, int which);  
101.     }  
102. }  

实现方式:

[java] view plain copy print ?

1. private void popInputPwdDialog() {  
2.       new MikyouCommonDialog(this,R.layout.input_pwd_dialog,"输入安全密码","确定","取消")  
3.               .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
4.                   @Override  
5.                   public void dialogListener(String btnType, View customView, DialogInterface dialogInterface, int which) {  
6.                       switch (btnType){  
7.                           case "positive"://点击确定按钮的操作  
8.                               EditText eTPwd=(EditText) customView.findViewById(R.id.input_pwd);  
9.                               checkAndSavePwd("input",eTPwd.getText().toString(),"");  
10.                               break;  
11.                           case "negative"://点击取消按钮的操作  
12.                               break;  
13.                       }  
14.                   }  
15.               }).showDialog();  
16.   
17.   }  

测试的Activity那么我们一起来对比一下封装后的代码:

[java] view plain copy print ?

1. package com.mikyou.dialogdemo;  
2.   
3. import android.content.DialogInterface;  
4. import android.os.Bundle;  
5. import android.support.v7.app.AppCompatActivity;  
6. import android.view.View;  
7. import android.widget.Toast;  
8.   
9. import com.mikyou.dialogdemo.myview.MikyouCommonDialog;  
10.   
11. public class MainActivity extends AppCompatActivity {  
12.   
13.     public void dialog1(View view){//弹出第一个对话框  
14.    new MikyouCommonDialog(this,"普通文本提示信息对话框","测试一","确定","取消")  
15.            .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
16.                @Override  
17.                public void dialogListener(String btnType, View customView, DialogInterface dialogInterface, int which) {  
18.                    switch (btnType){  
19.                        case "positive":  
20.                            Toast.makeText(MainActivity.this, "确定", Toast.LENGTH_SHORT).show();  
21.                            break;  
22.                        case "negative":  
23.                            Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
24.                            break;  
25.                    }  
26.                }  
27.            }).showDialog();  
28.     }  
29.     public void dialog2(View view){//弹出第二个对话框  
30.        new MikyouCommonDialog(this,"密码错误","测试二","重新输入","取消")  
31.                .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
32.                    @Override  
33.                    public void dialogListener(String btnType, View customView, DialogInterface dialogInterface, int which) {  
34.                        switch (btnType){  
35.                            case "positive":  
36.                                Toast.makeText(MainActivity.this, "重新输入", Toast.LENGTH_SHORT).show();  
37.                                break;  
38.                            case "negative":  
39.                                Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
40.                                break;  
41.                        }  
42.                    }  
43.                }).showDialog();  
44.     }  
45.    public void dialog3(View view){//弹出第三个对话框  
46.        new MikyouCommonDialog(this,R.layout.input_text_dialog,"测试三带有自定义View的布局","确定","取消")  
47.                .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
48.                    @Override  
49.                    public void dialogListener(String btnType, View customView, DialogInterface dialogInterface, int which) {  
50.                        switch (btnType){  
51.                            case "positive":  
52.                                Toast.makeText(MainActivity.this, "确定", Toast.LENGTH_SHORT).show();  
53.                                break;  
54.                            case "negative":  
55.                                Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
56.                                break;  
57.                        }  
58.                    }  
59.                }).showDialog();  
60.    }  
61.     @Override  
62.     protected void onCreate(Bundle savedInstanceState) {  
63.         super.onCreate(savedInstanceState);  
64.         setContentView(R.layout.activity_main);  
65.         initView();  
66.     }  
67.   
68.     private void initView() {  
69.     }  
70. }  

是不是感觉比开始那种最原始方法要好些，代码逻辑更清晰些．我们现在的这种封装还能进一步优化吗？我们都知道封装思想在于什么，在于用户外部接口调用传入数据不一样进行操作不一样，但是整个封装的框架是一样的．所以仔细观察一下上面的代码，是不是会发现那三个方法中的switch显得很鸡肋，因为在三个方法中还需要去判断是否是确定还是取消类型，并且在封装类里面我们还得把标记的字符串变量通过回调方法回调出来，感觉就有点多此一举了．

优化思想:

            就是我们不需要传入标记变量并且不需要在外部调用的时候使用switch来判断，而是采用两个回调方法，一个是确定类型的回调方法，另一个则是取消类型的回调方法．然后分别在不同类型回调方法实现各自的业务逻辑．这种方式实际上最原始那种方式也就是这样处理．

看下优化的代码:

[java] view plain copy print ?

1. package com.mikyou.myguardian.myview;  
2.   
3. import android.content.Context;  
4. import android.content.DialogInterface;  
5. import android.view.View;  
6.   
7. /** 
8.  * @自定义封装的通用对话框:MikyouCommonDialog 
9.  * 
10.  * Created by mikyou on 16-7-21. 
11.  * @param dialogTitle 对话框的标题 
12.  * @param dialogMessage 对话框的内容 
13.  * @param positiveText 表示是确定意图的按钮上text文本 
14.  * @param negativeText 表示是取消意图的按钮上text文本 
15.  * @param customeLayoutId 对话框自定义布局的id 若没有自定义布局　　默认传入0 
16.  * @param context 上下文对象 
17.  * @param dialogView 自定义布局的View对象,提供被外界访问的接口get和set方法,并且利用自定义的监听器将view对象回调出去 
18.  * @param listener 监听器　用于将确定和取消意图的两个点击事件监听器，合成一个监听器，并传入一个标记变量区别确定和取消意图 
19.  */  
20. public class MikyouCommonDialog2 {  
21.     private Context context;  
22.     private int customeLayoutId;  
23.     private String dialogTitle;  
24.     private String dialogMessage;  
25.     private String positiveText;  
26.     private String negativeText;  
27.   
28.     private View dialogView;  
29.     private OnDialogListener listener;  
30.     //带有自定义view的构造器  
31.     public MikyouCommonDialog2(Context context, int customeLayoutId, String dialogTitle, String positiveText, String negativeText) {  
32.         this.context = context;  
33.         this.customeLayoutId = customeLayoutId;  
34.         this.dialogTitle = dialogTitle;  
35.         this.positiveText = positiveText;  
36.         this.negativeText = negativeText;  
37.         this.dialogView=View.inflate(context,customeLayoutId,null);  
38.     }  
39.     //不带自定义view的构造器  
40.     public MikyouCommonDialog2(Context context, String dialogMessage, String dialogTitle, String positiveText, String negativeText) {  
41.         this.context = context;  
42.         this.dialogTitle = dialogTitle;  
43.         this.dialogMessage = dialogMessage;  
44.         this.positiveText = positiveText;  
45.         this.negativeText = negativeText;  
46.     }  
47.   
48.     public View getDialogView() {  
49.         return dialogView;  
50.     }  
51.   
52.     public void setDialogView(View dialogView) {  
53.         this.dialogView = dialogView;  
54.     }  
55.   
56.     public void showDialog(){  
57.         CustomDialog.Builder dialog=new CustomDialog.Builder(context);  
58.         dialog.setTitle(dialogTitle);//设置标题  
59.         //注意:dialogMessage和dialogView是互斥关系也就是dialogMessage存在dialogView就不存在,dialogView不存在dialogMessage就存在  
60.         if (dialogMessage!=null){  
61.             dialog.setMessage(dialogMessage);//设置对话框内容  
62.         }else{  
63.             dialog.setContentView(dialogView);//设置对话框的自定义view对象  
64.         }  
65.         dialog.setPositiveButton(positiveText, new DialogInterface.OnClickListener() {  
66.             @Override  
67.             public void onClick(DialogInterface dialogInterface, int which) {  
68.                 dialogInterface.dismiss();  
69.                 if (listener!=null){  
70.                     listener.dialogPositiveListener(dialogView,dialogInterface,which);  
71.                 }  
72.             }  
73.         }).setNegativeButton(negativeText, new DialogInterface.OnClickListener() {  
74.             @Override  
75.             public void onClick(DialogInterface dialogInterface, int which) {  
76.                 dialogInterface.dismiss();  
77.                 if (listener!=null){  
78.                     listener.dialogNegativeListener(dialogView,dialogInterface,which);  
79.                 }  
80.             }  
81.         }).create().show();  
82.     }  
83.     //注册监听器方法  
84.     public MikyouCommonDialog2 setOnDiaLogListener(OnDialogListener listener){  
85.         this.listener=listener;  
86.         return this;//把当前对象返回,用于链式编程  
87.     }  
88.     //定义一个监听器接口  
89.     public interface OnDialogListener{  
90.         //customView　这个参数需要注意就是如果没有自定义view,那么它则为null  
91.         public void dialogPositiveListener(View customView, DialogInterface dialogInterface, int which);  
92.         public void dialogNegativeListener(View customView, DialogInterface dialogInterface, int which);  
93.     }  
94. }  

测试方式:

[java] view plain copy print ?

1.  private void popInputPwdDialog() {  
2.         new MikyouCommonDialog2(this,R.layout.input_pwd_dialog,"输入安全密码","确定","取消")  
3.                 .setOnDiaLogListener(new MikyouCommonDialog2.OnDialogListener() {  
4.                     @Override  
5.                     public void dialogPositiveListener(View customView, DialogInterface dialogInterface, int which) {//点击确定按钮的操作  
6.                         EditText eTPwd=(EditText) customView.findViewById(R.id.input_pwd);  
7.                         checkAndSavePwd("input",eTPwd.getText().toString(),"");  
8.                     }  
9.                     @Override  
10.                     public void dialogNegativeListener(View customView, DialogInterface dialogInterface, int which) {//点击取消按钮的操作  
11. +  
12.                     }  
13.                 }).showDialog();  
14.     }  

测试Activity：

[java] view plain copy print ?

1. package com.mikyou.dialogdemo;  
2.   
3. import android.content.DialogInterface;  
4. import android.os.Bundle;  
5. import android.support.v7.app.AppCompatActivity;  
6. import android.view.View;  
7. import android.widget.Toast;  
8.   
9. import com.mikyou.dialogdemo.myview.MikyouCommonDialog;  
10.   
11. public class MainActivity extends AppCompatActivity {  
12.     public void dialog1(View view){//弹出第一个对话框  
13.         new MikyouCommonDialog(this,"普通文本提示信息对话框","测试一","确定","取消")  
14.                 .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
15.                     @Override  
16.                     public void dialogPositiveListener(View customView, DialogInterface dialogInterface, int which) {  
17.                         Toast.makeText(MainActivity.this, "确定", Toast.LENGTH_SHORT).show();  
18.                     }  
19.   
20.                     @Override  
21.                     public void dialogNegativeListener(View customView, DialogInterface dialogInterface, int which) {  
22.                         Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
23.                     }  
24.                 }).showDialog();  
25.     }  
26.     public void dialog2(View view){//弹出第二个对话框  
27.         new MikyouCommonDialog(this,"密码错误","测试二","重新输入","取消")  
28.                 .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
29.                     @Override  
30.                     public void dialogPositiveListener(View customView, DialogInterface dialogInterface, int which) {  
31.                         Toast.makeText(MainActivity.this, "重新输入", Toast.LENGTH_SHORT).show();  
32.                     }  
33.   
34.                     @Override  
35.                     public void dialogNegativeListener(View customView, DialogInterface dialogInterface, int which) {  
36.                         Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
37.                     }  
38.                 }).showDialog();  
39.     }  
40.     public void dialog3(View view){//弹出第三个对话框  
41.         new MikyouCommonDialog(this,R.layout.input_text_dialog,"测试三带有自定义View的布局","确定","取消")  
42.                 .setOnDiaLogListener(new MikyouCommonDialog.OnDialogListener() {  
43.                     @Override  
44.                     public void dialogPositiveListener(View customView, DialogInterface dialogInterface, int which) {  
45.                         Toast.makeText(MainActivity.this, "确定", Toast.LENGTH_SHORT).show();  
46.                     }  
47.   
48.                     @Override  
49.                     public void dialogNegativeListener(View customView, DialogInterface dialogInterface, int which) {  
50.                         Toast.makeText(MainActivity.this, "取消", Toast.LENGTH_SHORT).show();  
51.                     }  
52.                 }).showDialog();  
53.     }  
54.     @Override  
55.     protected void onCreate(Bundle savedInstanceState) {  
56.         super.onCreate(savedInstanceState);  
57.         setContentView(R.layout.activity_main);  
58.         initView();  
59.     }  
60.   
61.     private void initView() {  
62.     }  
63. }  

到这里，基本封装已经完了，以后就可以直接使用该自定义的类就可以实现一个自定义的对话框，感觉还是蛮实用的．