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

泛型的其他應用