Java泛型的其他應用——泛型接口、泛型方法、泛型數組以及泛型的嵌套設置
來源：程序員人生 發布時間：2016-07-11 15:50:15 閱讀次數：3333次
學習目標
掌握泛型接口的使用
掌握泛型方法的定義的及使用
掌握泛型數組的使用
掌握泛型的嵌套設置
之前所有的操作都是在類中直接使用泛型操作的，那末，對Java來講，也能夠直接在接口中定義及使用泛型。
定義泛型接口
在JDK1.5以后，不單單可以聲明泛型類，也能夠聲明泛型接口，聲明泛型接口和聲明泛型類的語法類似，也是在接口名稱后面加上<T>,以下格式所示：
[訪問權限] interface 接口名稱<泛型標識>{}
interface Info<T>{ // 在接口上定義泛型
public T getVar() ; // 定義抽象方法，抽象方法的返回值就是泛型類型
}
如果現在1個子類實現此接口但是沒有進行正確的實現，則在編譯時會出現正告信息。
interface Info<T>{
public T getVar();
}
class InfoImpl implements Info{
public String getVar(){
return null;
}
}
以上的操作，其實不是1個子類實現泛型的最好操作，最好在實現的時候也指定具體的泛型類型。
泛型接口實現的兩種方式
定義子類：在子類的定義上在也聲明泛型類型。
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 GenericsDemo24{
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()) ;
}
};
對后者，常常使用。泛型方法
之前的所有泛型除可以為類中的屬性指定類型以外，也能夠定義方法，泛型方法所在的類中是不是是泛型類本身是沒有任何關系的。
定義泛型方法
泛型方法可以定義泛型參數，此時，參數的類型就是傳入數據的類型，使用以下格式定義泛型方法。
泛型方法的簡單定義：
[訪問權限]<泛型標示> 泛型標示 方法名稱([泛型標示 參數名稱])
程序實例以下：
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(24) ; // 傳遞數字，自動裝箱
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(20) ;
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 ; // 返回實例化對象
}
};
使用泛型統1傳入參數的類型
如果在1些操作中，希望傳遞的泛型類型是1致的類型。
實例以下：
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 GenericsDemo28{
public static void main(String args[]){
Info<String> i1 = new Info<String>() ;
Info<String> i2 = new Info<String>() ;
i1.setVar("HELLO") ; // 設置內容
i2.setVar("liuxun") ; // 設置內容
add(i1,i2) ;
}
public static <T> void add(Info<T> i1,Info<T> i2){
System.out.println(i1.getVar() + " " + i2.getVar()) ;
}
};
但是如果傳遞到add定單中的兩個泛型類型不統1，則會出現毛病。
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 GenericsDemo29{
public static void main(String args[]){
Info<Integer> i1 = new Info<Integer>() ;
Info<String> i2 = new Info<String>() ;
i1.setVar(20) ; // 設置內容
i2.setVar("liuxun") ; // 設置內容
add(i1,i2) ; // X ：此處由于類型不1致就會出現毛病
}
public static <T> void add(Info<T> i1,Info<T> i2){
System.out.println(i1.getVar() + " " + i2.getVar()) ;
}
};
泛型數組
使用泛型方法的時候，也能夠傳遞或返回1個泛型數組。
程序以下：
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 + "、") ;
}
}
};
注意：... 表示可變參數 ，可以傳遞任意多的參數，可以當數組進行處理。
泛型的嵌套設置
之前所說的全部泛型操作，都是直接通過實例化類的時候完成，固然，在設置的時候也會看見嵌套的設置情勢。
程序實例以下：
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>("劉勛",20) ; // 實例化Info對象
d = new Demo<Info<String,Integer>>(i) ; // 在Demo類中設置Info類的對象
System.out.println("內容1：" + d.getInfo().getVar()) ;
System.out.println("內容2：" + d.getInfo().getValue()) ;
}
};
總結：
1、泛型在接口上可以定義，及其實現的方式。
2、泛型在使用的時候可以進行嵌套的操作，只要根據其操作語法便可。
3、泛型方法上使用泛型標記的時候需要先聲明，一樣可以指定其操作的上限和下限。
生活不易，碼農辛苦
如果您覺得本網站對您的學習有所幫助,可以手機掃描二維碼進行捐贈
