[关闭]
@lemonguge 2015-06-23T02:33:05.000000Z 字数 8165 阅读 354

泛型（二）

JAVA

边界

之前曾经简单的介绍过边界，只是大家没有发觉而已。边界使得你可以在用于泛型的类型参数上设置限制条件，尽管这使得你可以强制规定泛型可以应用的类型，但是其潜在的一个更重要的效果是你可以按照自己的边界类型来调用方法。

重用extends关键字

因为擦除移除了类型信息，所以，可以用无界泛型参数调用的方法只是那个可以用Object调用的方法。但是，如果能将这个参数限制为某个类型子集，那么你就可以调用这些类型子集来调用方法。

Java泛型重用了extends关键字来表示上界。

  1. interface Swim{
  2.     public abstract void swim(); // 游泳的功能
  3. }
  4. abstract class Animal{
  5.     public abstract void eat(); // 动物的吃方法
  6. }
  7. class Person implements Swim{
  8.     @Override
  9.     public void swim() {
  10.         System.out.println("Person swim.."); // 人可以游泳
  11.     }
  12. }
  13. abstract class Fish extends Animal implements Swim{
  14.     @Override
  15.     public void swim(){
  16.         System.out.println("Fish swim..");
  17.     }
  18. }
  19. class GoldenFish extends Fish{
  20.     @Override
  21.     public void eat() {
  22.         System.out.println("GoldenFish eat rice");
  23.     }
  24.     public void bubble() {
  25.         System.out.println("Oo."); // 金鱼吐泡泡
  26.     }
  27. }

上面这段代码描述了这么一些信息：人和鱼都有游泳的功能，金鱼可以吐泡泡，还有一个动物的继承体系（动物<--鱼<--金鱼）。

  1. // 无界泛型参数
  2. class HoldAny<T> {
  3.     T item;
  4.     HoldAny(T item) { this.item = item; }
  5. }
  6. // 上界是鱼，可以接受鱼和鱼的子类
  7. class HoldFish<T extends Fish> {
  8.     T item;
  9.     HoldFish(T item) { this.item = item; }
  10.     void feed(){ item.eat(); }
  11.     void show(){ item.swim(); }
  12. }
  13. // 可以接受实现游泳功能的类型
  14. class HoldSwim<T extends Swim> {
  15.     T item;
  16.     HoldSwim(T item) { this.item = item; }
  17.     void show() { item.swim(); }
  18. }
  19. // 可以继承一个类，实现多个接口，此时类必须放左边
  20. // ! class HoldSwimAnimal<T extends Swim & Animal> { }
  21. class HoldSwimAnimal<T extends Animal & Swim> { // 会游泳的动物
  22.     T item;
  23.     HoldSwimAnimal(T item) { this.item = item; }
  24.     void feed(){ item.eat(); }
  25.     void show() { item.swim(); }
  26. }
  27. public class ExtendsBound {
  28.     public static void main(String[] args) {
  29.         new HoldAny<Person>(new Person()); // OK
  30.         new HoldAny<Fish>(new GoldenFish()); // OK
  31.         // ! new HoldAny<Fish>(new Person());
  33.         // ! new HoldSwimAnimal<Person>(new Person());
  34.         new HoldAny<Fish>(new GoldenFish()); // OK
  36.         new HoldSwim<Swim>(new Person()).show();
  37.         new HoldSwim<Swim>(new GoldenFish()).show();
  39.         // ! new HoldFish<Person>(new Person()); // Bound mismatch
  40.         new HoldFish<Fish>(new GoldenFish()).show();
  41.         new HoldFish<Fish>(new GoldenFish()).feed();
  42.         new HoldFish<Fish>(new Fish(){
  43.             @Override
  44.             public void eat() {
  45.                 System.out.println("Fish eat..");
  46.             }
  47.         }).feed();
  48.     }
  49. } /* Output:
  50. Person swim..
  51. Fish swim..
  52. Fish swim..
  53. GoldenFish eat rice
  54. Fish eat..
  55. *///:~

