虽然现在很多新的项目都在使用RecyclerView，但是很多开发者在一些场景中还是倾向使用ListView或者GridView，然后就是需要写许多的Adapter。一次项目组在新启动一个新项目的时候，有个同事拿来了一个网上说的万能Adapter，在使用的时候发现即使在单个视图类型一旦逻辑判断比较复杂情况下非常不方便，更不用说在适配器Adapter中使用多视图类型了，这里仅是个人观点，也许没有掌握到精华，这是有关万能适配器Adapter的一片博文 Android 快速开发系列 打造万能的ListView GridView 适配器 。

当然了随着RecyclerView的使用，网上也有很多有关对RecyclerView多视图类型Adapter封装的博客，MultiType 3.0是一个大神写的比较全面的Adapter，这篇博客Android 复杂的多类型列表视图新写法：MultiType 3.0有详细的用法。万能适配器Adapter自己使用不是很方便，于是就参看RecyclerView中Adapter的实现方式进行对BaseAdapter进行了简单的封装，封装的目一是为了少写代码，另外一个就是让逻辑看上去更清晰一些。我们知道在RecyclerView的Adapter实现中它将视图创建与数据绑定进行了分离，同时将对View的查找创建也剥离开来了，本文就主要介绍如何将BaseAdapter的使用封装为跟RecyclerView的Adapter使用方式一致。由于很多时候在Adapter中我们都是使用的简单的视图类型，即单类型视图，因此本文将单视图类型的Adapter单独封装了一下，比使用多视图类型的Adapter使用了更严格的数据类型检查，同时在使用上也方便了许多。

RecyclerView中Adapter的使用

在使用RecyclerView的Adapter的时候我们首先需要继承RecyclerView的一个静态内部类Adapter，然后重写三个方法，实际上下面三个方法是必须要重写的，因为都是抽象方法。

• getItemCount()
• onBindViewHolder(VH holder, int position)
• onCreateViewHolder(ViewGroup parent, int viewType)

一般情况下重写上面三个方法就可以，但是如果存在多视图类型，在第三个方法

onCreateViewHolder()方法中我们也可以看到有一个参数是viewType，该参数作用就是针对不同的viewType需要创建不同的ViewHolder，因此还需要重写一个方法getItemViewType(int position)，针对多视图类型同BaseAdapter实现方式倒是很像，在BaseAdapter中这是需要除此之外还要重写一个方法getViewTypeCount()，但是在RecyclerView的Adapter中不需要该方法。

简单类型Adapter

1. private class MyAdapter extends RecyclerView.Adapter<MyViewHolder> { 
2.  
3.     @Override 
4.     public int getItemCount() { 
5.         return COUNT; 
6.     } 
7.  
8.     @Override 
9.     public void onBindViewHolder(MyViewHolder holder, int position) { 
10.         holder.textView.setText("TEXT_" + position); 
11.     } 
12.  
13.     @Override 
14.     public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { 
15.         View view = LayoutInflater.from(getApplicationContext()).inflate(R.layout.item_text, parent, false); 
16.         MyViewHolder holder = new MyViewHolder(view); 
17.         return holder; 
18.     } 
19.  
20. } 
21.  
22. private static class MyViewHolder extends RecyclerView.ViewHolder { 
23.     private TextView textView; 
24.  
25.     public MyViewHolder(View itemView) { 
26.         super(itemView); 
27.         textView = (TextView) itemView.findViewById(R.id.textView); 
28.     } 
29. } 

复杂类型Adapter

1. private class MyAdapter extends RecyclerView.Adapter<ViewHolder> { 
2.  
3.     @Override 
4.     public int getItemCount() { 
5.         return COUNT; 
6.     } 
7.  
8.     @Override 
9.     public int getItemViewType(int position) { 
10.         return position % 2 == 0 ? TYPE_IMAGE : TYPE_TEXT; 
11.     } 
12.  
13.     @Override 
14.     public void onBindViewHolder(ViewHolder holder, int position) { 
15.         int type = getItemViewType(position); 
16.         switch (type) { 
17.         case TYPE_TEXT: 
18.             ((MyTextHolder) holder).textView.setText("TEXT_" + position); 
19.             break; 
20.         case TYPE_IMAGE: 
21.             ((MyImageHolder) holder).imageView.setImageResource(R.drawable.image); 
22.             break; 
23.         } 
24.     } 
25.  
26.     @Override 
27.     public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { 
28.         View view; 
29.         ViewHolder holder = null; 
30.         switch (viewType) { 
31.         case TYPE_TEXT: 
32.             view = LayoutInflater.from(getApplicationContext()).inflate(R.layout.item_text, parent, false); 
33.             holder = new MyTextHolder(view); 
34.             break; 
35.         case TYPE_IMAGE: 
36.             view = LayoutInflater.from(getApplicationContext()).inflate(R.layout.item_image, parent, false); 
37.             holder = new MyImageHolder(view); 
38.             break; 
39.         } 
40.         return holder; 
41.     } 
42. } 
43.  
44. private class MyTextHolder extends RecyclerView.ViewHolder { 
45.     private TextView textView; 
46.  
47.     public MyTextHolder(View itemView) { 
48.         super(itemView); 
49.         textView = (TextView) itemView.findViewById(R.id.textView); 
50.     } 
51. } 
52.  
53. private class MyImageHolder extends ViewHolder { 
54.     private ImageView imageView; 
55.  
56.     public MyImageHolder(View itemView) { 
57.         super(itemView); 
58.         imageView = (ImageView) itemView.findViewById(R.id.imageView); 
59.     } 
60. } 

