泛型的其他应用-接口，方法定义使用，泛型数组，泛型的嵌套设置。

掌握泛型的接口的使用；

掌握泛型方法的定义与使用；

掌握泛型数组的使用；

掌握泛型的嵌套设置；

具体内容

1.1泛型接口基本概念

　　之前所有的操作都是在类中直接使用泛型操作的，那么，对于JAVA来说，也可以在接口中定义及使用泛型。

　　声明泛型接口：　　interface 接口名称<接口标示>{}

interface Info<T>
{
    public T getInfo();  
}

　　如果现在一个子类实现此接口是没有进行正确的实现，则在编译时候会出现警告， 例子：

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

　　以上操作不是一个子类实现泛型最好操作，最好在实现的时候也指定其具体的泛型类型。

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

　　第一方式：定义子类，在子类上也声明泛型类型。

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

　　但是对于后者，在使用泛型接口的时候往往会直接采用。

2泛型方法

　　之前所有的泛型除了可以为类中属性指定类型外，也可定义方法，泛型方法所在的类中是否是泛型类，本身并没有任何关系。

2.1定义泛型方法

　　泛型方法的简单定义：【访问权限】<泛型标识> 泛型标识 方法名称（【泛型标识  参数名称】）

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类型。

2.2通过泛型方法，返回泛型类的实例。

　　因为之前代码中可以发现，只要在方法中定义了泛型操作，则可以传递任意的数据类型。

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 ;    // 返回实例化对象
    }
};

2.3 使用泛型统一传递参数的类型

　　如果在一些操作中，希望传递的泛型类型是一致的。

　　

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>”类型，这样就产生了冲突。

　　这种方法能够帮我们解决一些容易出现的错误问题。

2.5泛型数组

　　使用泛型方法的时候，也可以传递或返回一个泛型数组。

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。

2.6泛型的嵌套设置

　　之前的全部泛型操作，都是直接通过实例化类完成的，当然，在设置的时候，也会看见嵌套的设置形式：也就是说，我在指定一个泛型的同时也会指定另一个泛型。

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，泛型语法上使用泛型标记的时候，需要先声明，同样可以指定其操作的上限和下限。