Java基礎突擊第七天0015(泛型二)

泛型接口

1.5之後，不僅可以聲明泛型類，也可以聲明泛型接口。

interface Info<T>{

        public T getVar();

}

泛型接口有兩種實現方式：直接在子類定義中聲明泛型/直接在子類實現的接口中明確給出泛型

第一種：直接在子類定義中聲明泛型寫法:class InfoClass<T> implements Info<T>

public class TestJava{
}
interface Info<T>{
	  public T getVar();
}
class InfoClass<T> implements Info<T>{
		private T var;
		public InfoClass(T var){
				this.var = var;
		}
		public void getVar(T var){
				this.var = var;
		}
		public T getVar(){
				return this.var;
		}
}
class Demo{
		public static void main(String[] args){
				Info<String> info = new InfoClass<String>("FangXy");
				System.out.println("Content:"+info.getVar());
		}
}//Demo

Output:Content:FangXy

寫法:class InfoClass<T> implements Info<T>

上例雖然指定了泛型，依然用子類來實例化接口，展現了多態性。

第二種：直接在接口中指定具體類型

class InfoClass implements Info<T>

public class TestJava{
}
interface Info<T>{
	  public T getVar();
}
class InfoClass implements Info<String>{
		private String var;
		public InfoClass(String var){
				this.var = var;
		}
		public void setVar(String var){
				this.var = var;
		}
		public String getVar(){
				return this.var;
		}
}
class Demo{
		public static void main(String[] args){
				Info<String> info = new InfoClass("FangXy");
				System.out.println("Content:"+info.getVar());
		}
}//Demo

Output：Content:FangXy

直接在子類實現接口時指定具體的泛型類型String。

覆寫接口中方法時，直接T換成String即可。

泛型方法：泛型方法的定義與其所在的類是否是泛型類沒有任何關係。

public <T>T   function(T  parameter)

public class TestJava{
}
class Info{
		public <T>T function(T temp){
				return temp;
		}
}
class Demo{
		public static void main(String[] args){
				Info info = new Info();
				String strTemp = info.function("FangXy");
				int intTemp = info.function(20);
				System.out.println(strTemp);
				System.out.println(intTemp);
		}
}//Demo

Output:

FangXy

20

function程序是將接收的參數直接返回。方法在接收參數中使用了泛型操作，所以此方法可以接收任意類型的數據。

方法的返回值類型由泛型指定。（public <T>T function(T parameter)）-->  String -> info.f(String)  int -> info.f(int)

通過泛型方法返回泛型實例（泛型類的實例化對象）。

public class TestJava{
}
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();
		}
}
class Demo{
		public static void main(String[] args){
				Info<Integer> strInfo = transmit(30);
				System.out.println(30);
		}
		public static <T extends Number>Info<T> transmit(T parameter){
				Info<T> temp = new Info<T>();
				temp.setVar(parameter);
				return temp;
		}
}//Demo

output:30

使用泛型統一傳入的參數類型

public class TestJava{
}
class Info<T>{
		private T var;
		public T getVar(){
				return var;
		}
		public void setVar(T var){
				this.var = var;
		}
		public String toString(){
				return this.var.toString();
		}
}
class Demo{
		public static <T>void unify(Info<T> parameter01,Info<T> parameter02){
				System.out.println("P01:"+parameter01.getVar()+" P02:"+parameter02.getVar());
		}
		public static void main(String[] args){
				Info<String> infoStr = new Info<String>();
				//Info<Integer> infoInt = new Info<Integer>();
				Info<String> infoStrN = new Info<String>();
				infoStr.setVar("FangXy");
				//infoInt.setVar(23);
				infoStrN.setVar("07999051");
				//unify(infoStr,infoInt);
				unify(infoStr,infoStrN);
		}
}//Demo

output:P01:FangXy P02:07999051

如程序註釋所示，若向unify傳入不同類型的參數則會編譯錯誤。

經測試，unify中參數類型必須一致，即使是Short和Integer一起傳入也會報錯。

此種方法可以爲程序操作的安全性提供保障。

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

public class TestJava{
}
class Demo{
		public static void main(String[] args){
				Integer intArr[] = returnGenericArray(1,2,3,4,5,6);
				recGenericArray(intArr);
		}
		public static <T>T[] returnGenericArray(T... array){   //receive variable array
				return array;																			//return generic array
		}
		public static <T>void recGenericArray(T genericArray[]){ //receive generic array
				for(T temp:genericArray){
						System.out.print(temp+" ");
				}
				System.out.println();
		}
}//Demo

output:1 2 3 4 5 6

雖然正常輸出了，不過給了提示信息。

注: TestJava.java使用了未經檢查或不安全的操作。

注: 有關詳細信息, 請使用 -Xlint:unchecked 重新編譯。

泛型也是可以嵌套的

如用泛型指定Info中的Key和Value，再用recInfo接收info類型的實例。達成泛型嵌套。

最後通過recInfo的實例化對象對Key和Value進行輸出。

public class TestJava{
}
class Info<K,V>{
		private K key;
		private V value;
		public Info(K key,V value){
				this.key = key;
				this.value = value;
		}
		public void setKey(K key){
				this.key = key;
		}
		public void setValue(V value){
				this.value = value;
		}
		public K getKey(){
				return this.key;
		}
		public V getValue(){
				return this.value;
		}
}
class RecInfo<S>{
		private S info;
		public RecInfo(S info){
				this.info = info;
		}
		public S getInfo(){
				return this.info;
		}
		public void setInfo(S info){
				this.info = info;
		}
}
class Demo{
		public static void main(String[] args){
				RecInfo<Info<String,Integer>> recDemo = null;
				Info<String,Integer> infoDemo = null;
				infoDemo = new Info<String,Integer>("FangXy",22);
				recDemo = new RecInfo<Info<String,Integer>>(infoDemo);
				System.out.println("Key:"+recDemo.getInfo().getKey());
				System.out.println("Value:"+recDemo.getInfo().getValue());
		}
}//Demo

output:

Key:FangXy

Value:22