通配符

通配符：在泛型参数表达式中的问号?。

  1. class Fruit {}
  2. class Apple extends Fruit {}
  3. class Jonathan extends Apple {}
  4. class Orange extends Fruit {}
  6. public class CovariantArrays {
  7.     public static void main(String[] args) {
  8.         Fruit[] fruit = new Apple[10];
  9.         fruit[0] = new Apple(); // OK
  10.         fruit[1] = new Jonathan(); // OK
  11.         // Runtime type is Apple[], not Fruit[] or Orange[]:
  12.         try {
  13.             // Compiler allows you to add Fruit:
  14.             fruit[0] = new Fruit(); // ArrayStoreException
  15.         } catch (Exception e) {
  16.             System.out.println(e);
  17.         }
  18.         try {
  19.             // Compiler allows you to add Oranges:
  20.             fruit[0] = new Orange(); // ArrayStoreException
  21.         } catch (Exception e) {
  22.             System.out.println(e);
  23.         }
  24.     }
  25. } /* Output:
  26. java.lang.ArrayStoreException: Fruit
  27. java.lang.ArrayStoreException: Orange
  28. *///:~

我们可以向导出类型的的数组赋予基类型的数组引用，但是存放元素时，只能存放导出类型或导出类型的子类。如果存放了基类型的元素，虽然在编译期，这是允许的。但是，运行时的数组机制知道它处理的实际类型，所以会抛出异常。

我们知道，泛型将错误检测从运行期移到编译期。我们使用泛型容器来代替数组，会发生什么呢？

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class NonCovariantGenerics {
  5.     // Compile Error: incompatible types:
  6.     // ! List<Fruit> flist = new ArrayList()<Apple>();
  7. } ///:~

根本就不能通过编译器的检查，直接报错了。其实很简单：假如这样做能通过编译，当我们给flist存放一个Fruit对象时，而在运行期，泛型的类型参数被擦除为Object，所以整个过程中不会产生任何异常，而这样的结果与我们所期望的不同，因为不可以往导出类型存放基类对象。假设不成立，即在编译期时，就不能通过检查。

希望大家明白，这根本就不是向上转型——Apple的List不是Fruit的List。当我们讨论容器的类型，而不是容器持有的类型，这和我们讨论数组的类型和数组元素的类型是一样的意思。正确的理解上面代码的说法是：“不能把一个涉及Apple的泛型赋给一个涉及Fruit的泛型”。

但是，有时你想要在两个类型之间建立某种关系的向上转型，这正是通配符所允许的：

  1. import java.util.*;
  3. public class GenericsAndCovariance {
  4.     public static void main(String[] args) {
  5.         // Wildcards allow covariance:
  6.         List<? extends Fruit> flist = new ArrayList<Apple>();
  7.         // Compile Error: can't add any type of object:
  8.         // flist.add(new Apple());
  9.         // flist.add(new Fruit());
  10.         // flist.add(new Object());
  11.         flist.add(null); // Legal but uninteresting
  12.         System.out.println(flist.size()); 
  13.         // We know that it returns at least Fruit:
  14.         Fruit f = flist.get(0);
  15.     }
  16. } /*
  17. 1
  18. *//:~

对于上面这段代码，发现了flist根本就无法接收任何类型的对象，只能存入null。其实这样是很合理的，由于泛型不能在运行期进行错误检测，只有在编译期保证代码的正确性。对于flist引用类型，你可以将它读作“具有任何从Fruit继承的类型的列表”。也就是说这个引用类型可以指向List<Fruit>、List<Apple>、List<Jonathan>、List<Orange>和List<任何Fruit的导出类>对象。当你想要调用其add(..)方法时，对于编译器来说，它并不知道flist引用指向哪一种，为了防止给导出类型存放基类对象的情况（当实际对象是List<Jonathan>，可你要存放了Apple对象），所以不允许向其中添加对象。一句话来讲：“子子孙孙无穷尽也。”

