java中的泛型【T】与通配符【?】概念入门

使用泛型的目的是利用Java编译机制，在编译过程中帮我们检测代码中不规范的有可能导致程序错误的代码。例如，我们都知道List容器可以持有任何类型的数据，所以我们可以把String和Integer等类型同时放入同一个List容器中，但是这种做法是极其危险的。在泛型机制中，这种操作就会导致编译不通过，会强制要求你将List容器中的数据类型修改为统一类型。这种机制可以帮助我们减少程序运行中隐藏的Bug。

泛型【T】

泛型在代码中使用广泛。

泛型的用法

根据泛型使用的位置，即使用在类（Class），属性（Field）和方法（Method）的不同位置，可以将泛型的用法总结为以下几种：

1.泛型类。在类名后添加泛型标识（<T...>），用于表示该类持有的一种类型。

2.泛型属性。泛型属性必须结合泛型类使用，用于接收泛型类持有的类型T。

3.泛型方法。在方法的返回值前声明泛型（<T extends 父类名>），该泛型是对该方法的参数T的一种限定。

泛型用法的补充

1.如果泛型T没有被extends修饰（包括类和方法），我们称之为无界泛型；如果被extend修饰，我们就称之为有界泛型。

2.如果方法参数中有泛型T，而方法的返回类型前没有泛型T，该类型就不是泛型方法，而是泛型类。

3.泛型方法常用在工具类中（即该方法只是一种工具），与类的实例对象无关。

4.当泛型方法中的泛型T与类中的泛型T同名时会产生警报，因为编译器不确定你要使用哪个持有对象。

有界泛型

相较于无界泛型（没有限定类型）的用法，我们可以使用有界泛型（<T extends 父类名>）来限定持有对象的范围，或泛型方法传入该方法参数的范围，以此保证业务逻辑的正确执行。

有界泛型只有上界（extends），而没有下界的用法（相对于通配符【？】）。

泛型中的继承

用一段代码说明泛型中继承的使用。

ArrayList<String> arrayList = new ArrayList<>();
Object object = new Object();
arrayList.add(object); // 编译器报错

因为 ArrayList<String>不是 ArrayList<Object>的子类 ，因此编译器会报错，错误信息为The method add(String) in the type ArrayList<String> is not applicable for the arguments (Object)。

通配符【?】

通配符代表的是一种未知的类型，常用在方法上（注意与泛型方法的区别，其不需要在方法的返回类型前声明。

上界通配

上界通配即定义通配符的上界，用关键字extends声明。

public static void process（List<? extends Foo> list）{}

无界通配

无界通配即不限制通配符的界限，不需要任何关键字去修饰【?】。

public static void printList（List<?> list）{}

通配符的功能形式和声明类型为Object是有区别的。

public static void printList（List<Object> list）{}

List<Object>和List<?>是不一样的，前者可以插入Object或任何Object对象的子类，但是后者在类型不匹配的情况下只能够插入null。

public class TestWildCard {
    public void printList(List<String> list) {
        for (Object elem : list)
            System.out.print(elem + " ");
        System.out.println();
    }

    public void printList2(List<?> list) {
        for (Object elem : list)
            System.out.print(elem + " ");
        System.out.println();
    }

    public static void main(String[] args) {
        TestWildCard testWildcard = new TestWildCard();

        ArrayList<? extends Object> arrayList = new ArrayList<>();
        arrayList.add(null);
        // arrayList.add(testWildcard); // 报错

        ArrayList<Object> arrayList2 = new ArrayList<>();
        arrayList2.add(null);
        arrayList2.add("2");

        List<Integer> li = Arrays.asList(1, 2, 3);
        testWildcard.printList2(li);
        // testWildcard.printList(li); // 报错

        List<String> ls = Arrays.asList("one", "two", "three");
        testWildcard.printList2(ls);
        testWildcard.printList(ls);
    }
}

下界通配

下界通配即定义通配符的下界，用关键字super声明。

public static void addNumbers（List<? super Integer> list）{}

泛型【T】与通配符【?】的区别

泛型和通配符最根本的区别就是Java编译器会把泛型【T】推断成具体类型，而把通配符【?】推断成未知类型。Java编辑器只能操作具体类型，不能操作未知类型，如果有对参数做修改的操作就必须要使用泛型，如果仅仅是查看就可以使用通配符。

这样，我们可以利用通配符特性设计出安全的接口。比如在一个接口的方法中定义了通配符参数，则继承该接口的所有方法都不能修改该方法传递过来的参数。

interface GInterface {
    <T> void foo(List<? extends T> list);
}

public class GInterfaceImpl implements GInterface{
    @Override
    public <T> void foo(List<? extends T> list) {
        // 只能遍历list，不能修改list
        for (T t : list) {
            System.out.println(t);
        }

        // list.add(new Object()); // 编译器报错
    }

    public static void main(String[] args) {
        GInterfaceImpl gIterfaceImpl = new GInterfaceImpl();
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("8");
        gIterfaceImpl.foo(list);
    }
}

"你弱的时候，坏人最多，这个世界的温柔，都来自与你的强大。"