泛型的作用及使用場景

Android使用泛型的地方很多，比如集成自BaseAdapter實現(xiàn)封裝的Adapter,對常用操作進行封裝，但是需要對傳進來的數(shù)據(jù)進行處理，此時就使用到泛型，示例如下：

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;  
    }  
  
    /** 
     * 往頂部添加數(shù)據(jù) 
     *  
     * @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;  
    }  
  
    /** 
     * 往底部添加數(shù)據(jù) 
     *  
     * @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中的數(shù)據(jù)) 
     * @param @param list 設(shè)定文件 
     * @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的方法，使用抽象方法強制調(diào)用者覆寫！ 
     */  
    @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;  
    }  
}

下面著重復(fù)習(xí)java基礎(chǔ)中有關(guān)泛型的知識點：

首先：泛型是java1.5提供的新特性；主要是為了解決數(shù)據(jù)類型的安全性問題，是在類聲明的時候通過一個標示表示類中某個屬性的類型或者是某個方法的返回值以及參數(shù)類型。這樣在類聲明或者實例化的時候只要指定好需要的類型即可。

泛型定義方法如下：

20160719135134874.png

如下為實際使用方式：

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

能夠更好的保護數(shù)據(jù)類型，避免編譯時出錯。減少類型轉(zhuǎn)換的代碼。
當然可以通過設(shè)置構(gòu)造方法的參數(shù)為泛型來進行泛型操作的值傳遞。

在開發(fā)中對象的引用傳遞是最常見的，但是在泛型操作中，進行引用傳遞的時候泛型必須匹配才可以傳遞，否則無法傳遞。

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") ;                            // 設(shè)置內(nèi)容  
        fun(i) ;  
    }  
    public static void fun(Info<?> temp){        // 可以接收任意的泛型對象  
        System.out.println("內(nèi)容：" + temp) ;  
    }  
};

使用？可以接受任意類型的數(shù)據(jù)，卻無法進行修改，？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);  // 設(shè)置整數(shù)，自動裝箱  
        info2.setVar(30.1F);  // 設(shè)置小數(shù)，自動裝箱    
        info3.setVar("俺是字符串，不能被受限的FUN組裝");  
        fun(info1);  
        fun(info2);  
