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

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

Java基础突击第七天0015(泛型二)

猜你喜欢