JAVA 泛型中的extends和super

1.List<? extend Fruit> list=new ArrayList<>(); 解释为：集合中元素是继承自Fruit，究竟是何种类型，编译器也无法判定。

如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)

2.List<? super Apple> list=new ArrayList<>();解释为:集合中的元素是Apple的父类，无法判定具体类型。

如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)

如果既要存又要取，那么就不要使用任何通配符。

3.<T extends Comparable<? super T>>和<T extends Comparable<T>>

example:

package genericity;

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

/**
 * TypeParameterTest
 * 对比<T extends Comparable<T>>和<T extends Comparable<? super T>>
 * Created by heqianqian on 2017/6/1.
 */
public class TypeParameterTest {

    public static <T extends Comparable<T>> void mySort1(List<T> list) {
        Collections.sort(list);
    }

    public static <T extends Comparable<? super T>> void mySort2(List<T> list) {
        Collections.sort(list);
    }

    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Animal(1));
        animals.add(new Dog(35));

        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog(100));
        dogs.add(new Dog(120));

        mySort1(animals);
        //mySort1(dogs);
    }
}

class Animal implements Comparable<Animal> {
    protected int age;

    public Animal(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Animal o) {
        return this.age - o.age;
    }
}

class Dog extends Animal {

    public Dog(int age) {
        super(age);
    }
}

其中mySort1(dogs) 会编译报错

Error:(33, 9) java: 无法将类 genericity.TypeParameterTest中的方法 mySort1应用到给定类型;
  需要: java.util.List<T>
  找到: java.util.List<genericity.Dog>
  原因: 推断类型不符合等式约束条件
    推断: genericity.Animal
    等式约束条件: genericity.Animal,genericity.Dog

<T extends Comparable<T>>类型 T 必须实现 Comparable 接口，并且这个接口的类型是 T。只有这样，T 的实例之间才能相互比较大小。例如，在实际调用时若使用的具体类是 Dog，那么 Dog 必须 implements Comparable<Dog>

<T extends Comparable<? super T>>类型 T 必须实现 Comparable 接口，并且这个接口的类型是 T 或 T 的任一父类。这样声明后，T 的实例之间，T 的实例和它的父类的实例之间，可以相互比较大小。例如，在实际调用时若使用的具体类是 Dog (假设 Dog 有一个父类 Animal），Dog 可以从 Animal 那里继承 Comparable<Animal> ，或者自己 implements Comparable<Dog> 。

---