Android中泛型使用实例

一,通用Adapter

1,Example

public abstract class CommonAdapter<T> extends BaseAdapter {

    protected LayoutInflater mInflater;
    protected Context mContext;
    protected List<T> mDatas;
    protected ImageLoader mImageLoader;

    public CommonAdapter(Context context, List<T> mDatas) {
        this.mContext = context;
        this.mInflater = LayoutInflater.from(mContext);
        this.mDatas = mDatas;
        mImageLoader = new ImageLoader(context);
    }

    @Override
    public int getCount() {
        return mDatas.size();
    }

    @Override
    public T getItem(int position) {
        return mDatas.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public abstract View getView(int position, View convertView, ViewGroup parent);

}

2,分析:

a,这里使用了泛型类
泛型类(Java Class)，它可以接受任意类型的数据。所谓“泛型”，就是“宽泛的数据类型”，任意的数据类型。
为什么要使用泛型呢?
其实是为了解决数据类型的安全问题，主要原理是在类声明的时候通过标识，表示类中某个属性类型或是某个方法的返回值及参数类型。这样在类的声明及实例化的时候只要指定好需要放入类型即可.
有些读者不禁要问了,有什么数据类型的安全问题呢?
答案就是向下转型
public abstract class CommonAdapter<T> extends BaseAdapter

3,好处:

在构造方法中使用泛型统一了传入参数的类型
Adapter通常都需要接受一个数据或者集合,但是数据类型却是不确定的,因而像这样因为要接受宽泛的数据类型的场景使用泛型是很自然而然的事情.通用性就是泛型的一大好处.

二,OrmLite中使用

1,Example

public class DBUtil {
    static LiteOrm liteOrm;
    static DBUtil dbUtil = null;
    Context context;
    String dbName;

    public static DBUtil getInstance() {
        if (dbUtil == null) {
            initDBUtil();
        }
        return dbUtil;
    }

    public void clearDBUtil() {
        liteOrm.deleteDatabase();
        liteOrm.openOrCreateDatabase();
    }

    public static void initDBUtil() {
        dbUtil = new DBUtil(App.getAppContext());
    }

    public DBUtil(Context context) {
        this.context = context;
        String DB_NAME = SPUtils.getCurUserId();
        if (!DB_NAME.equals("-1")) {
            dbName = DB_NAME + ".db";
            Log.v(StaticData.TAG, "DB_NAME=" + DB_NAME + ",context=" + context.toString());
            if (liteOrm != null)
                liteOrm.close();
            liteOrm = LiteOrm.newSingleInstance(context, DB_NAME + ".db");
            
        }
    }
    
/*
    *保存某个实体
    */
    public <W> void saveItem(W b) {
        liteOrm.save(b);
    }
    /*
    *保存一个集合
    */
    public <W> void saveItem(Collection<W> b) {
        liteOrm.save(b);
    }
    /*
    *查询所有某一类型的所有数据
    */
    public <T> ArrayList<T> getAllItem(Class<T> tClass) {
        return liteOrm.query(tClass);
    }
}

2,分析:

泛型方法.png

RxJava中

1,example

 private class HttpResultFunc<T> implements Func1<HttpResult<T>, T> {

    @Override
    public T call(HttpResult<T> httpResult) {
        if (httpResult.getSuccess()) {
            if (httpResult.getData() != null) {
                Log.i("retrofit", httpResult.getData().toString());
            }
            return httpResult.getData();
        } else {
            throw new ApiException(httpResult.getMessage());
    //                return T;
        }
    }
}

2,分析

在使用Retrofit+Rxjava时,如果返回的数据类型为
** {success:"true",msg:"登陆成功",data:{content:"content"}} **
相信大家约定的接口返回数据都大同小异,
那么问题来了,前面success,msg解析成到实际应用中的实体类成了冗余数据,完全用不着,那么就会想到用Rxjava中的map操作符
,而map接受Func1实例,而我很多数据解析都需要进行相同的变换操作,那么HttpResultFunc就应运而生了.数据结构不确定的情况当然就用到泛型了.有木有看到这段代码如痴如醉的感觉呢?