泛型的其他应用---------（3）

1，泛型接口的使用

2，泛型方法的定义及使用

3，泛型数组的使用

4，泛型的嵌套设置

5，泛型应用范例

1，泛型接口

声明泛型接口和声明泛型类的语法类似，也是在接口名称后面加上，格式：

interface Info<T>{		// 在接口上定义泛型
	public T getVar() ;	// 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl implements Info{	// 定义泛型接口的子类
	
	public String getVar(){
		return null ;
	}
};

这样直接继承，使用，把泛型类型设置成了一个String，运行不会有问题，但是这样的使用，其实并不是最好的实现泛型接口的操作，最好在实现的时候，也指定其具体的泛型类型。

泛型接口的实现的两种方式

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()) ;
	}
};

如果现在实现接口的子类不想使用泛型声明，则在实现接口的时候直接指定好其具体的操作类型即可。

2，第二种：直接实现，在实现泛型接口的时候指定具体的泛型类型。

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()) ;
	}
};

2，泛型方法

泛型出了可以为类中的属性指定数据类型以外，也可以定义方法，泛型方法所在的类是否是泛型类并没有任何关系。

定义泛型方法

泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型，使用格式：

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(30) ;		// 传递数字，自动装箱
		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(30) ;
		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 ;	// 返回实例化对象
	}
};

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

如果在一些操作中，希望传递的泛型类型是一致的类型。
比如如下代码的add方法的两个参数类型由外部指定且保持一致，则可以使用泛型。

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("李兴华") ;		// 设置内容
		add(i1,i2) ;
	}
	public static <T> void add(Info<T> i1,Info<T> i2){
		System.out.println(i1.getVar() + " " + i2.getVar()) ;
	}
};

但是如果传递到add方法中的两个泛型类型不统一，则编译时期就会出现错误，因为两个参数的类型都是使用T表示，两个T是同一个类型。如下：

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(30) ;		// 设置内容
		i2.setVar("李兴华") ;		// 设置内容
		add(i1,i2) ;
	}
	public static <T> void add(Info<T> i1,Info<T> i2){
		System.out.println(i1.getVar() + " " + i2.getVar()) ;
	}
};

使用泛型方法，可以很方便的检查参数类型的问题。

泛型数组

参数是一个数组，数组是一个方法的可变参数，数组里都是T类型的数据：

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>("李兴华",30) ;	 // 实例化Info对象
		d = new Demo<Info<String,Integer>>(i) ;	// 在Demo类中设置Info类的对象
		System.out.println("内容一：" + d.getInfo().getVar()) ;
		System.out.println("内容二：" + d.getInfo().getValue()) ;
	}
};

5，泛型应用范例

例子：假设表示一个人的信息，信息有基本信息和联系方式等信息。
很明显，信息定义为一个接口，实现了此接口的类才可以表示出人的信息：

interface Info{		// 只有此接口的子类才是表示人的信息
}

接口定义完成，但是接口中没有任何的方法，这样的接口称为标识接口。
之后定义人的类，人的类中只要是此接口的子类都可以表示人的信息。

总结

1，泛型可以在接口上定义。
2，泛型在使用的时候，可以进行嵌套。
3，泛型方法上使用泛型标记的时候需要声明，同样可以指定其操作的上限和下限。