如果你项目一直用系统给你封装的BaseAdapter的话,那么我只想说,你不累么?
代码繁多还要写数据缓存,还不如自己动手写一个模板吧,这样后面项目就可以直接套用了,编写和执行效率大大提升啊。
BaseAdapter.java
001 |
import java.util.ArrayList;
|
002 |
import java.util.Collection;
|
003 |
import java.util.Collections;
|
004 |
import java.util.Comparator;
|
005 |
import java.util.List;
|
006 |
007 |
import android.content.Context;
|
008 |
import android.content.res.Resources;
|
009 |
import android.view.LayoutInflater;
|
010 |
import android.view.View;
|
011 |
import android.view.ViewGroup;
|
012 |
013 |
014 |
/** |
015 |
* 实现这个适配器模板会少很多代码
|
016 |
* @author leehom
|
017 |
* @param <T>
|
018 |
*/
|
019 |
public abstract class BaseAdapter<T> extends android.widget.BaseAdapter {
|
020 |
021 |
protected List<T> list;
|
022 |
protected Context context;
|
023 |
protected LayoutInflater inflater;
|
024 |
private int layoutID;
|
025 |
026 |
public BaseAdapter(Context context, T[] ts, int layoutID) {
|
027 |
super ();
|
028 |
this .context = context;
|
029 |
this .list = new ArrayList<T>();
|
030 |
this .layoutID = layoutID;
|
031 |
Collections.addAll(list, ts);
|
032 |
this .inflater = LayoutInflater.from(context);
|
033 |
}
|
034 |
035 |
public BaseAdapter(Context context, List<T> list, int layoutID) {
|
036 |
super ();
|
037 |
this .layoutID = layoutID;
|
038 |
this .context = context;
|
039 |
this .list = new ArrayList<T>();
|
040 |
this .list.addAll(list);
|
041 |
this .inflater = LayoutInflater.from(context);
|
042 |
}
|
043 |
044 |
public Resources getResources() {
|
045 |
return context.getResources();
|
046 |
}
|
047 |
048 |
public synchronized void add(T object) {
|
049 |
list.add(object);
|
050 |
}
|
051 |
052 |
public synchronized void addAll(Collection<? extends T> collection) {
|
053 |
list.addAll(collection);
|
054 |
}
|
055 |
056 |
public synchronized void remove(T object) {
|
057 |
list.remove(object);
|
058 |
}
|
059 |
060 |
public synchronized void insert(T object, int index) {
|
061 |
list.add(index, object);
|
062 |
}
|
063 |
064 |
public synchronized void clear() {
|
065 |
list.clear();
|
066 |
}
|
067 |
068 |
public synchronized void sort(Comparator<? super T> comparator) {
|
069 |
Collections.sort(list, comparator);
|
070 |
}
|
071 |
072 |
@Override
|
073 |
public T getItem( int position) {
|
074 |
// TODO Auto-generated method stub
|
075 |
return list.get(position);
|
076 |
}
|
077 |
078 |
@Override
|
079 |
public int getCount() {
|
080 |
// TODO Auto-generated method stub
|
081 |
return list.size();
|
082 |
}
|
083 |
084 |
@Override
|
085 |
public long getItemId( int position) {
|
086 |
// TODO Auto-generated method stub
|
087 |
return position;
|
088 |
}
|
089 |
090 |
@Override
|
091 |
public View getView( int position, View convertView, ViewGroup parent) {
|
092 |
// TODO Auto-generated method stub
|
093 |
ViewHolder holder = null ;
|
094 |
if (convertView == null ) {
|
095 |
convertView = inflater.inflate(layoutID, null );
|
096 |
holder = new ViewHolder(convertView);
|
097 |
initView(holder);
|
098 |
convertView.setTag(holder);
|
099 |
} else {
|
100 |
holder = (ViewHolder) convertView.getTag();
|
101 |
}
|
102 |
setViewValue(holder, position);
|
103 |
return convertView;
|
104 |
}
|
105 |
106 |
public List<T> getList() {
|
107 |
return list;
|
108 |
}
|
109 |
|
110 |
/**
|
111 |
* 向ViewHolder类里面添加View
|
112 |
* @param holder
|
113 |
*/
|
114 |
public abstract void initView(ViewHolder holder);
|
115 |
116 |
/**
|
117 |
* 从ViewHolder获取对应ID的View设置其值
|
118 |
* @param holder
|
119 |
* @param t 数据对象
|
120 |
*/
|
121 |
public abstract void setViewValue(ViewHolder holder, int position);
|
122 |
123 |
} |
用的时候也是继承它,然后只需要初始化ID和设置Value就行了。例:
01 |
import java.lang.reflect.Field;
|
02 |
import java.lang.reflect.InvocationTargetException;
|
03 |
import java.lang.reflect.Method;
|
04 |
import java.util.ArrayList;
|
05 |
06 |
import android.annotation.SuppressLint;
|
07 |
import android.content.Context;
|
08 |
09 |
import com.fenjin.app.humiture.R;
|
10 |
import com.fenjin.app.item.DefaultItem;
|
11 |
12 |
@SuppressLint ( "DefaultLocale" )
|
13 |
public class DefaultAdapter extends BaseAdapter<DefaultItem> {
|
14 |
15 |
public DefaultAdapter(Context context, Object object) {
|
16 |
super (context, new ArrayList<DefaultItem>(),
|
17 |
R.layout.default_list_item_layout);
|
18 |
// TODO Auto-generated constructor stub
|
19 |
try {
|
20 |
Field[] fields = object.getClass().getDeclaredFields();
|
21 |
for (Field field : fields) {
|
22 |
String lable = field.getName();
|
23 |
String firstWord = lable.substring( 0 , 1 ).toUpperCase();
|
24 |
StringBuffer buffer = new StringBuffer( "get" );
|
25 |
buffer.append(firstWord);
|
26 |
buffer.append(lable.substring( 1 ));
|
27 |
String name = buffer.toString();
|
28 |
Method method = object.getClass().getDeclaredMethod(name);
|
29 |
String value = method.invoke(object).toString();
|
30 |
DefaultItem item = new DefaultItem(lable, value);
|
31 |
add(item);
|
32 |
}
|
33 |
} catch (IllegalArgumentException e) {
|
34 |
// TODO Auto-generated catch block
|
35 |
e.printStackTrace();
|
36 |
} catch (NoSuchMethodException e) {
|
37 |
// TODO Auto-generated catch block
|
38 |
e.printStackTrace();
|
39 |
} catch (IllegalAccessException e) {
|
40 |
// TODO Auto-generated catch block
|
41 |
e.printStackTrace();
|
42 |
} catch (InvocationTargetException e) {
|
43 |
// TODO Auto-generated catch block
|
44 |
e.printStackTrace();
|
45 |
}
|
46 |
}
|
47 |
48 |
@Override
|
49 |
public void initView(ViewHolder holder) {
|
50 |
// TODO Auto-generated method stub
|
51 |
holder.addView(R.id.default_lable);
|
52 |
holder.addView(R.id.default_value);
|
53 |
}
|
54 |
55 |
@Override
|
56 |
public void setViewValue(ViewHolder holder, int position) {
|
57 |
// TODO Auto-generated method stub
|
58 |
DefaultItem item = getItem(position);
|
59 |
holder.getTextView(R.id.default_lable).setText(item.getLable());
|
60 |
holder.getTextView(R.id.default_value).setText(item.getValue());
|
61 |
}
|
62 |
63 |
@Override
|
64 |
public boolean isEnabled( int position) {
|
65 |
// TODO Auto-generated method stub
|
66 |
return false ;
|
67 |
}
|
68 |
69 |
} |
javabean代码
01 |
public class DefaultItem {
|
02 |
03 |
String lable;
|
04 |
String value;
|
05 |
06 |
public DefaultItem(String lable, String value) {
|
07 |
super ();
|
08 |
this .lable = lable;
|
09 |
this .value = value;
|
10 |
}
|
11 |
12 |
public String getLable() {
|
13 |
return lable;
|
14 |
}
|
15 |
16 |
public void setLable(String lable) {
|
17 |
this .lable = lable;
|
18 |
}
|
19 |
20 |
public String getValue() {
|
21 |
return value;
|
22 |
}
|
23 |
24 |
public void setValue(String value) {
|
25 |
this .value = value;
|
26 |
}
|
27 |
28 |
} |
xml代码
01 |
<? xml version = "1.0" encoding = "utf-8" ?>
|
02 |
< LinearLayout xmlns:android = "http://schemas.android.com/apk/res/android"
|
03 |
android:layout_width = "match_parent"
|
04 |
android:layout_height = "match_parent"
|
05 |
android:orientation = "horizontal"
|
06 |
android:padding = "@dimen/margin_10" >
|
07 |
08 |
< TextView
|
09 |
android:id = "@+id/default_lable"
|
10 |
android:layout_width = "wrap_content"
|
11 |
android:layout_height = "wrap_content" />
|
12 |
13 |
< TextView
|
14 |
android:layout_width = "wrap_content"
|
15 |
android:layout_height = "wrap_content"
|
16 |
android:text = ":" />
|
17 |
18 |
< TextView
|
19 |
android:id = "@+id/default_value"
|
20 |
android:layout_width = "wrap_content"
|
21 |
android:layout_height = "wrap_content" />
|
22 |
23 |
</ LinearLayout >
|
每次实现的代码仅仅这么点
01 |
@Override |
02 |
public void initView(ViewHolder holder) {
|
03 |
// TODO Auto-generated method stub
|
04 |
holder.addView(R.id.default_lable);
|
05 |
holder.addView(R.id.default_value);
|
06 |
} |
07 |
08 |
@Override |
09 |
public void setViewValue(ViewHolder holder, int position) {
|
10 |
// TODO Auto-generated method stub
|
11 |
DefaultItem item = getItem(position);
|
12 |
holder.getTextView(R.id.default_lable).setText(item.getLable());
|
13 |
holder.getTextView(R.id.default_value).setText(item.getValue());
|
14 |
} |
是不是非常不错呢?
- 本文固定链接: http://www.ithtw.com/1300.html
- leehom 2015年03月06日 于 IT十万为什么 发表
相关推荐
- 为了保持灵活性,封装的Adapter可能会提供一些模板方法,如onCreateViewHolder()和onBindViewHolder(),允许子类覆盖以实现自己的逻辑。 - 另外,还可能提供一些扩展点,如自定义点击事件监听、动画效果等。 5....
1. **通用性**:构造一个通用的`Adapter`模板,避免每次添加新列表时都需要重新编写一个适配器。这种做法减少了大量重复代码的编写。 2. **组件化**:通过组装的方式构建`Adapter`。将每个不同类型的`Item`(即不同...
文件模板用于生成整个新文件,如Activity、Fragment或Adapter;而代码片段模板则用于在现有代码中插入特定代码块,如日志打印、try-catch块等。 创建自定义模板的过程如下: 1. **打开模板配置**:进入Settings...
1. **模板方法设计模式**:通用Adapter通常采用模板方法设计模式,定义了一套基本的操作流程,比如绑定数据、创建视图等,而具体的实现则留给子类。这样,开发者只需要关注数据与视图的映射,而不必从头编写整个...
这种适配器旨在提高代码的复用性和灵活性,减少开发者为不同类型的列表项编写多个适配器的负担。 1. **Adapter的基本原理** Adapter是Android中的一个接口,它定义了将数据转换为列表或网格中可显示视图的方法。...
此外,由于这是一个开源项目,开发者可以根据自己的需求对模板进行定制,甚至贡献自己的模板,推动社区的发展。 在Android Studio中,可以直接导入Kotlin-Android-Studio-Templates项目,然后将模板复制到相应的...
"简化适配器编写"可能涉及到一些设计原则和最佳实践,例如如何利用已有的类库,避免重复造轮子,或者如何通过模板方法模式或策略模式来减少适配器的代码量,提高代码的可读性和可维护性。 在实际项目中,适配器模式...
总结来说,"安卓万能适配器Adapter"是一种高效、灵活的编程实践,它通过抽象和模板化的方法,降低了适配器的复用成本,让开发者能够更加专注于业务逻辑的实现,而不是重复的代码编写。在Android开发中,掌握这种技术...
这些组件协同工作,使得程序员能够编写出简洁、高效且易于维护的代码。 1. 容器:STL容器是存储和管理对象的数据结构。常见的容器有vector(动态数组)、list(双向链表)、deque(双端队列)、set(集合,基于红黑...
项目模板用于创建新的Android项目,而文件模板则用于在现有项目中快速生成特定类型的代码文件,如Activity、Fragment、Adapter等。 ### 2. 使用项目模板 当你新建一个Android项目时,Android Studio会提供多种预定...
首先,需要编写SQL查询语句获取数据库表中的数据,例如: ```csharp string connectionString = "your_connection_string"; string query = "SELECT * FROM TableName"; using (SqlConnection connection = new ...
开发者可以根据这个基础模板,为自己的项目创建特定的适配器子类,只需要关注数据和视图的对应关系即可。 通过这种方式,我们不仅可以实现ListView的通用适配器,还可以将其扩展到其他的列表组件,如RecyclerView,...
#### 配接器(Adapter) 配接器如`reverse_iterator`和`iterator_adaptor`提供了对现有容器和迭代器功能的扩展,例如反向迭代容器或创建自定义迭代器。 ### STL的重要性和优势 STL的引入极大地简化了C++编程,提供...
2. **模板方法设计模式**:通过模板方法设计模式,base-adapter-helper将视图绑定逻辑分离出来,使得代码结构更清晰,易于维护。开发者可以自定义每个数据项的视图绑定过程。 3. **便捷的事件处理**:提供了简便的...
**MVP框架模板详解** MVP(Model-View-Presenter)是一种常见的软件设计模式,尤其在Android应用开发中被广泛采用。MVP架构的主要目的是为了提高代码的可测试性、可维护性和降低耦合度。在这个例子中,我们将会探讨...
接着,在C#代码中编写连接字符串,并使用SqlCommand类执行INSERT语句将日记内容和日期保存到数据库的表中。 ```csharp using System.Data.SqlClient; // ... private void btnSave_Click(object sender, ...
安装composer require dandjo/object-adapter目的其目的是在使用诸如Twig之类的模板引擎背后的复杂对象时,使生活变得更轻松。 它提供了一些语法功能,例如编写getSomeProperty getter( getSomeProperty )并通过...
该项目通常包含了对多种视图类型的兼容,以及对数据操作的便捷接口,以减少开发者重复编写相似适配器代码的工作量。 在Java编程语言中,适配器模式是一种设计模式,它允许不兼容的类协同工作。在Android中,适配器...
通过这种方式,开发者可以针对不同的需求创建多个自定义模板,如Fragment、Adapter或其他常用的代码结构,大大提升开发效率,减少重复工作。 总结来说,使用TemplateBuilder插件在Android Studio中构建自定义模板,...