一旦执行这种类型的向上转型，你就将丢失掉向其中传递任何对象的能力，甚至是传递Object也不行。不过，当你调用一个返回Fruit的方法时，则是安全的，无论哪种对象都可以被安全的向上转型其基类类型。

  1. import java.util.*;
  3. public class GenericReading {
  4.     static <T> T readExact(List<T> list) {
  5.         return list.get(0);
  6.     }
  8.     static List<Apple> apples = Arrays.asList(new Apple());
  9.     static List<Fruit> fruit = Arrays.asList(new Fruit());
  11.     // A static method adapts to each call:
  12.     static void f1() {
  13.         Apple a = readExact(apples);
  14.         Fruit f = readExact(fruit);
  15.         f = readExact(apples);
  16.     }
  18.     // If, however, you have a class, then its type is
  19.     // established when the class is instantiated:
  20.     static class Reader<T> {
  21.         T readExact(List<T> list) {
  22.             return list.get(0);
  23.         }
  24.     }
  25.     static void f2() {
  26.         Reader<Fruit> fruitReader = new Reader<Fruit>();
  27.         Fruit f = fruitReader.readExact(fruit);
  28.         // Fruit a = fruitReader.readExact(apples); // Error:
  29.         // readExact(List<Fruit>) cannot be
  30.         // applied to (List<Apple>).
  31.     }
  33.     static class CovariantReader<T> {
  34.         T readCovariant(List<? extends T> list) {
  35.             return list.get(0);
  36.         }
  37.     }
  38.     static void f3() {
  39.         CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
  40.         Fruit f = fruitReader.readCovariant(fruit);
  41.         Fruit a = fruitReader.readCovariant(apples);
  42.     }
  44.     public static void main(String[] args) {
  45.         f1();
  46.         f2();
  47.         f3();
  48.     }
  49. } ///:~

无界通配符

无界通配符<?>看起来意味这“任何事物”，因此使用无界通配符好像等价于使用原生类型。

举个例子：关于List<?>和List之间的差异。List<?>看起来等价于List<Object>，而List实际上也是List<Object>。List实际上表示“持有任何Object类型的原生List”，而List<?>表示“具有某种特定类型 的非原生List，只是我们不知道那种类型是什么。”

无论何时，只要使用了原生类型，都会放弃编译期检查。

  1. class Cellphone { }
  3. public class Holder<T> {
  4.     private T a;
  5.     public Holder(T a) { this.a = a; }
  6.     public void set(T a) { this.a = a; }
  7.     public T get() { return a; }
  9.     // Raw argument:
  10.     static void rawArgs(Holder holder, Object arg) {
  11.         holder.set(arg); // Warning:
  12.         // The method set(Object) belongs to the raw type Holder
  13.         holder.set(new Cellphone()); // Same warning
  15.         // OK, but type information has been lost:
  16.         Object obj = holder.get();
  17.     }
  19.     // Similar to rawArgs(), but errors instead of warnings:
  20.     static void unboundedArg(Holder<?> holder, Object arg) {
  21.         // The method set(capture of ?) in the type Holder<capture of ?>
  22.         // is not applicable for the arguments (Object)
  23.         // ! holder.set(arg); // Error
  25.         // ! holder.set(new Cellphone()); // Same error
  27.         // OK, but type information has been lost:
  28.         Object obj = holder.get();
  29.     }
  30.     static <T> T exact(Holder<T> holder) {
  31.         T t = holder.get();
  32.         return t;
  33.     }
  34.     @SuppressWarnings({ "unused", "rawtypes" })
  35.     public static void main(String[] args) {
  36.         Holder raw = new Holder();
  37.         Holder<?> unbounded = new Holder<Long>();
  38.         Holder<Long> qualified = new Holder<Long>();
  40.         Object r1 = exact(raw); // Warnings:
  41.         Object r3 = exact(unbounded);
  42.         Long r2 = exact(qualified);
  43.     }
  44. } ///~

