Builder设计模式，模板设计模式，Adapter设计模式笔记

因为这三个都比较偏代码，所以都是以贴出运用这些模式的代码，然后通俗总结各个设计模式。

Builder设计模式

Builder设计模式设计模式列子代码如下：

/**
 * Created by hcDarren on 2017/9/23.
 * 这个是导航栏的基类
 */

public class AbsNavigationBar<B extends AbsNavigationBar.Builder> implements INavigation {
    private B mBuilder;
   
    //...代码省略

    /**
     * Builder 构建类
     * 构建 NavigationBar 还有存储参数
     */
    public static abstract class Builder<B extends Builder> {
        public Context mContext;
        
        //...代码省略

        public Builder(Context context, int layoutId, ViewGroup parent) {
            this.mContext = context;
            //...代码省略
        }

        /**
         * 用来创建 NavigationBar
         *
         * @return
         */
        public abstract AbsNavigationBar create();

        /**
         * 设置文本
         *
         * @param viewId
         * @param text
         * @return
         */
        public B setText(int viewId, String text) {
            mTextMaps.put(viewId, text);
            return (B) this;
        }

        /**
         * 设置点击事件
         *
         * @param viewId
         * @param clickListener
         * @return
         */
        public B setOnClickListener(int viewId, View.OnClickListener clickListener) {
            mCLickListenerMaps.put(viewId, clickListener);
            return (B) this;
        }
    }
}

当调用的时候会以一种链式形式：

DefaultNavigationBar navigationBar =
                new DefaultNavigationBar.Builder(this,parent)
                        .setLeftText("返回")
                        .hideLeftText()
                        .setLeftClickListener(new View.OnClickListener(){
                            @Override
                            public void onClick(View v) {
                                finish();
                            }
                        })
                        // 还有一些参数
                        .create();

总结

当类中参数过多时，会有多个参数的方法产生。而且以后如果添加参数，对参数方法改动又比较大。例如以下情况：

class A{
    private String a;

    private String b;

    private String c;

    private String d;

    private String e;   

    private String f;

    public A(){}

    public A(String a){
    }

    public A(String a, String b){}

    public A(String a, String b, String c){}

    public A(String a, String b, String c, String d){}   

    public A(String a, String b, String c, String d){}

    public A(String a, String b, String c, String d, String e){}

    public A(String a, String b, String c, String d, String e, String f){}  
}

Builder模式很好解决了这类情况，在拓展和调用都非常简单明了。

模板设计模式

在android中，Activity的生命周期就是使用的模板模式：

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "ActivityTest";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "---onCreate()---");

    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "---onStart()---");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(TAG, "---onRestart()---");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "---onResume()---");

    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "---onPause()---");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "---onStop()---");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "---onDestroy()---");
    }
}

各个生命周期会按照指定的情景顺序调用，而模板设计模式的核心理念也就是这个。也就是模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供具体实现。而我们自己封装的BaseActivity类也是使用了模板模式的概念：

public abstract class BaseActivity extends AppCompatActivity{

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 1. 设置布局
        setContentView();
        // 写一些公用的方法，ButterKnife注解，统一管理Activity，等等
        // 2. 初始化Title
        initTitle();
        // 3. 初始化View
        initView();
        // 4. 访问接口数据（initData）
        initData(savedInstanceState);
    }

    protected abstract void initData(Bundle savedInstanceState);

    protected abstract void initView();

    protected abstract void initTitle();

    protected abstract void setContentView();

    // 写一大堆方法 ，很多 Activity 都要用的
    public void startActivity(Class<? extends BaseActivity> clazz) {
        Intent intent =  new Intent(this,clazz);
        startActivity(intent);
    }
}

总结

模板模式简单说就是抽象类定义一系列顺序执行的方法，但是具体实现由子类自行决定。

Adapter设计模式

适配器设计模式，在android用的比较多的就是列表界面List设置的Adapter了，是很好的例子。

public class ListAdapter implements AdapterTarget {
    private List<String> mItems;
    private Context context;
    public ListAdapter(List<String> items, Context context){
        this.mItems = items;
        this.context = context;
    }
    @Override
    public int getCount() {
        return mItems.size();
    }

    @Override
    public View getView(int position, ViewGroup parent) {
        TextView itemView = (TextView) LayoutInflater.from(context)
                .inflate(R.layout.item_main,parent,false);
        itemView.setText(mItems.get(position));
        return itemView;
    }
}

而这个设计模式主要就是将我们所得到的数据类型转换为我们所需要的数据类型，而中间这个转换就可以以Adapter设计模式进行转换。在 ListAdapter 中，就是将原本的数据类型转换为 ListView 所需要的View类型，而这个过程通过 ListAdapter 实现，就是使用的 Adapter 设计模式。

总结

Adapter 设计模式使用的场景简单来说就是当我们需要将其他类型转换到我们需要的类型时适配时，我们可以通过编写一个Apapter类来进行转换。这也就是 Adapter 设计模式的核心。