第二章--Java泛型 第三节--泛型类型限定

泛型类型限定（1）：

泛型：编写的代码可以被很多不同类型的对象所重用

特定场合下，需要对泛型的类型做一定的限制（要有某些特定方法，或者说它必须实现什么接口）

T... 表示一个不定项参数，其本质是一个T类型的数组

泛型类型限定（2）：泛型限定语法（对T的类型做一定的限制）

---- 比如<T extends Comparable> 约定T必须实现Comparable（是个接口，这里也用extends）的子类

---- 使用关键字extends固定，后面可以多个接口或类（最多只能一个），用单个 &  拼接，比如

      <T extends Comparable & Serializable>

---- extends限定可以有多个接口，但是只能有一个类，且类必须排在第一位

---- 逗号隔参数，如果泛型里面有多个泛型引入类型的话，用逗号隔离。比如

      <T extends File & Cloneable, U extends Serializable>

泛型继承原则（1）：泛型类之间的继承

---- Pair<S>和Pair<T>没有任何关系，无论S和T之间是什么关系

上述第二句话报错，说明Pair<Apple>和Pair<Fruit>没有关系，不论Apple类和Fruit类是什么关系

----泛型类可以扩展或实现其他的类，比如ArrayList<T>实现List<T>

List<Orange>  oranges  =  new  ArrayList<Orange> ();

说明：

（1）最上面的List本身是一个泛型类

（2）List<Fruit>是List里面指定类型为Fruit的泛型对象；同理List<Apple>是List里面指定类型为Apple的泛型对象

（3）List<Fruit>和List<Apple>没有任何关系；同理ArrayList<Fruit>和ArrayList<Apple>没有任何关系

（4）ArrayList<Fruit>是ArrayList里面指定类型为Fruit的泛型对象；同理ArrayList<Apple>是ArrayList里面指定类型为Apple的泛型对象

（5）有关系的是，ArrayList<Fruit>是List<Fruit>的子类

 

泛型通配符类型（1）：

为了弥补上面泛型类之间继承关系的不足。功能相对弱一些，比如List<Fruit>和List<Apple>没有任何关系，哪怕Apple类继承于Fruit类。那么，Java泛型，又推出了一个通配符的概念，那么可以使得泛型对象之间存在者继承关系

上限界定符，Pair< ? extends  S>

---- Pair能接收的参数类型，是S自身或子类

比如 Pair< ? extends Fruit> 代表 Pair<Fruit>, Pair<Apple>, Pair<Orange>等

这么理解：把 Pair< ? extends Fruit>  fruits看作Pair<Apple> fruits或者Pair<Fruit> fruits，那么子类可以转型为父类对象，所以可以执行Fruit  first  = fruits.getFirst();

泛型通配符类型（2）：

Pair< ? extends S>，Pair能接收的参数类型，是S类自身或者子类

---- 只能调用get方法，不能调用set方法，编译器只能保证出来的类型（肯定可以转型为S类的），但是不能保证放入的对象是什么类型。

（1）Pair< ? extends Fruit>代表Pair<Fruit>，Pair<Apple>，Pair<Orange>等

（2）？ extends Fruit getFirst();   // get拿出来的数据肯定可以转型为Fruit

（3）void setFirst( ? extends Fruit) // 放数据，不知道该放什么类型的数据进去，有可能这个变量，它原始的定义是Apple类型，你给它放入一个Orange类型的数据 

上面的第二句话中的fruits只能放入Apple类型的数据，因为原始的定义（第一句话）Pair<Apple> apples这里定义好了

泛型通配符类型（3）：

下限界定符，Pair< ? super  S>

---- Pair能接收的类型参数，是S类的自身或者超类（或者说父类）

比如 Pair< ? super Apple> 代表 Pair<Object>，Pair<Fruit>，Pair<Apple>等

规则就是一条：子类对象可以转为父类对象，但是父类对象不可以转为子类对象

泛型通配符类型（4）：

Pair< ? super S>，Pair能接收的类型参数，是S类本身或者超类（父类）

---- 只能调用set方法，不能调用get方法，因为编译器保证放入的是S类本身或者超类，但是不能保证出来的是什么具体类型

（1）Pair<? super Apple> 代表的是 Pair<Object>，Pair<Fruit>，Pair<Apple>等

（2）void setFirst(? super Apple)  // 只要放进来的是Apple或者Apple子类，我肯定可以做转型，因为？ super Apple代表Apple本身或者父类，所以放进来Apple或者Apple子类我就可以转型为父类

（3）？ super Apple getFirst()  // 因为？super Apple不确定什么类型，可能是Object，可能是Fruit，可能是Apple，没办法知道get出来的具体是哪一种类型

说明：上面第四句话，fruits.getFirst()出来的类型不知道是什么类型，可以是Object，可以是Fruit，可以是Apple

泛型通配符类型（5）：泛型PECS原则

PECS原则：Producer Extends，Consumer Super原则

---- 如果要从泛型类读取类型 T 的数据，并且不能写入，可以使用 ？ extends 通配符（上限通配符）。Producer Extends，泛型类是生产者，往外输出东西。即我们只是get数据，并没有做set操作

---- 如果要想泛型类写入类型 T 的数据，并且不需要读取，可以使用 ？ super 通配符（下限通配符）。Consumer Super，泛型类是消费者，往内增加东西

---- 如果既想写入又想读出，那就不用通配符，只需要用单独的 <T> 这个东西就可以

泛型通配符类型（6）：无限定类型的泛型

Pair<T>：原始类型（在运行的时候，这个T会固定为一种类型）

Pair<?>：无限定通配符，表示任意类型（在运行的时候，会表示任意类型），几乎不用，了解即可

    比如可以表示Pair<Object>，Pair<Apple>，Pair<Orange> 等

    ? getFirst()    //  不确定出来是什么类型，只能赋值给Object

    void setFirst()    //  无法放入任何对象，甚至是Object

 

总结：泛型类型限定

----  Pair<T> 和 Pair<S> 没有关系

----  Pair<T extends Comparable & Serializable> 限定 T 的类型

----  PRES原则：  Pair<? extends T>，只能get，不能set。即只生产，不消费

                             Pair<? super T>，只能set，不能get，即只消费，不生成