Java泛型

参考：Java知识点总结（Java泛型）

---

自定义泛型类

public class Sad<T> {
    T type;

    public T getType() {
        return type;
    }
    public void setType(T type) {
        this.type = type;
    }
}

自定义泛型接口

public interface Comparator<T1, T2> {
    void compare1(T1 t1, T2 t2);

    T2 compare2(T1 t1, T2 t2);

    abstract T1 comapare3(T2 t2);
}

非泛型类中定义泛型方法

public class Method {
    //注意此处void前面有<T> 泛型类没有
    public <T> void printT(T t) { 
        System.out.println(t);
    }

    public <T extends List> T yourList(T t) {
        t.add("A");
        return t;
    }
}

继承泛型类

public abstract class Father<T1, T2> {
    T1 t1;
    abstract void print(T2 t2);
}

// 部分保留
public class ExtendsClass<T2> extends Father<Integer, T2> {
    @Override
    void print(T2 t2) {}

    //注意此处的T2不是泛型类上的T2，特意写成一样的名字，但两者不相同，此处T2是在void前面<T2>所定义的
    //所以方法里的参数类型T2也是void前面定义的T2而不是类上定义的T2。
    <T2> void print2(T2 t2) {}
}

// 部分保留
class ExtendsClass2<T1> extends Father<T1, String> {
    @Override
    void print(String s) {
    }
}

---

通配符

• T、K、V、E 等泛型字母为有类型，类型参数赋予具体的值
• ？未知类型 类型参数赋予不确定值，任意类型。只能用在声明类型、方法参数上，不能用在定义泛型类上

extends/super

• 上限（extends）：? extends List 指定的类必须是继承某个类，或者实现了某个接口（不是implements）
• 下限（super）： ? super List 即父类或本身

public class Demo03 {
    public static void main(String[] args) {
        List<?> list = null;
        test(list);

        List<Fruit> list0 = null;
        List<Banana> list1 = null;
        List<Apple> list2 = null;

        test2(list0);
        test2(list1);
        test2(list2);

        test3(list0);
//        test3(list1); //error
        test3(list2);

        //test4和test1-3完全不是一个概念。test4是List的子类，而test1-3是List泛型中的子/父类
        test4(list1);
    }

    //此处的extend和test1-3的extend不知道是不是一样，但至少可以确认T类型通配符用不了super关键字
    private static <T extends List>void test4(T t1) {}

    private static void test3(List<? super Apple> List) {}

    private static void test2(List<? extends Fruit> list) {}

    private static void test(List<?> list) {
        list = new ArrayList<String>();
        list = new ArrayList<Integer>();
    }
}

public class Fruit {
}

public class Apple extends Fruit {
}

public class Banana extends Fruit {
}

---

其他一些小知识

public class Demo04 {
    public static void main(String[] args) {
        Fruit fruit = new Apple();

        //泛型没有多态
//        List<Fruit> list = new ArrayList<Apple>(); //error
        List<? extends Fruit> list = new ArrayList<Apple>();
    }
}

通配符T、K、V、E 等与?的区别：

• 首先?只能用在声明类型、方法参数上，T、K、V、E无法使用super关键字。
• 其次，两者作用范围不是完全一样的，?是限定泛型的范围。如果要实现向下继承
  T、K、V、E方法一是在class头上注明，方法二是在方法上注明。而?实在参数中注明

public class Test<T extends Fruit> { //T、K、V、E方法1
    //T、K、V、E方法2
    <T1 extends Fruit> void test(T1 t) {}
    //?方法
    void test2(List<? extends Fruit> list) {}
}

从上面可以看出T、K、V、E方法一和?方法限定范围不一样，而T、K、V、E方法二和?方法限定范围一样。也就是两者作用有部分重叠，但也都有各自的无法取代的功能。？的独特点在于只有它可以使用super关键字，向上过滤