自定义BaseAdapter

在自定义基类之前，先简单分析一下，我们需要自定义一个支持单种视图的Adapter，还要自定义一个支持多种视图类型的Adapter，两个类都要继承BaseAdapter，先将两个类都公用的部分抽取出来定义为MyAdapter。

1. public abstract class MyAdapter<T> extends BaseAdapter { 
2.  
3.     protected List<T> dataList = new ArrayList<>(); 
4.     protected Context context; 
5.     protected LayoutInflater inflater; 
6.  
7.     public MyAdapter(Context context) { 
8.         this.context = context; 
9.         inflater = LayoutInflater.from(context); 
10.     } 
11.  
12.     public void setDataList(List<T> dataList) { 
13.         this.dataList = dataList; 
14.         notifyDataSetChanged(); 
15.     } 
16.  
17.     @Override 
18.     public int getCount() { 
19.         if (null == dataList) { 
20.             return 0; 
21.         } 
22.         return dataList.size(); 
23.     } 
24.  
25.     @Override 
26.     public T getItem(int position) { 
27.         return dataList.get(position); 
28.     } 
29.  
30.     @Override 
31.     public long getItemId(int position) { 
32.         return position; 
33.     } 
34.  
35. } 

在RecyclerView的Adapter实现中是没有getView()方法的，下面我们就分析一下getView()方法如何拆分，一般情况下我们在实现getView()方法都是如下流程。

1. public View getView(int position, View convertView, ViewGroup parent) { 
2.     ViewHolder holder = null; 
3.     if (null == convertView) { 
4.         //填充布局 
5.         convertView=inflater.inflate(R.layout.item_layout, parent,false); 
6.         holder = new ViewHolder(); 
7.         //通过ID查询控件 
8.         holder.textView=(TextView)convertView.findViewById(R.id.textView); 
9.         holder.imageView=(ImageView)convertView.findViewById(R.id.imageView); 
10.         convertView .setTag(holder); 
11.     } else { 
12.         holder = (ViewHolder) convertView.getTag(); 
13.     } 
14.     //赋值逻辑 
15.     return convertView; 
16. } 
17. //一个空的ViewHolder 
18. public static class ViewHolder{ 
19.     TextView textView; 
20.     ImageView imageView; 
21. } 

Java编程比较流行的一种编程方式不是说面向接口编程吗，在Android开发中也有一个开发方式叫做面向Holder的编程，上面代码是传统的实现ViewHolder的方式，说句实现话就没做什么事，就是作为一个载体承载着我们需要的控件。我们让ViewHolder多做一些事情，让它在convertView==null情况下需要做的多数逻辑都放到ViewHolder中去。

1. public class ViewHolder { 
2.     private final View itemView; 
3.  
4.     public ViewHolder(View itemView) { 
5.         if (null == itemView) { 
6.             throw new IllegalArgumentException("itemView must not be null"); 
7.         } else { 
8.             this.itemView = itemView; 
9.             itemView.setTag(this); 
10.         } 
11.     } 
12.  
13.     public View getItemView() { 
14.         return itemView; 
15.     } 
16. } 

在ViewHolder中的itemView就是getView()方法中的convertView，这里刚好是条目的根View，类似RecyclerView中ViewHolder构造方法中itemView。由于不同的视图需要创建不同的ViewHolder，因此我们可以将创建ViewHolder的方法设置为抽象的方法暴露出去，另外赋值的时候我们也需要根据具体的业务进行赋值，同样设置一个抽象方法。

1. public abstract class SimpleAdapter<T,VH extends ViewHolder> extends MyAdapter<T> { 
2.  
3.     public SimpleAdapter(Context context) { 
4.         super(context); 
5.     } 
6.  
7.     public View getView(int position, View convertView, ViewGroup parent) { 
8.         VH holder = null; 
9.         if (null == convertView) { 
10.             holder = onCreateViewHolder(parent); 
11.             convertView = holder.getItemView(); 
12.         } else { 
13.             holder = (VH) convertView.getTag(); 
14.         } 
15.         onBindViewHolder(holder, position); 
16.         return convertView; 
17.     } 
18.  
19.     public abstract void onBindViewHolder(VH holder, int position); 
20.  
21.     public abstract VH onCreateViewHolder(ViewGroup parent); 
22.  
23. } 

