？ extends T和? super T到底什么区别，感觉不太好理解，明白的请举例说明一下，谢谢

泛型限定
例：Student extends Person
ArrayList<Person> al =new ArrayList<Student>(); //错误，左右两边必须一致。左右两边不一致时易出安全问题。这时可以使用泛型限定
ArrayList<？extends Person> //只允许Person和它的子类，上限。如Collection类addAll(Collection<? extends E> c)
ArrayList<？super Student > //只允许Student和它的父类，下限。如TreeSet类TreeSet(Comparator<? super E> comparator)

1. package hcy.test.main;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. class Person{
   
6. 
   
7. }
   
8. 
   
9. class Student extends Person{
   
10. 
    
11. }
    
12. 
    
13. class Worker extends Person{
    
14. 
    
15. }
    
16. 
    
17. class Test
    
18. {
    
19. public static void main(String[] args)
    
20. {
    
21. Test t=new Test();
    
22. ArrayList<Person> al1=new ArrayList<Person>();
    
23. al1.add(new Person());
    
24. al1.add(new Person());
    
25. 
    
26. ArrayList<Student> al2=new ArrayList<Student>();
    
27. al2.add(new Student());
    
28. al2.add(new Student());
    
29. 
    
30. ArrayList<Worker> al3=new ArrayList<Worker>();
    
31. al3.add(new Worker());
    
32. al3.add(new Worker());
    
33. 
    
34. t.printFather(al1);
    
35. t.printFather(al2);
    
36. t.printFather(al3);//编译通不过，只允许Student和它的父类
    
37. 
    
38. t.printSon(al1);
    
39. t.printSon(al2);
    
40. t.printSon(al3);
    
41. 
    
42. }
    
43. 
    
44. public void printSon(ArrayList<? extends Person> al){
    
45. System.out.println("right!");
    
46. }
    
47. 
    
48. public void printFather(ArrayList<? super Student> al){
    
49. System.out.println("right!");
    
50. }
    
51. }

复制代码

关于？ extends T和? super T到底什么区别，你对比一下自然就清楚了，？代表你要填进去的内容：
？ extends T：代表的即是继承于T的那个类，因而表示的是里面可以放T和T的子类；
？ super T:代表的是T的超类，因而表示里面可以放T和T的父类！

举一个家族成员例子吧

？extends T :

T代表这个家族的始祖，那么?extends T就是说？只要是T的后代就行，即T的子子孙孙了，它是有上限的

?super T：
T代表这个家族的最小一代，那么？super T就是说？只要是T的前辈就行，即T的爷爷爸爸等，它是有下限的

建议你把Java中的继承梳理清除，这些概念是很容易理解的
？ extends T指的是可以支持T和T的子类；
？ super T值得是可以支持T和T的父类

1. <? super T>  表示以T类型为下限的某种类
实例化的时候对象的泛型一定要大于等于T类型(也就是T的父类或自己)
使用的时候类型一定要小雨等于T类型(也就是T的子类或自己)

2. <? extends T> 表示以T类型为上线的某种类
实例化的时候对象的泛型一定要小于等于T类型(也就是T的子类或自己)



import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Searching {
    public static void main(String[] args) {
        String[] strings = { "0", "1", "2", "3", "4", "5"};

        List<Integer> integers = new ArrayList<Integer>();
        for(String s : strings){
            integers.add(Integer.valueOf(s));
        }
        if(integers.get(1)>new Integer(1)){System.out.println("<1>");}
        if(integers.get(1)<new Integer(1)){System.out.println("<2>");}
        if(integers.get(1)==new Integer(1)){System.out.println("<3>");}
        System.out.println(Collections.binarySearch(integers, 1,cmp));
    }

    static Comparator<Integer> cmp = new Comparator<Integer>(){
        public int compare(Integer i,Integer j){
            return i<j?-1:(i==j?0:1);
        }
    };
}
此程序输出：-2

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Searching {
    public static void main(String[] args) {
        String[] strings = { "0", "1", "2", "3", "4", "5"};

        List<Integer> integers = new ArrayList<Integer>();
        for(String s : strings){
            integers.add(Integer.valueOf(s));
        }
        if(integers.get(1)>new Integer(1)){System.out.println("<1>");}
        if(integers.get(1)<new Integer(1)){System.out.println("<2>");}
        if(integers.get(1)==new Integer(1)){System.out.println("<3>");}
        System.out.println(Collections.binarySearch(integers, 1,cmp));
    }

    static Comparator<Integer> cmp = new Comparator<Integer>(){
        public int compare(Integer i,Integer j){
            return i<j?-1:(i>j?1:0);
        }
    };
}
此程序输出：1

泛型的限定我是这样理解的；
? extends T: 可以接收T类型或者T的子类型。限定上限。即T和T的后代都可以接收，其他不行
? super T: 可以接收T类型或者T的父类型。限定下限。即T和T的祖祖辈辈都可以接收，其他不行

? extends T:    ？<T
? super T:        ?>T