12月7号(第34天的学习泛型)

Java泛型最简单的方法是把它看成一种便捷语法，能节省对Java类型转换(casting)上的操作：

List<Apple> box = new List<Apple>();
Apple apple = box.get(0);

代码box是一个装有Apple对象的List。get方法返回一个Apple对象实例这个过程不需要进行类型转换。

这个是没有泛型的

List box = new List();
Apple apple = (Apple) box.get(0);

泛型好处就是让编译器保留参数的类型信息，执行类型检查，执行类型转换操作：编译器保证了这些类型转换的绝对无误。

泛型的构成

泛型的构成就有了一个类型变量的概念。Java类型变量是一种没有限制的标志符，产生于下面几种：

泛型类声明
泛型接口声明
泛型方法声明
泛型构造器(constructor)声明

泛型类和接口

一个类或接口上有一个或多个类型变量，那它就是泛型。类型变量由尖括号界定，放在类或接口名的后面：

public interface List<T> extends Collection<T> {

}
类型变量就一个参数，它提供给编译器用来类型检查的信息。

Java类库里的很多类这新出现的泛型标记，或者说这个List接口里的get方法是这样的：

T get(int index);
get方法实际返回的是一个类型为T的对象，T是在List<T>声明中的类型变量。

泛型方法和构造器(Constructor构造器)

方法和构造器上声明了一个或多个类型变量，它们也可以泛型化。

public static <t> T getFirst(List<T> list)
这个方法将会接受一个List<T>类型的参数，返回一个T类型的对象。

可以使用Java类库里提供的泛型类，也可以使用自己的泛型类。

类型安全的写入数据

创建了一个List<String>实例，然后装入一些数据：

List<String> str = new ArrayList<String>();
str.add("Hello ");
str.add("World.");
List<String>装入另外一种对象，编译器就会提示错误：

str.add(1); // 不能编译

类型安全的读取数据…

当我们在使用List<String>对象时，它总能保证我们得到的是一个String对象：

String myString = str.get(0);

遍历

类库中的很多类，Iterator<T>，功能都有所增强，被泛型化。List<T>接口里的iterator()方法现在返回的是Iterator<T>，由T next()方法返回的对象不需要再进行类型转换，直接得到正确的类型。

for (Iterator<String> iter = str.iterator(); iter.hasNext();) {
String s = iter.next();
System.out.print(s);
}
使用foreach

“for each”语法同样受益于泛型。前面的代码可以写出这样：

for (String s: str) {
System.out.print(s);
}
这样既容易阅读也容易维护。

自动封装(Autoboxing)和自动拆封(Autounboxing)

在使用Java泛型时，autoboxing(自动安装)/autounboxing(自动拆装)这两个特征会被自动的用到

List<Integer> ints = new ArrayList<Integer>();
ints.add(0);
ints.add(1);

int sum = 0;
for (int i : ints) {
sum += i;
}
要明白的一点是，封装和解封会带来性能上的损失，所有，通用要谨慎的使用。

子类型

在Java中，跟其它具有面向对象类型的语言一样，类型的层级可以被设计成这样：

Java中，类型T的子类型既可以是类型T的一个扩展，也可以是类型T的一个直接或非直接实现(如果T是一个接口的话)。因为成为某类型的子类型是一个具有传递性质的关系，如果类型A是B的一个子类型，B是C的子类型，那么A也是C的子类型。

FujiApple(富士苹果)是Apple的子类型
Apple是Fruit(水果)的子类型
FujiApple(富士苹果)是Fruit(水果)的子类型
所有Java类型都是Object类型的子类型。

B类型的任何一个子类型A都可以被赋给一个类型B的声明：

Apple a = new Apple();
Fruit f = a;
泛型类型的子类型

一个Apple对象的实例可以被赋给一个Fruit对象的声明，就像上面看到的，那么，List<Apple> 和 a List<Fruit>之间又是个什么关系？更通用些，如果类型A是类型B的子类型，那C<A> 和 C<B>之间是什么关系？

没有任何关系。泛型类型跟其是否子类型没有任何关系。

这段代码是无效的：

List<Apple> apples = new List<Apple>();
List<Fruit> fruits = apples;
下面的同样也不允许：

List<Apple> apples;
List<Fruit> fruits = new List<Fruit>();
apples = fruits;
为什么？一个苹果是一个水果，为什么一箱苹果不能是一箱水果？

在某些事情上，这种说法可以成立，但在类型(类)封装的状态和操作上不成立。如果把一箱苹果当成一箱水果会发生什么情况？

List<Apple> apples = new List<Apple>();
List<Fruit> fruits = apples;
fruits.add(new Strawberry());
可以这样的话，就可以在list里装入各种不同的水果子类型，这是绝对不允许的。

另外一种方式会更直观的理解：一箱水果不是一箱苹果，因为它有可能是一箱另外一种水果，比如草莓(子类型)。

这是一个需要注意的问题吗？

应该不是个大问题。而程序员对此感到意外的最大原因是数组和泛型类型上用法的不一致。对于泛型类型，它们和类型的子类型之间是没什么关系的。而对于数组，它们和子类型是相关的：如果类型A是类型B的子类型，那么A[]是B[]的子类型：

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
可是稍等一下！如果把前面的那个议论中暴露出的问题放在这里，仍然能够在一个apple类型的数组中加入strawberrie(草莓)对象：

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();
这样写真的可以编译，但是在运行时抛出ArrayStoreException异常。因为数组的这特点，在存储数据的操作上，Java运行时需要检查类型的兼容性。这种检查，很显然，会带来一定的性能问题，需要明白这一点。

重申一下，泛型使用起来更安全，能“纠正”Java数组中这种类型上的缺陷。

如果它们不相关，就没有办法把一个未知类型的对象数组传入一个方法里(不经过每次都封装成Object[])，就像下面的：

void sort(Object[] o);
泛型出现后，数组的这个个性已经不再有使用上的必要了，实际上是应该避免使用。

通配符

在本文的前面的部分里已经说过了泛型类型的子类型的不相关性。但有些时候，我们希望能够像使用普通类型那样使用泛型类型：

向上造型一个泛型对象的引用
向下造型一个泛型对象的引用
向上造型一个泛型对象的引用

假设有很多箱子，每个箱子里都装有不同的水果，需要找到一种方法能够通用的处理任何一箱水果。更通俗的说法，A是B的子类型，需要找到一种方法能够将C<A>类型的实例赋给一个C<B>类型的声明。

为了完成这种操作，需要使用带有通配符的扩展声明，就像下面的例子里那样：

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
“? extends”是泛型类型的子类型相关性成为现实：Apple是Fruit的子类型，List<Apple> 是 List<? extends Fruit> 的子类型。

向下造型一个泛型对象的引用

另外一种通配符：? super。如果类型B是类型A的超类型(父类型)，那么C<B> 是 C<? super A> 的子类型：

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;