了解通配符

通配符的概念

问题

package com.CoderLB;

public class Person<A> {
    private A age;

    public A getAge() {
        return age;
    }

    public void setAge(A age) {
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Person<String> per = new Person<String>();
        per.setAge("二十岁");
        fun(per);
    }
    public static void fun(Person<String> per){
        System.out.println(per.getAge());
    }
}
//输出：二十岁

上述中，如果泛型类中的类型改变之后发现方法中的参数的泛型也需要改变，这就说明了fun方法依赖Person的泛型，这也是耦合度较高的一种体现。可以在方法的参数中使用通配符代替具体的泛型。通配符使用"?"即可

通配符解决问题

package com.CoderLB;


import com.baidu.vo.Dept;
import com.baidu.vo.Emp;
import com.baidu.vo.EmpDAOImpl;

public class Test {
    public static void main(String[] args) {
        Person<String> per1 = new Person<String>();
        per1.setAge("二十岁");
        fun(per1);
        Person<Integer> per2 = new Person<Integer>();
        per2.setAge(20);
        fun(per2);
    }
    public static void fun(Person<?> per){
        System.out.println(per.getAge());
    }
}
//输出：
二十岁
20

使用“?”，在方法中替代具体的泛型类型，之后不管Person类中的泛型如何改变，fun方法都不需要改变。通配符还有两个子通配符。一个通配符上限，一个是通配符下限。

方法通配符上限

定义方式：？ extends 上限类型

package com.CoderLB;


import com.baidu.vo.Dept;
import com.baidu.vo.Emp;
import com.baidu.vo.EmpDAOImpl;

public class Test {
    public static void main(String[] args) {
        Person<Short> per1 = new Person<Short>();
        per1.setAge((short)20);
        fun(per1);
        Person<Double> per2 = new Person<Double>();
        per2.setAge(20.0);
        fun(per2);
    }
    public static void fun(Person<? extends Number> per){
        System.out.println(per.getAge());
    }
}
//输出：
20
20.0

类的泛型上限

类名<占位符 extends 上限>

package com.CoderLB;

public class Person<A extends Number> {
    private A age;

    public A getAge() {
        return age;
    }

    public void setAge(A age) {
        this.age = age;
    }
}

package com.CoderLB;

public class Person<A> {
    private A age;

    public A getAge() {
        return age;
    }

    public void setAge(A age) {
        this.age = age;
    }
}


public class Test {
    public static void main(String[] args) {
        Person<Object> per = new Person<Object>();
        per.setAge(18);
        fun(per);

    }
    public static void fun(Person<? super Number > per){
        System.out.println(per.getAge());
    }

}

类使用了泛型上限之后实例化对象的时候指定的泛型的具体类型只能是泛型上限类类型以及上限类型的子类类型。

方法通配符的下限

定义方式：？ super 下限类型

package com.CoderLB;


import com.baidu.vo.Dept;
import com.baidu.vo.Emp;
import com.baidu.vo.EmpDAOImpl;

public class Test {
    public static void main(String[] args) {
        Person<Number> per = new Person<Number>();
        per.setAge(18);
        fun(per);

    }
    public static void fun(Person<? super Byte > per){
        System.out.println(per.getAge());
    }

}
//输出：18

使用通配符的下限制之后：方法只能接受下限类型以及下限类型的父类类型作为泛型具体类型。
类的泛型是没有下限的。

小结

1. 使用通配符“?”解决了方法对泛型的依赖
2. 通配符的上限“? extends 上限类型”，方法只能接受上限类型的子类类型，泛型类也可以设置上限。
3. 通配符下限“? super 下限类型”，方法只能接受下限本类类型以及下限的父类类型，泛型类不可以设置下限

[抽象类Number是表示数字值可转换为基本数据类型平台类的超类byte ， double ， float ， int ， long和short 。 从一个特定的数字值转换的特定语义Number实现给定的原语类型由定义Number所讨论的实现。 对于平台类，转换往往是类似于一个基本收缩转换或加宽原语转换为The Java™ Language Specification限定用于原始类型之间的转换。 因此，转换可能会丢失有关数值的总体大小的信息，可能会失去精度，甚至可能会返回与输入不同的符号结果。]