泛型的作用及使用场景

作者: 骏骏的简书 | 来源:发表于2016-07-21 11:17 被阅读1538次

Android使用泛型的地方很多，比如集成自BaseAdapter实现封装的Adapter,对常用操作进行封装，但是需要对传进来的数据进行处理，此时就使用到泛型，示例如下：

public abstract class EasyAdapter<T> extends BaseAdapter {  
    private LayoutInflater inflater;  
    private int layoutId;  
    private List<T> mlist = new ArrayList<T>();  
  
    public EasyAdapter(Context context, int layoutId, List<T> list) {  
        super();  
        this.inflater = LayoutInflater.from(context);  
        this.layoutId = layoutId;  
        this.mlist = list;  
    }  
  
    /** 
     * 往顶部添加数据 
     *  
     * @param list 
     */  
    public void add2Head(List<T> list) {  
        mlist.addAll(0, list);  
        notifyDataSetChanged();  
    }  
      
    public void clearAll() {  
        mlist.clear();  
        notifyDataSetChanged();  
    }  
  
    public List<T> getAllList() {  
        return mlist;  
    }  
  
    /** 
     * 往底部添加数据 
     *  
     * @param list 
     */  
    public void add2Bottom(List<T> list) {  
        mlist.addAll(list);  
        notifyDataSetChanged();  
    }  
  
    public void add2Bottom(T t) {  
        mlist.add(t);  
        notifyDataSetChanged();  
    }  
  
    /** 
     * @Title: updateListView 
     * @Description: TODO(更新BaseAdapter中的数据) 
     * @param @param list 设定文件 
     * @return void 返回类型 
     * @throws 
     */  
    public void updateListView(List<T> list) {  
        mlist = list;  
        notifyDataSetChanged();  
    }  
  
    @Override  
    public int getCount() {  
        return mlist.size();  
    }  
  
    @Override  
    public T getItem(int position) {  
        return mlist.get(position);  
    }  
  
    @Override  
    public long getItemId(int position) {  
  
        return position;  
    }  
  
    /** 
     * 实际显示View的方法，使用抽象方法强制调用者覆写！ 
     */  
    @Override  
    public View getView(int position, View convertView, ViewGroup parent) {  
  
        ViewHolder viewHolder = ViewHolder.getViewHolder(parent, convertView,  
                inflater, layoutId);  
        convert(viewHolder, mlist.get(position));  
        return viewHolder.getConvertView();  
  
    }  
  
    public abstract void convert(ViewHolder viewHolder, T t);  
  
}

还有就是比如解析json,json的bean各有不同：

public class GsonImpl extends Json {  
    private Gson gson = new Gson();  
  
    @Override  
    public String toJson(Object src) {  
        return gson.toJson(src);  
    }  
  
    @Override  
    public <T> T toObject(String json, Class<T> claxx) {  
        return gson.fromJson(json, claxx);  
    }  
  
    @Override  
    public <T> T toObject(byte[] bytes, Class<T> claxx) {  
        return gson.fromJson(new String(bytes), claxx);  
    }  
  
    @Override  
    public <T> List<T> toList(String json, Class<T> claxx) {  
          Type type = new TypeToken<ArrayList<T>>() {}.getType();    
             List<T> list = gson.fromJson(json, type);    
        return list;  
    }  
}

下面着重复习java基础中有关泛型的知识点：

首先：泛型是java1.5提供的新特性；主要是为了解决数据类型的安全性问题，是在类声明的时候通过一个标示表示类中某个属性的类型或者是某个方法的返回值以及参数类型。这样在类声明或者实例化的时候只要指定好需要的类型即可。

泛型定义方法如下：

20160719135134874.png

如下为实际使用方式：

public class Point<T> {  
  
    private T data;  
  
    public T getData() {  
        return data;  
    }  
  
    public void setData(T data) {  
        this.data = data;  
    }  
}

能够更好的保护数据类型，避免编译时出错。减少类型转换的代码。
当然可以通过设置构造方法的参数为泛型来进行泛型操作的值传递。

在开发中对象的引用传递是最常见的，但是在泛型操作中，进行引用传递的时候泛型必须匹配才可以传递，否则无法传递。

class Info<T>{  
    private T var ;        // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){    // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo14{  
    public static void main(String args[]){  
        Info<String> i = new Info<String>() ;        // 使用String为泛型类型  
        i.setVar("MLDN") ;                            // 设置内容  
        fun(i) ;  
    }  
    public static void fun(Info<?> temp){        // 可以接收任意的泛型对象  
        System.out.println("内容：" + temp) ;  
    }  
};

