标签：
掌握泛型的接口的使用；
掌握泛型方法的定义与使用；
掌握泛型数组的使用；
掌握泛型的嵌套设置；
之前所有的操作都是在类中直接使用泛型操作的，那么，对于JAVA来说，也可以在接口中定义及使用泛型。
声明泛型接口： interface 接口名称<接口标示>{}
interface Info<T> { public T getInfo(); }
如果现在一个子类实现此接口是没有进行正确的实现，则在编译时候会出现警告， 例子：
interface Info<T>{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型 } class InfoImpl implements Info{ // 定义泛型接口的子类 public T getVar(){ return null ; } };
以上操作不是一个子类实现泛型最好操作，最好在实现的时候也指定其具体的泛型类型。
第一方式：定义子类，在子类上也声明泛型类型。
package Thread1; 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 demo1{ public static void main(String arsg[]){ Info<String> i = null; // 声明接口对象 i = new InfoImpl<String>("李兴华") ; // 通过子类实例化对象 System.out.println("内容：" + i.getVar()) ; } };
第二方式：如果现在实现接口的子类不想使用泛型声明，则在实现接口的时候直接指定好具体的操作类型即可。
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()) ; } };
但是对于后者，在使用泛型接口的时候往往会直接采用。
之前所有的泛型除了可以为类中属性指定类型外，也可定义方法，泛型方法所在的类中是否是泛型类，本身并没有任何关系。
泛型方法的简单定义：【访问权限】<泛型标识> 泛型标识 方法名称（【泛型标识 参数名称】）
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) ; // 输出内容 } };
注意：“《T》”这个不能缺少，而且紧跟后面的“T”也不能少。《T》表示定义泛型标识"T"为泛型类型，只是起到了定义声明作用，并没有起到返回类型的作用，因此需要后面这个T表示返回的类型。注意两个“T”和“《T》”的作用不同。
这个代码利用了自动装箱，自动拆箱的操作。例如30自动转化成Integer类型给t，然后t返回给“i”的时候自动拆箱成int类型。
因为之前代码中可以发现，只要在方法中定义了泛型操作，则可以传递任意的数据类型。
package Thread1; 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 demo1{ 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){ //这里的“<T extends Number>” 的作用是表示声明定义“T”为泛型类型。而"Info<T>"的作用是方法返回值类型。 Info<T> temp = new Info<T>() ; // 根据传入的数据类型实例化Info，比如传递的param为String类型，则这个方法里的“T”就为String类型。 temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中 return temp ; // 返回实例化对象 } };
如果在一些操作中，希望传递的泛型类型是一致的。
package Thread1; 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 demo1{ 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()) ; } };
运行结果：
HELLO 李兴华
但是，如果现在传人到add方法中的两个泛型使用类型不统一，就会出现错误。
package Thread1; 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 demo1{ 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()) ; } };
运行结果：
Exception in thread "main" java.lang.Error: Unresolved compilation problem: The method add(Info<T>, Info<T>) in the type demo1 is not applicable for the arguments (Info<Integer>, Info<String>) at Thread1.demo1.main(demo1.java:20)
错误的原因是因为，在定义的时候两个对象的类型不同，但是在add()方法中，大家的类型都是“<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 + "、") ; } } };
这里利用了可变参数。
注意：这里之所以”i[]“数组的类型用Integer，而不用int，是因为，这里的"i"数组要传递给“T”作泛型，但是int 是基本数据类型，Integer是其包装类，注意是一个类，泛型也是求是类的，所以要用integer。
之前的全部泛型操作，都是直接通过实例化类完成的，当然，在设置的时候，也会看见嵌套的设置形式：也就是说，我在指定一个泛型的同时也会指定另一个泛型。
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 ; } };
以上在操作的时候，希望Demo类中Info属性是Info类。也就是说，S的类型是Info，但是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()) ; } };
完整代码：
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()) ; } };
1，泛型在接口可以定义，及其实现的方式。
2，泛型在使用的时候可以进行嵌套操作，只要根据其操作语法即可。
3，泛型语法上使用泛型标记的时候，需要先声明，同样可以指定其操作的上限和下限。
泛型的其他应用-接口，方法定义使用，泛型数组，泛型的嵌套设置。
标签：
原文地址：http://www.cnblogs.com/alsf/p/5697548.html
