泛型注意:

任意泛型类型兼容所有原始类型，泛型类型型关系要一一对应。

• List<Object>接受List
• List<String>接受List
• List<Object>不接受List<String>
• List<Base>不接受List<Child>

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        //没有使用泛型的List
        List list = new ArrayList();
        list.add(new Object());
        list.add(new Main());
        list.add(1);
        list.add("1241");
        list.add(14);
        //使用了泛型的方法
        main.test(list);
         //使用了泛型的List
        List<String> stringList = new ArrayList<>();
        stringList.add("s");

        //泛型类型不一致报错
        main.test(stringList);

        //不报错
        main.test2(list);
        main.test2(stringList);
    }

    private void test(List<Object> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }
     private void test2(List list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }   
}

泛型作为参数:

虽然泛型类型不一样，但是重载依然报错。

private void test(List<Integer> list) {}
private void test(List<String> list){}

任意类型:?

• 使用<?>可接受任意类型，但是不能确定接受的类型
• 使用<? extends BaseClass>下界限制，?代表继承自BaseClass的任意子类和BaseClass自身
• 使用<? super SuperClass>上界限制，?代表SuperClass的任意父类和SuperClass自身

?通配符实现泛型动态:

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        List<Child1> child1s = new ArrayList<>();
        List<Child2> child2s = new ArrayList<>();
        List<Child3> child3s = new ArrayList<>();
        main.test(child1s);
        main.test(child2s);
        main.test(child3s);
    }

    private void test(List<? extends Base> list) {
        for(Base b:list){
            b.doSome();
        }
    }
}

abstract class Base {
    public abstract void doSome();
}

class Child1 extends Base {
    @Override
    public void doSome() {}
}


class Child2 extends Base {
    @Override
    public void doSome() {}
}

class Child3 extends Base {
    @Override
    public void doSome() {}
}

---