掌握通配符“？”的使用。

掌握受限泛型的设置。

掌握泛型与子类继承的限制。

具体内容

1.1匹配任意类型的通配符

　　在开发中对象的引用传递（向上向下传递）是最常见的，但是，在泛型的操作中，在进行引用传递的时候泛型类型必须匹配才可以传递，否则不能传递。

　　例如，如下没有进行泛型类型匹配，一个是String,一个是Object类型。

package Thread1;
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 demo1{
    public static void main(String args[]){
        Info<String> i = new Info<String>() ;        // 使用String为泛型类型
        i.setVar("MLDN") ;                            // 设置内容
        fun(i) ;　　　　　　　　　　　　　　　　　　　　//把String泛型类型的i对象传递给Object泛型类型的temp。
    }
    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 demo1 is not applicable for the arguments (Info<String>)

    at Thread1.demo1.main(demo1.java:18)

　　泛型对象进行引用传递的时候，类型必须一致，如果非要传递，则可以将fun方法中Info参数的泛型取消掉（变成 void fun(Info temp)）。、

　　以上确实改进了功能，但是似乎不是很妥当，毕竟之前指定过泛型。

　　以上程序在fun()方法中使用"Info<?>"的代码形式，表示可以使用任意的泛型类型对象，这样的话fun()方法定义就合理了，但是使用以上方法也有需要注意的地方，

即：如果使用“？“接收泛型对象的时候，则不能设置被泛型指定的内容。

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 GenericsDemo14{
    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) ;
    }
};

　　如果使用”？“意味着可以接收任意的内容，但是此内容无法直接使得用”？“修饰的泛型的对象进行修改。如下就会出问题：

package Thread1;
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 demo1{
    public static void main(String args[]){
        Info<?> i = new Info<String>() ;        // 使用String为泛型类型
        i.setVar("MLDN") ;                            // 设置内容，这里会出错，因为”？“通配符修饰的对象只能接收，不能修改，也就是不能设置。
    }
};

　　运行结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
    The method setVar(capture#1-of ?) in the type Info<capture#1-of ?> is not applicable for the arguments (String)

    at Thread1.demo1.main(demo1.java:17)

　　在使用”？“只能接收，不能修改。

1.2受限泛型

　　之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

设置上限

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 + "、") ;
    }
};

　　运行成功。但是，如果传人的泛型类型为String的话就不行，因为String不是Number子类。

　　在类中使用泛型上限。

package Thread1;
class Info<T extends Number>{    // 此处泛型只能是数字类型
    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 demo1{
    public static void main(String args[]){
        Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象
    }
};

　　如果在使用Info的时候设置成String类型，则编译的时候将会出现错误（String不是Number子类）：

设置下限

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 GenericsDemo21{
    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类型的泛型，String类的父类只有Object类
        System.out.print(temp + "、") ;
    }
};

　　Object类和String类都是String的父类，所有运行成功，但是如果此时用Integer则会出错，因为integer并不是String父类。

1.3解释：泛型与子类继承的限制。

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

接收。

　　例如，以下肯定出错。

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 GenericsDemo23{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>() ;        // 泛型类型为String
        Info<Object> i2 = null ;
        i2 = i1 ;　　　　　　　　　　　　　　　　　　//这里因为对象泛型类型不同，而出错。
    }
};

　　Object肯定比String大。

总结

　　1）使用？可以接收任意泛型对象。

　　2）泛型的上限：？extends 类型。

　　3）泛型的下限：？super 类型。相对了解一些就可。

　　4）了解为什么泛型子类之间的继承无法直接转换的原因。