通配符

class Info<T>{
    private T var ;        // 定义泛型变量
    public void setVar(T var){
        this.var = var ;
    }
    public T getVar(){
        return this.var ;
    }
    public String toString(){    // 直接打印
        return this.var.toString() ;
    }
};
public class Test{
    public static void main(String args[]){
        Info<String> i = new Info<String>() ;        // 使用String为泛型类型
        i.setVar("MLDN") ;                            // 设置内容
        fun(i) ;
    }
    public static void fun(Info<Object> temp){        // 接收Object泛型类型的Info对象
        System.out.println("内容：" + temp) ;
    }
};

编译错误：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The method fun(Info<Object>) in the type Test is not applicable for the arguments (Info<String>)

    at Test.main(Test.java:17)

　　泛型对象进行引用传递的时候，类型必须一致。如果现在非要传递，则可以将fun方法中Info参数的泛型取消掉。如下：

class Info<T>{
    private T var ;        // 定义泛型变量
    public void setVar(T var){
        this.var = var ;
    }
    public T getVar(){
        return this.var ;
    }
    public String toString(){    // 直接打印
        return this.var.toString() ;
    }
};
public class Test{
    public static void main(String args[]){
        Info<String> i = new Info<String>() ;        // 使用String为泛型类型
        i.setVar("MLDN") ;                            // 设置内容
        fun(i) ;
    }
    public static void fun(Info temp){        // 接收Object泛型类型的Info对象
        System.out.println("内容：" + temp) ;
    }
};

　　以上的确完成了改进的功能，但是，代码似乎有些不是很稳妥，毕竟已经指定过泛型了。

 

class Info<T>{
    private T var ;        // 定义泛型变量
    public void setVar(T var){
        this.var = var ;
    }
    public T getVar(){
        return this.var ;
    }
    public String toString(){    // 直接打印
        return this.var.toString() ;
    }
};
public class Test{
    public static void main(String args[]){
        Info<String> i = new Info<String>() ;        // 使用String为泛型类型
        i.setVar("MLDN") ;                            // 设置内容
        fun(i) ;
    }
    public static void fun(Info<?> temp){        // 可以接收任意的泛型对象
        System.out.println("内容：" + temp) ;
    }
};

结果输出：

内容：MLDN

　　如果使用了“?”，意味着可以接收任意的内容，但是此内容却无法直接使用<?>修饰的泛型对象进行修改。如下：

错误提示：

The method setVar(capture#1-of ?) in the type Info<capture#1-of ?> is not applicable for the arguments (String)

改正后：

 

使用<?>只能接受，不能修改：

 

定义类：[访问权限] 类名称<泛型标识 super 类> 对象名称

 

设置上限

class Info<T>{
    private T var ;        // 定义泛型变量
    public void setVar(T var){
        this.var = var ;
    }
    public T getVar(){
        return this.var ;
    }
    public String toString(){    // 直接打印
        return this.var.toString() ;
    }
};
public class GenericsDemo17{
    public static void main(String args[]){
        Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象
        Info<Float> i2 = new Info<Float>() ;            // 声明Float的泛型对象
        i1.setVar(30) ;                                    // 设置整数，自动装箱
        i2.setVar(30.1f) ;                                // 设置小数，自动装箱
        fun(i1) ;
        fun(i2) ;
    }
    public static void fun(Info<? extends Number> temp){    // 只能接收Number及其Number的子类
        System.out.print(temp + "、") ;
    }
};

如果把Info设置成String类型，则在编译的时候将出现错误：

又如：

 

设置下限

　　当使用的泛型只能在本类及其父类类型上应用的使用，就必须使用泛型的范围下限配置。

class Info<T>{
    private T var ;        // 定义泛型变量
    public void setVar(T var){
        this.var = var ;
    }
    public T getVar(){
        return this.var ;
    }
    public String toString(){    // 直接打印
        return this.var.toString() ;
    }
};
public class Test{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>() ;        // 声明String的泛型对象
        Info<Object> i2 = new Info<Object>() ;        // 声明Object的泛型对象
        i1.setVar("hello") ;
        i2.setVar(new Object()) ;
        fun(i1) ;
        fun(i2) ;
    }
    public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型
        System.out.print(temp + "、") ;
    }
};

运行结果：

如果现在使用了Integer作为泛型的类型，则不满足泛型的下限：

 

泛型与子类继承的限制

　　一个类的子类可以通过对象多态性，为其父类实例化，但是在泛型操作中，子类的泛型类型是无法使用父类的泛型类型接收的，比如：Info<String>不能使用Info<Object>接收