在设置多视图类型的Adapter的时候只需要在创建ViewHolder的时候多传入一个viewType的参数即可。

1. public abstract class MultiAdapter<T> extends MyAdapter<T> { 
2.  
3.     public MultiAdapter(Context context) { 
4.         super(context); 
5.     } 
6.  
7.     @Override 
8.     public View getView(int position, View convertView, ViewGroup parent) { 
9.         ViewHolder holder = null; 
10.         if (null == convertView) { 
11.             holder = onCreateViewHolder(parent, getItemViewType(position)); 
12.             convertView = holder.getItemView(); 
13.         } else { 
14.             holder = (ViewHolder) convertView.getTag(); 
15.         } 
16.         onBindViewHolder(holder, position); 
17.         return convertView; 
18.     } 
19.  
20.     public abstract void onBindViewHolder(ViewHolder holder, int position); 
21.  
22.     public abstract ViewHolder onCreateViewHolder(ViewGroup parent, int viewType); 
23.  
24. } 

自定义BaseAdapter的使用

单视图类型SimpleAdapter使用

1. public class TextAdapter extends SimpleAdapter<String, TextAdapter.TextHolder> { 
2.  
3.     public TextAdapter(Context context) { 
4.         super(context); 
5.     } 
6.  
7.     @Override 
8.     public void onBindViewHolder(TextHolder holder, int position) { 
9.         holder.textView.setText(getItem(position)); 
10.     } 
11.  
12.     @Override 
13.     public TextHolder onCreateViewHolder(ViewGroup parent) { 
14.         View convertView=inflater.inflate(R.layout.item_text, parent, false); 
15.         return new TextHolder(convertView); 
16.     } 
17.  
18.     static class TextHolder extends ViewHolder{ 
19.  
20.         public TextView textView; 
21.  
22.         public TextHolder(View itemView) { 
23.             super(itemView); 
24.             textView=(TextView) itemView.findViewById(R.id.textView); 
25.         } 
26.     } 
27. } 

这里我们使用了两个泛型，一个是ViewHolder中支持的数据类型String，另外一个就是我们需要创建的ViewHolder，这样在onCreateViewHolder方法的返回值就会自动返回我们自定义的ViewHolder,有关泛型更多的知识可以参看Java泛型使用解析，单视图类型Adapter的使用比RecyclerView的Adapter还要方便许多。

多视图类型的使用

1. public class RichAdapter extends MultiAdapter<String> { 
2.  
3.     private static final int TEXT = 0; 
4.     private static final int PIC = 1; 
5.  
6.     public RichAdapter(Context context) { 
7.         super(context); 
8.     } 
9.  
10.     @Override 
11.     public int getViewTypeCount() { 
12.         return 2; 
13.     } 
14.  
15.     @Override 
16.     public int getItemViewType(int position) { 
17.         if (position % 3 == 0) { 
18.             return PIC; 
19.         } else { 
20.             return TEXT; 
21.         } 
22.     } 
23.  
24.     @Override 
25.     public void onBindViewHolder(ViewHolder holder, int position) { 
26.         switch (getItemViewType(position)) { 
27.         case TEXT: 
28.             TextHolder textHolder=(TextHolder) holder; 
29.             textHolder.textView.setText(getItem(position)); 
30.             break; 
31.         case PIC: 
32.             ImageHolder imageHolder=(ImageHolder) holder; 
33.             imageHolder.imageView.setImageResource(R.drawable.image); 
34.             break; 
35.         } 
36.     } 
37.  
38.     @Override 
39.     public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { 
40.         View itemView = null; 
41.         ViewHolder holder = null; 
42.         switch (viewType) { 
43.         case TEXT: 
44.             itemView = inflater.inflate(R.layout.item_text, parent, false); 
45.             holder = new TextHolder(itemView); 
46.             break; 
47.         case PIC: 
48.             itemView = inflater.inflate(R.layout.item_image, parent, false); 
49.             holder = new ImageHolder(itemView); 
50.             break; 
51.         } 
52.         return holder; 
53.     } 
54.  
55.     private static class TextHolder extends ViewHolder { 
56.         TextView textView; 
57.  
58.         public TextHolder(View itemView) { 
59.             super(itemView); 
60.             textView = (TextView) itemView.findViewById(R.id.textView); 
61.         } 
62.  
63.     } 
64.  
65.     private static class ImageHolder extends ViewHolder { 
66.         ImageView imageView; 
67.  
68.         public ImageHolder(View itemView) { 
69.             super(itemView); 
70.             imageView = (ImageView) itemView.findViewById(R.id.imageView); 
71.         } 
72.     } 
73. } 

这里的使用情况跟RecyclerView的使用几乎是一模一样，唯一不一样的地方就是多写了一个getViewTypeCount()方法，在ListView或者GridView使用BaseAdapter实现多种类型视图的时候该方法必须要重写。