向接受“确切”泛型类型（没有通配符）的方法exact(..)传递一个原生引用Holder，就会得到一个警告，因为确切的参数期望得到在原生类型类型中并不存在的信息。如果传递了一个无界引用，就不会有任何可以确定返回类型的类型信息。

捕捉转换：向一个使用无界通配符<?>的方法传递原生类型，那么对编译器来说，可能会推断出实际的类型参数，是这个方法可以回转并调用另一种使用参数类型T的方法。

笔者认为，然而这并没什么用。

逆变

超类型通配符super：由某个特定类的任何基类来界定，表示下界，super只能与通配符?结合使用，即? super。

我们可以使用<? super MyClass>，甚至可以使用<? super T>，但是却不能声明<T super MyClass>，不能对泛型参数给出一个超类型边界！

  1. import java.util.*;
  3. public class SuperTypeWildcards {
  4.     static void writeTo(List<? super Apple> apples) {
  5.         apples.add(new Apple());
  6.         apples.add(new Jonathan());
  7.         // ! apples.add(new Fruit()); // Error
  8.     }
  9. }

对于编译器来讲，apples引用类型中的泛型类型参数为? super Apple，这就意味着apples引用可以指向List<Apple>、List<Fruit>，甚至是List<Object>对象。无论是指向了哪一种对象，这些容器对象都可以存储Apple类型和Apple类型的导出类型。由于List<Apple>不能存储Fruit类型对象，所以会报错。

无界通配符的五种存在形式

  1. <?>
  2. <? super MyClass>
  3. <? extends MyClass>
  4. <? super T>
  5. <? extends T>
  6. <T extends MyClass>

使用泛型时会出现的问题

1、任何基本类型都不能作为类型参数。
2、一个类不能实现同一个泛型接口的两种变体，由于擦除的原因，这两个变体会成为相同的接口。

  1. interface Payable<T> {}
  3. class Employee implements Payable<Employee> {}
  4. // ! class Hourly extends Employee implements Payable<Hourly> {} ///:~
  1. interface Payable<T> {}
  2. // 去掉泛型，可以通过编译
  3. class Employee implements Payable {}
  4. class Hourly extends Employee implements Payable {} ///:~

3、使用带有泛型类型参数的转型或instanceof不会有任何效果。
4、 由于擦除的原因，重载方法将产生相同的类型签名。

  1. public class UseList<W,T> {
  2.     void f1(List<T> v) {}
  3.     // ! void f1(List<W> v) {}
  4.     // 必须提供明显有区别的方法名
  5.     void f2(List<W> v) {}
  6. } ///:~

5、基类劫持了接口，原理是一个类不能实现同一个泛型接口的两种变体。

  1. class ComparablePet implements Comparable<ComparablePet> {
  2.     public int compareTo(ComparablePet arg) {
  3.         return 0;
  4.     }
  5. }
  7. // 报错：The interface Comparable cannot be implemented more than once with different arguments:
  8. // Comparable<ComparablePet> and Comparable<TomCat>
  9. // 基类ComparablePet劫持了Comparable接口，只能进行ComparablePet的比较，而不能进行TomCat的比较
  10. class TomCat extends ComparablePet implements Comparable<TomCat> {
  11.     // Error: Comparable cannot be inherited with
  12.     // different arguments: <Cat> and <Pet>
  13.     public int compareTo(TomCat arg) {
  14.         return 0;
  15.     }
  16. } // ERROR
  18. // 下面演示实现ComparablePet中的相同接口的可行性：这只是与覆盖基类中的方法相同
  19. class Hamster extends ComparablePet implements Comparable<ComparablePet> {
  20.     public int compareTo(ComparablePet arg) {
  21.         return 0;
  22.     }
  23. }
  25. // Or just:
  26. class Gecko extends ComparablePet {
  27.     public int compareTo(ComparablePet arg) {
  28.         return 0;
  29.     }
  30. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注