回头看自己写的东西，大概Android当自己控制的定义，编写代码适用性比较高。但是，看看没有什么技术含量，因此，当在学习设计模式，想想有些东西是否可以改善，例如：
自己定义Dialog是Android应用必须的，系统的控件实在是太难看了。
在构建中，全然是，new完对象之后，须要什么构建什么。这样写没有问题。可读性也还行，就是看上去不咋的。
下面是小部分代码片段：
package com.example.demo.Builder; /**
*
* @author qubian
* @data 2015年6月10日
* @email naibbian@163.com
*
*/
public class BuilderDialog extends Dialog implements View.OnClickListener {
private Context mContext;
private View view;
private View lineView;
private TextView titleTv;
private TextView contentTv;
private Button sureBtn;
private Button cancelBtn;
private String sureTitle;
private String cancelTitle;
private String title;
private String content;
private boolean sureVisible = true;
private boolean cancelVisible = true;
private View.OnClickListener sureListener;
private View.OnClickListener cancelListener; public BuilderDialog(Context context, String title, String content) {
super(context, R.style.base_dialog_style);
this.mContext = context;
this.title = title;
this.content = content;
view = LayoutInflater.from(mContext).inflate(R.layout.dialog_normal,
null);
addContentView(view, Utils.getDialogLayoutParams(mContext));
} public void setSureTitle(String title) {
sureTitle = title;
} public void setCancelTitle(String title) {
cancelTitle = title;
} public void setCancelVisible(boolean visible) {
cancelVisible = visible;
} public void setSureListener(View.OnClickListener listener) {
if (listener != null) {
sureListener = listener;
}
} public void setCancelListener(View.OnClickListener listener) { } /**
* 能否够返回
*
* @param canBack
*/
public void setCanBack(boolean canBack) { }
//初始化
private void initView() {
lineView = view.findViewById(R.id.line_view);
titleTv = (TextView) view.findViewById(R.id.title_tv);
contentTv = (TextView) view.findViewById(R.id.content_tv);
contentTv.setText((content.replace("\\r","\r").replace("\\n", "\n")));
sureBtn = (Button) view.findViewById(R.id.sure_btn);
cancelBtn = (Button) view.findViewById(R.id.cancel_btn);
} @Override
public void show() {
initView();
titleTv.setText(title);
if (sureVisible) {
if (sureListener == null) {
sureBtn.setOnClickListener(this);
} else {
sureBtn.setOnClickListener(sureListener);
}
if (sureTitle != null) {
sureBtn.setText(sureTitle);
}
} else {
sureBtn.setVisibility(View.GONE);
}
if (cancelVisible) { } else { }
super.show();
} @Override
public void onClick(View v) {
if (v.getId() == sureBtn.getId()) {
this.cancel();
} else if (v.getId() == cancelBtn.getId()) {
this.cancel();
}
} }
使用。和适用都没问题，而且逻辑也比較简单，那么怎样优化呢？
言归正传：
建造者模式
1、定义：
将一个复杂的构建与其表示分离，使得同样的构建有了不同的表示。
2、目的：
建造者模式是讲复杂的内部构建封装在内部，对于其它外部成员来说，仅仅须要传递构建者和构建工具。便能够得到所需。不须要关心怎样构建，以及内部构建过程。
3、使用：
3.1、在构建的过程中，同意不同的构建过程。产生不同表示的构建对象；
3.2、在复杂的对象时，其复杂的构建算法应当独立于对象的组成部分，或者是独立于装配方式时；
4、一个简单的demo：
核心：抽象建造者，详细建造者，实体类
package com.example.demo.Builder; import android.util.Log;
/**
* 建造者模式
* @author qubian
* @data 2015年6月10日
* @email naibbian@163.com
*
*/
public class Product { Builder mBuilder ;
public Builder getBuilder()
{
if (mBuilder==null) {
mBuilder = new ProductBuilder();
}
return mBuilder;
} /**
* 抽象建造者
* @author qubian
* @data 2015年6月10日
* @email naibbian@163.com
*
*/
public interface Builder
{
public Builder buildPart1(); public Builder buildPart2(); public Product getProduct();
}
/**
* 详细的建造者
* @author qubian
* @data 2015年6月10日
* @email naibbian@163.com
*
*/
public class ProductBuilder implements Builder
{
private static final String TAG= "ProductBuilder";
Product mProduct = new Product();
@Override
public Builder buildPart1() {
Log.i(TAG, "buildPart1");
return this; } @Override
public Builder buildPart2() {
Log.i(TAG, "buildPart2");
return this; } @Override
public Product getProduct() { return mProduct;
} } }
使用：
package com.example.demo.Builder; /**
* 使用
* @author qubian
* @data 2015年6月10日
* @email naibbian@163.com
*
*/
public class UseProduct { public void use()
{
Product p = new Product().getBuilder().buildPart1().buildPart2().getProduct();
} }
5、在Android的源代码中。建造者模式。肯定是不可缺少的；
当中最为代表的就是AlertDialog,在其构建过程中，便是构建与表示分离。
其内部的Builder便是他的构建者。
public class AlertDialog extends Dialog implements DialogInterface {
private AlertController mAlert;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mAlert.installContent();
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (mAlert.onKeyDown(keyCode, event)) return true;
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (mAlert.onKeyUp(keyCode, event)) return true;
return super.onKeyUp(keyCode, event);
}
public static class Builder {
private final AlertController.AlertParams P;
private int mTheme;
/**
* Constructor using a context for this builder and the {@link AlertDialog} it creates.
*/
public Builder(Context context) {
this(context, resolveDialogTheme(context, 0));
}
/**
* Set the title displayed in the {@link Dialog}.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setTitle(CharSequence title) {
P.mTitle = title;
return this;
}
/**
* Set the message to display using the given resource id.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setMessage(int messageId) {
P.mMessage = P.mContext.getText(messageId);
return this;
}
/**
* Set the message to display.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setMessage(CharSequence message) {
P.mMessage = message;
return this;
}
/**
* Set the resource id of the {@link Drawable} to be used in the title.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setIcon(int iconId) {
P.mIconId = iconId;
return this;
}
/**
* Set a listener to be invoked when the positive button of the dialog is pressed.
* @param textId The resource id of the text to display in the positive button
* @param listener The {@link DialogInterface.OnClickListener} to use.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setPositiveButton(int textId, final OnClickListener listener) {
P.mPositiveButtonText = P.mContext.getText(textId);
P.mPositiveButtonListener = listener;
return this;
}
/**
* Set a listener to be invoked when the positive button of the dialog is pressed.
* @param text The text to display in the positive button
* @param listener The {@link DialogInterface.OnClickListener} to use.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setPositiveButton(CharSequence text, final OnClickListener listener) {
P.mPositiveButtonText = text;
P.mPositiveButtonListener = listener;
return this;
}
/**
* Set a listener to be invoked when the negative button of the dialog is pressed.
* @param textId The resource id of the text to display in the negative button
* @param listener The {@link DialogInterface.OnClickListener} to use.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setNegativeButton(int textId, final OnClickListener listener) {
P.mNegativeButtonText = P.mContext.getText(textId);
P.mNegativeButtonListener = listener;
return this;
}
/**
* Set a listener to be invoked when the negative button of the dialog is pressed.
* @param text The text to display in the negative button
* @param listener The {@link DialogInterface.OnClickListener} to use.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setNegativeButton(CharSequence text, final OnClickListener listener) {
P.mNegativeButtonText = text;
P.mNegativeButtonListener = listener;
return this;
}
/**
* Set a listener to be invoked when the neutral button of the dialog is pressed.
* @param textId The resource id of the text to display in the neutral button
* @param listener The {@link DialogInterface.OnClickListener} to use.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setNeutralButton(int textId, final OnClickListener listener) {
P.mNeutralButtonText = P.mContext.getText(textId);
P.mNeutralButtonListener = listener;
return this;
}
/**
* Set a custom view to be the contents of the Dialog. If the supplied view is an instance
* of a {@link ListView} the light background will be used.
*
* @param view The view to use as the contents of the Dialog.
*
* @return This Builder object to allow for chaining of calls to set methods
*/
public Builder setView(View view) {
P.mView = view;
P.mViewSpacingSpecified = false;
return this;
}
/**
* Creates a {@link AlertDialog} with the arguments supplied to this builder. It does not
* {@link Dialog#show()} the dialog. This allows the user to do any extra processing
* before displaying the dialog. Use {@link #show()} if you don't have any other processing
* to do and want this to be created and displayed.
*/
public AlertDialog create() {
final AlertDialog dialog = new AlertDialog(P.mContext, mTheme, false);
P.apply(dialog.mAlert);
dialog.setCancelable(P.mCancelable);
if (P.mCancelable) {
dialog.setCanceledOnTouchOutside(true);
}
dialog.setOnCancelListener(P.mOnCancelListener);
dialog.setOnDismissListener(P.mOnDismissListener);
if (P.mOnKeyListener != null) {
dialog.setOnKeyListener(P.mOnKeyListener);
}
return dialog;
}
/**
* Creates a {@link AlertDialog} with the arguments supplied to this builder and
* {@link Dialog#show()}'s the dialog.
*/
public AlertDialog show() {
AlertDialog dialog = create();
dialog.show();
return dialog;
}
}
}
也许它的开放性，AlterView也有自己的构建过程，这种使用AlterView建设者Builder要构建视图，他对象可以自行操作。