//        fun(info3);    //受限了，不能調(diào)用這個  
      
    }  
      
    /** 
     * 可以接收任意的泛型對象(// 只能接收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("內(nèi)容："+temp);  
    }  
      
}

不僅僅在使用過程中，也可以在定義類的時候指定泛型上限：

class Info<T extends Number>{    // 此處泛型只能是數(shù)字類型  
    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的泛型對象  
    }  
};

如果設(shè)置成Stirng類型就會出現(xiàn)錯誤：

    GenericsDemo20.java:15: 類型參數(shù) java.lang.String 不在   其限制范圍之內(nèi)  
    Info<String> i1 = new Info<String>() ;// 聲明Integer的  泛型對象

String 不是Number的子類，最高不能超過Number的子類。
設(shè)置下限
=====
泛型適用于本類以及父類類型上的時候，必須使用泛型下限。

如下只能接受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以后，不僅僅可以聲明泛型類，也可以聲明泛型接口，泛型接口很類似泛型類：

訪問權(quán)限 +interface +接口名稱 + <泛型標示>{}
泛型接口實現(xiàn)的兩種方式
==============
1、

interface Info<T>{        // 在接口上定義泛型  
    public T getVar() ;    // 定義抽象方法，抽象方法的返回值就是泛型類型  
}  
class InfoImpl implements Info<String>{    // 定義泛型接口的子類  
    private String var ;                // 定義屬性  
    public InfoImpl(String var){        // 通過構(gòu)造方法設(shè)置屬性內(nèi)容  
        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("內(nèi)容：" + i.getVar()) ;  
    }  
};

2、

interface Info<T>{        // 在接口上定義泛型  
    public T getVar() ;    // 定義抽象方法，抽象方法的返回值就是泛型類型  
}  
class InfoImpl<T> implements Info<T>{    // 定義泛型接口的子類  
    private T var ;                // 定義屬性  
    public InfoImpl(T var){        // 通過構(gòu)造方法設(shè)置屬性內(nèi)容  
        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("內(nèi)容：" + i.getVar()) ;  
    }  
};

泛型方法：

泛型方法定義：

訪問權(quán)限 +<泛型標示>+泛型標示 方法名稱（泛型標示 參數(shù)名稱）

class Demo{  
    public <T> T fun(T t){            // 可以接收任意類型的數(shù)據(jù)  
        return t ;                    // 直接把參數(shù)返回  
    }  
};  
public class GenericsDemo{  
    public static void main(String args[]){  
        Demo d = new Demo()    ;    // 實例化Demo對象  
        String str = d.fun("soyoungboy") ; //    傳遞字符串  
        int i = d.fun(30) ;        // 傳遞數(shù)字，自動裝箱  
        System.out.println(str) ;    // 輸出內(nèi)容  
        System.out.println(i) ;        // 輸出內(nèi)容  
    }  
};

通過泛型方法返回泛型類的實例

class Info<T extends Number>{    // 指定上限，只能是數(shù)字類型  
    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>() ;        // 根據(jù)傳入的數(shù)據(jù)類型實例化Info  
        temp.setVar(param) ;        // 將傳遞的內(nèi)容設(shè)置到Info對象的var屬性之中  
        return temp ;    // 返回實例化對象  
    }  
};

如果同一方法參數(shù)使用泛型，應(yīng)該保證泛型類型一致：

class Info<T>{    // 指定上限，只能是數(shù)字類型  
    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) ;        // 設(shè)置內(nèi)容  
        i2.setVar("aoyoungboy") ;        // 設(shè)置內(nèi)容  
        add(i1,i2) ;  
    }  
    public static <T> void add(Info<T> i1,Info<T> i2){  
        System.out.println(i1.getVar() + " " + i2.getVar()) ;  
    }  
};

就會產(chǎn)生錯誤：

  【泛型】_泛型的其他應(yīng)用\代碼>javac GenericsDemo.java  
   GenericsDemo29.java:19: 無法將 GenericsDemo 中的      <T>add(Info<T>,Info<T>) 應(yīng)用  
   于 (Info<java.lang.Integer>,Info<java.lang.String>)  
   add(i1,i2) ;

泛型數(shù)組

使用泛型方法的時候，也可以傳遞或者返回一個泛型數(shù)組：

public class GenericsDemo{  
    public static void main(String args[]){  
        Integer i[] = fun1(1,2,3,4,5,6) ;    // 返回泛型數(shù)組  
        fun2(i) ;  
    }  
    public static <T> T[] fun1(T...arg){    // 接收可變參數(shù)  
        return arg ;            // 返回泛型數(shù)組  
    }  
    public static <T> void fun2(T param[]){    // 輸出  
        System.out.print("接收泛型數(shù)組：") ;  
        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類中設(shè)置Info類的對象  
        System.out.println("內(nèi)容一：" + d.getInfo().getVar()) ;  
        System.out.println("內(nèi)容二：" + d.getInfo().getValue()) ;  
    }  
};
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 在沒有泛型之前，從集合讀取到的每一個對象都必須進行轉(zhuǎn)換。如果有人不小心插入了類型錯誤的對象，在運行時的轉(zhuǎn)換處理就會...
    Uenchi閱讀 1,511評論 0贊 1
  • object 變量可指向任何類的實例，這讓你能夠創(chuàng)建可對任何數(shù)據(jù)類型進程處理的類。然而，這種方法存在幾個嚴重的問題...
    CarlDonitz閱讀 1,021評論 0贊 5
  • Spring Cloud為開發(fā)人員提供了快速構(gòu)建分布式系統(tǒng)中一些常見模式的工具（例如配置管理，服務(wù)發(fā)現(xiàn)，斷路器，智...
    卡卡羅2017閱讀 136,653評論 19贊 139
  • 前些日子和一位朋友聊天，談及夢想時都黯然神傷。我們所就讀的學(xué)校算不上好，一個好的大學(xué)于我們而言就是一座難以企及的高...
    172a2ac1b993閱讀 295評論 0贊 0
  • 奇妙清單 一句話推薦：全平臺都可以使用的支持團隊協(xié)作的工具（ios/adroid/mac/win/watch） 界...
    lanbizi閱讀 1,753評論 2贊 50

友情鏈接更多精彩內(nèi)容