使用？可以接受任意类型的数据，却无法进行修改，？w为通配符。

受限泛型

class Info<T>  
{  
    private T var;    // 定义泛型变量   
  
    public T getVar() {  
        return var;  
    }  
  
    public void setVar(T var) {  
        this.var = var;  
    }  
      
    public String toString(){    // 直接打印    
        return var.toString();  
    }  
      
}

public class GenericsDemo17 {      
      
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        Info<Integer> info1 = new Info<Integer>(); // 声明Integer的泛型对象    
        Info<Float> info2 = new Info<Float>();  // 声明Float的泛型对象  
        Info<String> info3 = new Info<String>();   
        info1.setVar(30);  // 设置整数，自动装箱  
        info2.setVar(30.1F);  // 设置小数，自动装箱    
        info3.setVar("俺是字符串，不能被受限的FUN组装");  
        fun(info1);  
        fun(info2);  
//        fun(info3);    //受限了，不能调用这个  
      
    }  
      
    /** 
     * 可以接收任意的泛型对象(// 只能接收Number及其Number的子类) 
     * @param temp 
     */  
    public static void fun(Info<? extends Number> temp){  
    // 只能接收String或Object类型的泛型  
    //public static void fun(Info<? super String> temp){  
        System.out.println("内容："+temp);  
    }  
      
}

不仅仅在使用过程中，也可以在定义类的时候指定泛型上限：

class Info<T extends Number>{    // 此处泛型只能是数字类型  
    private T var ;        // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){    // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo19{  
    public static void main(String args[]){  
        Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象  
    }  
};

如果设置成Stirng类型就会出现错误：

    GenericsDemo20.java:15: 类型参数 java.lang.String 不在   其限制范围之内  
    Info<String> i1 = new Info<String>() ;// 声明Integer的  泛型对象

String 不是Number的子类，最高不能超过Number的子类。
设置下限
=====
泛型适用于本类以及父类类型上的时候，必须使用泛型下限。

如下只能接受String以及String的父类。最低不能接受Stirng类及其父类以外的类。

class Info<T>{  
    private T var ;        // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){    // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo21{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;        // 声明String的泛型对象  
        Info<Object> i2 = new Info<Object>() ;        // 声明Object的泛型对象  
        i1.setVar("hello") ;  
        i2.setVar(new Object()) ;  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型  
        System.out.print(temp + "、") ;  
    }  
};

注意：子类无法使用父类的泛型类型进行接受。

class Info<T>{  
    private T var ;        // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){    // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo23{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;        // 泛型类型为String  
        Info<Object> i2 = null ;  
        i2 = i1 ;  
    }  
};

就会报如下错误：

    GenericsDemo23.java:17: 不兼容的类型  
    找到： Info<java.lang.String>  
    需要： Info<java.lang.Object>  
            i2 = i1 ;

泛型接口：

在jdk1.5以后，不仅仅可以声明泛型类，也可以声明泛型接口，泛型接口很类似泛型类：

访问权限 +interface +接口名称 + <泛型标示>{}
泛型接口实现的两种方式
==============
1、

interface Info<T>{        // 在接口上定义泛型  
    public T getVar() ;    // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl implements Info<String>{    // 定义泛型接口的子类  
    private String var ;                // 定义属性  
    public InfoImpl(String var){        // 通过构造方法设置属性内容  
        this.setVar(var) ;      
    }  
    public void setVar(String var){  
        this.var = var ;  
    }  
    public String getVar(){  
        return this.var ;  
    }  
};  
public class GenericsDemo{  
    public static void main(String arsg[]){  
        Info i = null;        // 声明接口对象  
        i = new InfoImpl("soyoungboy") ;    // 通过子类实例化对象  
        System.out.println("内容：" + i.getVar()) ;  
    }  
};

2、

