泛型接口
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