java泛型操做複習，以及講解在android中使用的場景

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); }

代碼來自個人github:https://github.com/soyoungboy/EasyAnroid/blob/master/EasyAnroid/src/com/soyoungboy/base/adapter/EasyAdapter.java

還有就是好比解析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提供的新特性；主要是爲了解決數據類型的安全性問題，是在類聲明的時候經過一個標示表示類中某個屬性的類型或者是某個方法的返回值以及參數類型。這樣在類聲明或者實例化的時候只要指定好須要的類型便可。

泛型定義方法以下：

以下爲實際使用方式：

可以更好的保護數據類型，避免編譯時出錯。減小類型轉換的代碼。

固然能夠經過設置構造方法的參數爲泛型來進行泛型操做的值傳遞。

多個泛型類型

 

泛型的安全警告

---

 

我只是嘗試着天天都在學習和進步

通配符

在開發中對象的引用傳遞是最多見的，可是在泛型操做中，進行引用傳遞的時候泛型必須匹配才能夠傳遞，不然沒法傳遞。

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()) ; } };

泛型的其餘應用