Java编程思想——第十五章：泛型

泛型实现了 参数化类型 的概念，使代码可以应用多种类型。

多态算是一种泛化机制。将方法的参数类型设为基类，那么该方法就可以接受从这个基类中导出的任何类作为参数。使用基类能够具备更好的灵活性。但是，考虑到除了 final类 不能拓展，其他任何类都可以被拓展，所以这种灵活性大多数时候也会有一些性能损耗。

方法参数是一个接口也会放松限制。可是有时候，即便使用了接口，对程序的约束还是太强了。因为一旦指明接口，它就要求你的代码必须使用特定的接口。而我们希望达到的目的是编写更通用的代码，要使代码能够应用于某种不具体的类型，而不是一个具体的接口或类。

1.与c++的比较

2.简单泛型

创造容器类 是促成泛型出现的一个重要原因。泛型的主要目的之一就是用来指定容器要持有什么类型的对象，而且有编译器来保证类型的正确性。

与其使用Object我们更喜欢暂时不指定类型，而是稍后再决定具体使用什么类型。要达到这个目的，要使用类型参数

public class Holder<T> {
    private T a;
    public Holder(T a) {this.a = a;}
    public void set(T a) {this.a = a;}
    public T get() {return a;}
}

2.1 一个元祖类库

• 元祖 ：它是将一组对象直接打包存储于其中的一个单一对象。这个容器对象允许读取其中元素，但是不允许向其中存放新的对象。元祖也被称为数据传送对象或信使。元祖可以具有任意长度，其中的元素可以是任意不同的类型。还可以利用继承机制实现长度更长的元祖。
• 为了使用元祖，你只需定义一个长度适合的元祖，将其作为方法的返回值，然后在return语句中创建该元祖，并返回即可。

2.2 一个堆栈类

3.泛型接口

• 泛型也可以应用于接口。例如 生成器（generator），这是一种专门负责创建对象的类。实际上，这是 工厂方法设计模式 的一种应用。不过，当使用生成器创建新的对象时，它不需要任何参数，而工厂方法一般需要参数。

• 一般而言，一个生成器只定义一个方法，该方法用以产生新的对象。

  public interface Generator<T> {
      T next();
  }
  

4.泛型方法

泛型方法使得该方法能够独立于类而产生变化。如果使用泛型方法可以取代整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。

4.1 杠杆利用类型参数推断

4.2 可变参数与泛型方法

• 泛型方法与可变参数列表能够很好地共存

4.3 用于Generator的泛型方法

public class Generators {
    public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen, int n) {
        for(int i = 0; i < n; i ++)
            coll.add(gen.next());
        return coll;
    }
}

4.4 一个通用的Generator

public class BasicGenerator<T> implements Generator<T> {
    private Class<T> type;
    public BasicGenerator(Class<T> type) {
        this.type = type;
    }
    public T next() {
        try {
            return type.newInstance();
        } catch(Exception e) {
            throw new RuntimeException(e);
        }
    }
    public static <T> Generator<T> create(Class<T> type) {
        return new BasicGenerator<T>(type);
    }
}

5.匿名内部类

• 泛型还可以应用于内部类以及匿名内部类。

6.构建复杂模型

• 泛型的一个重要好处是能够简单而安全地创建复杂的模型。

7.擦除的神秘之处

• 根据JDK文档的描述，Class.getTypeParameters() 将返回一个 TypeVarible 对象数组，表示有泛型声明的类型参数...这只是表示用作参数占位符的标识符，这并非有用的信息。所以

  在泛型代码内部所声明的类型参数，无法获得任何有关泛型参数类型的信息

  因此，你可以知道诸如类型参数标识符和泛型类型边界这类的信息——你却无法知道用来创建某个特定实例的实际的类型参数。

  Java泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此，List<String> 和 List<Integer> 在运行时实际上是相同的类型。这两种类型都被擦除成它们的原生类型，即 List。

• 泛型类型只有在静态类型检查期间才出现。在此之后，程序中的所有泛型类型都被擦除，替换为他们的非泛型上界。普通类型被擦除成 Object。

  擦除的核心动机是它使得泛化的客户端可以用非泛化的类库来使用，反之亦然，这经常被称为 迁移兼容性。

• 擦除的代价是显著的。翻寻个不能用于显式地引用运行时类型的操作之中，例如转型、instanceof操作和 new表达式。因为所有关于参数的类型信息都丢失了。

8.擦除的补偿

• 擦除丢失了在泛型代码中执行某些操作的能力。任何在运行需要周到确切类型信息的操作都将无法工作。

  public class Erased<T> {
      private final int SIZE = 100;
      public static void f(Object arg) {
          if(arg instanceof T) {              //ERROR
              T var = new T();                //ERROR
              T[] array = new T[SIZE];        //ERROR
              T[] array = (T)new Object[SIZE]; //unchecked warning
          }
      }
  }
  

  使用 instanceof 的尝试是失败的，因为其类型信息已经被擦除了。如果引入类型标签，就可以转用动态的 isInstance() 。

07/06/2019 :created,just half.