泛型的其他應用-接口，方法定義使用，泛型數組，泛型的嵌套設置。

掌握泛型的接口的使用；

掌握泛型方法的定義與使用；

掌握泛型數組的使用；

掌握泛型的嵌套設置；

具體內容

1.1泛型接口基本概念

　　之前所有的操作都是在類中直接使用泛型操作的，那么，對於JAVA來說，也可以在接口中定義及使用泛型。

　　聲明泛型接口：　　interface 接口名稱<接口標示>{}

interface Info<T>
{
    public T getInfo();  
}

　　如果現在一個子類實現此接口是沒有進行正確的實現，則在編譯時候會出現警告， 例子：

interface Info<T>{        // 在接口上定義泛型
    public T getVar() ;    // 定義抽象方法，抽象方法的返回值就是泛型類型
}
class InfoImpl implements Info{    // 定義泛型接口的子類
    public T getVar(){
        return null ;
    }
};

　　以上操作不是一個子類實現泛型最好操作，最好在實現的時候也指定其具體的泛型類型。

1.2泛型接口實現的兩種方式

　　第一方式：定義子類，在子類上也聲明泛型類型。

package Thread1;
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 demo1{
    public static void main(String arsg[]){
        Info<String> i = null; // 聲明接口對象 i = new InfoImpl<String>("李興華") ; // 通過子類實例化對象
        System.out.println("內容：" + i.getVar()) ;
    }
};

　　第二方式：如果現在實現接口的子類不想使用泛型聲明，則在實現接口的時候直接指定好具體的操作類型即可。

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 GenericsDemo25{
    public static void main(String arsg[]){
        Info i = null; // 聲明接口對象 i = new InfoImpl("李興華") ; // 通過子類實例化對象
        System.out.println("內容：" + i.getVar()) ;
    }
};

　　但是對於后者，在使用泛型接口的時候往往會直接采用。

2泛型方法

　　之前所有的泛型除了可以為類中屬性指定類型外，也可定義方法，泛型方法所在的類中是否是泛型類，本身並沒有任何關系。

2.1定義泛型方法

　　泛型方法的簡單定義：【訪問權限】<泛型標識> 泛型標識 方法名稱（【泛型標識  參數名稱】）

 

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

 

　　注意：“《T》”這個不能缺少，而且緊跟后面的“T”也不能少。《T》表示定義泛型標識"T"為泛型類型，只是起到了定義聲明作用，並沒有起到返回類型的作用，因此需要后面這個T表示返回的類型。注意兩個“T”和“《T》”的作用不同。　　

　　這個代碼利用了自動裝箱，自動拆箱的操作。例如30自動轉化成Integer類型給t，然后t返回給“i”的時候自動拆箱成int類型。

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

　　因為之前代碼中可以發現，只要在方法中定義了泛型操作，則可以傳遞任意的數據類型。

package Thread1;
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 demo1{
    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){　　　　//這里的“<T extends Number>” 的作用是表示聲明定義“T”為泛型類型。而"Info<T>"的作用是方法返回值類型。
        Info<T> temp = new Info<T>() ;        // 根據傳入的數據類型實例化Info，比如傳遞的param為String類型，則這個方法里的“T”就為String類型。
        temp.setVar(param) ;        // 將傳遞的內容設置到Info對象的var屬性之中
        return temp ;    // 返回實例化對象
    }
};

2.3 使用泛型統一傳遞參數的類型

　　如果在一些操作中，希望傳遞的泛型類型是一致的。

　　

package Thread1;
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 demo1{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>() ;
        Info<String> i2 = new Info<String>() ;
        i1.setVar("HELLO") ;        // 設置內容
        i2.setVar("李興華") ;        // 設置內容
 add(i1,i2) ;
    }
    public static <T> void add(Info<T> i1,Info<T> i2){
        System.out.println(i1.getVar() + " " + i2.getVar()) ;
    }
};

　　運行結果：

HELLO 李興華

　　但是，如果現在傳人到add方法中的兩個泛型使用類型不統一，就會出現錯誤。

package Thread1;
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 demo1{
    public static void main(String args[]){
        Info<Integer> i1 = new Info<Integer>() ;
        Info<String> i2 = new Info<String>() ;
        i1.setVar(30) ;        // 設置內容
        i2.setVar("李興華") ;        // 設置內容
 add(i1,i2) ;
    }
    public static <T> void add(Info<T> i1,Info<T> i2){
        System.out.println(i1.getVar() + " " + i2.getVar()) ;
    }
};

　　運行結果：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The method add(Info<T>, Info<T>) in the type demo1 is not applicable for the arguments (Info<Integer>, Info<String>)

    at Thread1.demo1.main(demo1.java:20)

　　錯誤的原因是因為，在定義的時候兩個對象的類型不同，但是在add()方法中，大家的類型都是“<T>”類型，這樣就產生了沖突。

　　這種方法能夠幫我們解決一些容易出現的錯誤問題。

2.5泛型數組

　　使用泛型方法的時候，也可以傳遞或返回一個泛型數組。

public class GenericsDemo30{
    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 + "、") ;
        }
    }
};

　　這里利用了可變參數。

　　注意：這里之所以”i[]“數組的類型用Integer，而不用int，是因為，這里的"i"數組要傳遞給“T”作泛型，但是int 是基本數據類型，Integer是其包裝類，注意是一個類，泛型也是求是類的，所以要用integer。

2.6泛型的嵌套設置

　　之前的全部泛型操作，都是直接通過實例化類完成的，當然，在設置的時候，也會看見嵌套的設置形式：也就是說，我在指定一個泛型的同時也會指定另一個泛型。

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

　　以上在操作的時候，希望Demo類中Info屬性是Info類。也就是說，S的類型是Info，但是Info類本身使用的時候，需要設置兩個泛型。

public class GenericsDemo31{
    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()) ;
    }
};

　　完整代碼：

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

總結

　　1，泛型在接口可以定義，及其實現的方式。

　　2，泛型在使用的時候可以進行嵌套操作，只要根據其操作語法即可。

　　3，泛型語法上使用泛型標記的時候，需要先聲明，同樣可以指定其操作的上限和下限。