「 Java 基础 - 泛型 」一文说清 Java 泛型中的通配符 T、E、K、V、N、？和 Object 的区别和含义

public interface Enumeration<E> {    /**     * Tests if this enumeration contains more elements.     *     * @return  <code>true</code> if and only if this enumeration object     *           contains at least one more element to provide;     *          <code>false</code> otherwise.     */    boolean hasMoreElements();
    /**     * Returns the next element of this enumeration if this enumeration     * object has at least one more element to provide.     *     * @return     the next element of this enumeration.     * @exception  NoSuchElementException  if no more elements exist.     */    E nextElement();}

private static <E> void printArray(E[] inputArray)

private static <E,T> void printArray(E[] inputArray, T data)

public class Demo<T> {    private T t;        public void setT(T t){        this.t = t;    }    public T getT(){        return t;    }}

public class Demo<T> {        public void show(T t){        System.out.println(t);    }}

public interface Demo<T> {    void show(T t);}

public class DemoImlp<T> implements Demo<T> {    @Override    public void show(T t){        System.out.println(t);    }}

public class Demo {    public static void main(String[] args) {        System.out.println(sum(10,20));        System.out.println(sum(10,20,30));        System.out.println(sum(10,20,30,40));        System.out.println(sum(10,20,30,40,50));        System.out.println(sum(10,20,30,40,50,60));        System.out.println(sum(10,20,30,40,50,60,70));
    }
    public static int sum(int... a){//a其实是一个数组，用来存储参数        int sum = 0;        for(int i:a){            sum += i;        }        return sum;    }}

public static int fun1(int... a,int b){//报错    ......}
public static int fun2(int b,int... a){//正常    ......}

List<Animal> animalsList

List<? extends Animal> animalsList

/* * 统计几条腿 */static int countLegs1 (List<? extends Animal > animals ) {    int retVal = 0;    for ( Animal animal : animals )    {        retVal += animal.countLegs1();    }    return retVal;}/* * 统计几条腿 */static int countLegs2 (List< Animal > animals ){    int retVal = 0;    for ( Animal animal : animals )    {        retVal += animal.countLegs2();    }    return retVal;}
public static void main(String[] args) {    List<Dog> dogs = new ArrayList<>();   // 不会报错    countLegs( dogs );  // 报错    countLegs1(dogs);}

private <K extends A, E extends B> E test(K arg1, E arg2){    E result = arg2;    arg2.compareTo(arg1);    //.....    return result;}

private <T> void test(List<? super T> a, List<T> b){    for (T t : b) {        a.add(t);    }}
public static void main(String[] args) {    List<Dog> dogs = new ArrayList<>();    List<Animal> animals = new ArrayList<>();    new Test3().test(animals,dogs);}
// Dog 是 Animal 的子类class Dog extends Animal {
}

// 通过 T 来 确保 泛型参数的一致性public <T extends Number> void test(List<T> dest, List<T> src)
//通配符是 不确定的，所以这个方法不能保证两个 List 具有相同的元素类型public void test(List<? extends Number> dest, List<? extends Number> src)

public static void main() {    Demo<String> demo = new Demo<>();    List<String> a = new ArrayList<>();    List<String> b = new ArrayList<>();    demo.test(a,b);}/** * 通过T来确保泛型参数的一致性 */public <T extends Numbers> void test(List<T> a,List<T> b) {    System.out.println(a);    System.out.println(b);}

Demo demo = new Demo<>();List<String> a = new ArrayList<>();List<Number> b = new ArrayList<>();demo.testNon(a,b);

public calss Demo implements DemoInterfaceA,DemoInterfaceB {    /**     * 使用“&”符号设定多重边界 (Multi Bounds)     */    public static<T extends DemoInterfaceA & DemoInterfaceB> void test(T t){            }}
/* * 接口A */interface DemoInterfaceA {}
/* * 接口B */interface DemoInterfaceB {}

T extends A

? extends A? super A

// 指定结合元素只能用 T 类型List<T>  list = new ArrayList<T>();// 集合元素可以是任意类型，这种没哟意义，一般方法中，只是为了说明用法List<?> list = new ArrayList<?>();

// 可以T t = operate();// 不可以？ car = operate();

Animal cat = new Cat();

Animal cat = new Cat();Cat anotherCat = (Cat) cat;

public static void main(String[] args) {    Object number1 = 1;    Integer number2 = (Integer) number1;    String s = (String) number1;//报错}

java.lang.Integer cannot be cast to java.lang.String

// 通过反射的方式生成  demoA // 对象，这里比较明显的是，我们需要使用强制类型转换DemoA demoA = (DemoA)Class.forName("com.xiaoliucoding.test.DemoA").newInstance();

public class Test3 {        public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException,InstantiationException {        return clazz.newInstance();    }        public static void main(String[] args) throws IllegalAccessException, InstantiationException {        A a = createInstance(A.class);        B b = createInstance(B.class);    } }
/* * A */class A {}
/* * B */class B {}

// 可以public Class<?> clazz;// 不可以，因为 T 需要指定类型public Class<T> clazzT;

public void pushAll(Iterable<E> source) {    for (E e : source) {        push(e);    }}

public static void main(String[] args) {    Stack<Number> statck = new Stack<>();    Iterable<Integer> integers = new ArrayList<>();    statck.pushAll(integers);// 报错}

public void pushAll(Iterable<? extends E> source) {    for (E e : source) {      push(e);    }}

public void popAll(Collection<E> destination) {    while (!isEmpty()) {        destination.add(pop());    }}

public static void main(String[] args) {    Stack<Number> statck = new Stack<>();    Collection<Object> objects = new ArrayList<>();    statck.popAll(objects);// 报错}

public void popAll(Collection<? super E> destination) {    while (!isEmpty()) {        destination.add(pop());    }}