interface Info<T>{        // 在接口上定义泛型  
    public T getVar() ;    // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl<T> implements Info<T>{    // 定义泛型接口的子类  
    private T var ;                // 定义属性  
    public InfoImpl(T var){        // 通过构造方法设置属性内容  
        this.setVar(var) ;      
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
};  
public class GenericsDemo{  
    public static void main(String arsg[]){  
        Info<String> i = null;        // 声明接口对象  
        i = new InfoImpl<String>("soyoungboy") ;    // 通过子类实例化对象  
        System.out.println("内容：" + i.getVar()) ;  
    }  
};

泛型方法：

泛型方法定义：

访问权限 +<泛型标示>+泛型标示方法名称（泛型标示参数名称）

class Demo{  
    public <T> T fun(T t){            // 可以接收任意类型的数据  
        return t ;                    // 直接把参数返回  
    }  
};  
public class GenericsDemo{  
    public static void main(String args[]){  
        Demo d = new Demo()    ;    // 实例化Demo对象  
        String str = d.fun("soyoungboy") ; //    传递字符串  
        int i = d.fun(30) ;        // 传递数字，自动装箱  
        System.out.println(str) ;    // 输出内容  
        System.out.println(i) ;        // 输出内容  
    }  
};

通过泛型方法返回泛型类的实例

class Info<T extends Number>{    // 指定上限，只能是数字类型  
    private T var ;        // 此类型由外部决定  
    public T getVar(){  
        return this.var ;      
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){        // 覆写Object类中的toString()方法  
        return this.var.toString() ;      
    }  
};  
public class GenericsDemo27{  
    public static void main(String args[]){  
        Info<Integer> i = fun(30) ;  
        System.out.println(i.getVar()) ;  
    }  
    public static <T extends Number> Info<T> fun(T param){  
        Info<T> temp = new Info<T>() ;        // 根据传入的数据类型实例化Info  
        temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中  
        return temp ;    // 返回实例化对象  
    }  
};

如果同一方法参数使用泛型，应该保证泛型类型一致：

class Info<T>{    // 指定上限，只能是数字类型  
    private T var ;        // 此类型由外部决定  
    public T getVar(){  
        return this.var ;      
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){        // 覆写Object类中的toString()方法  
        return this.var.toString() ;      
    }  
};  
public class GenericsDemo{  
    public static void main(String args[]){  
        Info<Integer> i1 = new Info<Integer>() ;  
        Info<String> i2 = new Info<String>() ;  
        i1.setVar(30) ;        // 设置内容  
        i2.setVar("aoyoungboy") ;        // 设置内容  
        add(i1,i2) ;  
    }  
    public static <T> void add(Info<T> i1,Info<T> i2){  
        System.out.println(i1.getVar() + " " + i2.getVar()) ;  
    }  
};

就会产生错误：

  【泛型】_泛型的其他应用\代码>javac GenericsDemo.java  
   GenericsDemo29.java:19: 无法将 GenericsDemo 中的      <T>add(Info<T>,Info<T>) 应用  
   于 (Info<java.lang.Integer>,Info<java.lang.String>)  
   add(i1,i2) ;

泛型数组

使用泛型方法的时候，也可以传递或者返回一个泛型数组：

public class GenericsDemo{  
    public static void main(String args[]){  
        Integer i[] = fun1(1,2,3,4,5,6) ;    // 返回泛型数组  
        fun2(i) ;  
    }  
    public static <T> T[] fun1(T...arg){    // 接收可变参数  
        return arg ;            // 返回泛型数组  
    }  
    public static <T> void fun2(T param[]){    // 输出  
        System.out.print("接收泛型数组：") ;  
        for(T t:param){  
            System.out.print(t + "、") ;  
        }  
    }  
};

泛型嵌套：

class Info<T,V>{        // 接收两个泛型类型  
    private T var ;  
    private V value ;  
    public Info(T var,V value){  
        this.setVar(var) ;  
        this.setValue(value) ;  
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
};  
class Demo<S>{  
    private S info ;  
    public Demo(S info){  
        this.setInfo(info) ;  
    }  
    public void setInfo(S info){  
        this.info = info ;  
    }  
    public S getInfo(){  
        return this.info ;  
    }  
};  
public class GenericsDemo{  
    public static void main(String args[]){  
        Demo<Info<String,Integer>> d = null ;        // 将Info作为Demo的泛型类型  
        Info<String,Integer> i = null ;    // Info指定两个泛型类型  
        i = new Info<String,Integer>("李兴华",30) ;     // 实例化Info对象  
        d = new Demo<Info<String,Integer>>(i) ;    // 在Demo类中设置Info类的对象  
        System.out.println("内容一：" + d.getInfo().getVar()) ;  
        System.out.println("内容二：" + d.getInfo().getValue()) ;  
    }  
};

泛型的作用及使用场景

受限泛型

注意：子类无法使用父类的泛型类型进行接受。

泛型接口：

泛型方法：

通过泛型方法返回泛型类的实例

如果同一方法参数使用泛型，应该保证泛型类型一致：

泛型数组

泛型嵌套：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

IT书籍阅读