泛型的其他应用

本章目标
掌握泛型接口的使用
掌握泛型方法的定义及使用
掌握泛型数组的使用
掌握泛型的嵌套设置

 

定义泛型接口
在JDK 1.5之后，不仅仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法类似，也是在接口名称后面加上<T>，如下格式所示：
——[访问权限] interface 接口名称<泛型标识>{}
interface Info<T>{  // 在接口上定义泛型
  public T getVar() ;
}

泛型接口的两种实现方式
泛型接口定义完成之后，下面就要定义此接口的子类，定义泛型接口的子类时有两种方式，一种是直接在子类之后声明泛型，另外一种是直接在子类实现的接口中明确的给出泛型类型。

实现1 —— 在子类的定义上声明泛型类型

public interface Info<T> {//在接口上定义泛型
	public T getVar();
}
class InfoImpl<T> implements Info<T>{//定义泛型接口的子类
	private T var;//定义属性
	public InfoImpl(T var){//通过构造方法设置属性内容
		this.setVar(var);
	}
	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
	
}

 

public class GenericDemo24 {
	public static void main(String[] args) {
		Info<String> i = null;//定义接口对象
		i = new InfoImpl<String>("chaoyi");//通过子类实例化此对象
		System.out.println("内容："+i.getVar());
	}
/* 结果：
 * 内容：chaoyi
 * */
}

 

实现2 —— 直接在接口中指定具体类型

public interface Info<T> {//在接口上定义泛型
	public T getVar();
}
class InfoImpl implements Info<String>{//定义泛型接口的子类，指定类型为 String
	private String var;//定义属性
	public InfoImpl(String var){//通过构造方法设置属性内容
		this.setVar(var);
	}
	public String getVar() {
		return var;
	}
	public void setVar(String var) {//接口上已指明类型，所以此处必须是 String
		this.var = var;
	}
	
}

 

public class GenericDemo25 {
	public static void main(String[] args) {
		Info<String> i = null;//定义接口对象
		i = new InfoImpl("chaoyi");//通过子类实例化此对象，不用指定泛型
		System.out.println("内容："+i.getVar());
	}
/* 结果：
 * 内容：chaoyi
 * */
}

 

定义泛型方法
泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型，使用如下的格式定义泛型方法。
泛型方法的简单定义：
——[访问权限] <泛型标识> 泛型标识 方法名称([泛型标识 参数名称])

 

定义一个泛型方法

class Demo{
	public <T>T fun(T t){//可以接收任何类型的数据
		return t;
	}
}
public class GenericDemo26 {
	public static void main(String[] args) {
		Demo d = new Demo();
		String str =d.fun("chaoyi");//传递字符串
		int i =d.fun(30);//传递数字
		System.out.println(str);//输出内容
		System.out.println(i);//输出内容
	}
/*结果：
 * chaoyi
 * 30
 * */
}

 

通过泛型方法返回泛型类实例
如果现在希望可以通过泛型方法返回一个泛型类的实例化对象的话，则必须在方法的返回类型声明处明确的指定泛型标识。

 

通过方法返回泛型类实例

class Info<T extends Number>{//此处泛型只能是数字类型
	private T var;//此变量的类型由外部决定
	public T getVar() {//返回值的类型由外部指定
		return var;
	}
	public void setVar(T var) {//设置的类型由外部指定
		this.var = var;
	}
	public String toString(){//覆写 Object 类中的 toString() 方法
		return this.var.toString();
	}
}
public class GenericDemo27 {
	public static void main(String[] args) {
		Info<Integer> i = fun(30);//传递整数到 fun() 方法
		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 ;  // 返回实例化对象
	}
/*结果：
 * 30
 * */
}

 

使用泛型统一传入的参数类型

class Info<T>{//此处泛型只能是数字类型
	private T var;//此变量的类型由外部决定
	public T getVar() {//返回值的类型由外部指定
		return var;
	}
	public void setVar(T var) {//设置的类型由外部指定
		this.var = var;
	}
	public String toString(){//覆写 Object 类中的 toString() 方法
		return this.var.toString();
	}
}
public class GenericDemo28 {
	public static void main(String[] args) {
		Info<String> i1 = new Info<String>();//设置 String 为泛型类型
		Info<String> i2 = new Info<String>();//设置 String 为泛型类型
		i1.setVar("choayi");//设置内容
		i2.setVar("阅谁问君诵，水落清香浮。");//设置内容
		add(i1, i2);
	}
	public static <T> void add(Info<T> i1,Info<T>i2){
		System.out.println(i1.getVar()+"、"+i2.getVar());
	}
/*结果：
 * choayi、阅谁问君诵，水落清香浮。
 * */
}

 

泛型数组
使用泛型方法时，也可以传递或返回一个泛型数组，如下代码所示。

public class GenericDemo30 {
	public static void main(String[] args) {
		Integer i[] =fun1(1,2,3,4,5,6,7,8);//返回泛型数组
		fun2(i);//输出数组内容
	}
	public static <T> T[] fun1(T... arg){//接收可变参数，返回泛型数组
		return arg;//返回泛型数组
	}
	public static <T> void fun2(T param[]){//接收泛型数组
		System.out.println("接收泛型数组：");
		for(T t:param){
			System.out.print(t+"、");
		}
		System.out.println("");
	}
/*结果：
 * 接收泛型数组：
 * 1、2、3、4、5、6、7、8、
 * */
}

 

泛型的嵌套设置
可以在一个类的泛型中指定另外一个类的泛型。

class Info<T,V>{//指定两个泛型类型
	private T var;//第 1 个泛型属性
	private V value;//第 2 个泛型属性
	public Info(T var, V value) {//通过构造方法设置
		this.var = var;
		this.value = value;
	}
	public T getVar() {
		return var;
	}
	public void setVar(T var) {
		this.var = var;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
}
class Demo<S>{
	private S info;
	public Demo(S info) {
		this.info = info;
	}
	public S getInfo() {
		return info;
	}
	public void setInfo(S info) {
		this.info = info;
	}	
}
public class GenericDemo31 {
	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>("chaoyi", 30);
		d =new Demo<Info<String,Integer>>(i);//在 Demo 类中设置 Info 类对象
		System.out.println("内容一："+d.getInfo().getVar());
		System.out.println("内容二："+d.getInfo().getValue());
	}
/*结果：
 * 内容一：chaoyi
 * 内容二：30
 * */
}