《java编程思想》—— 泛型

摘要：引用泛型除了方法因不能使用外部实例参数外，其他继承实现成员变量，成员方法，方法返回值等都可使用。因此，生成的字节码仅包含普通的类，接口和方法。

一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义类的对应类型；如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
----摘自原书
Ordinary classes and methods work with specific types: either
primitives or class types. If you are writing code that might be used
across more types, this rigidity can be overconstraining.
----摘自英文版

从原书的第一段话引出，其实泛型的出现是为了让编写的代码可以应用于多种类型，解除只能使用具体类型的限制，这也就是参数化类型的概念。

泛型是在Java SE5出现的，也就是说java5版本之前的java是不存在泛型的概念的。而Java5这个版本增加了泛型设计其中重要的一个原因就是：优雅的安全的让容器类解除只能使用具体类型的束缚，从而适用于多种类型。

下面以ArrayList为例比较前后差异，证明泛型的优雅和安全：

java1.4版本

public class ArrayList // 省略继承和实现
{
    transient Object[] elementData;         // 用于存储ArrayList对象的数组
    public Object get(int index) { . . . }  // 获取数组对象
    public void add(Object o) { . . . }     // 添加数组对象
}

java5版本

public class ArrayList
{
    transient Object[] elementData;
    public E get(int index) {...}
    public boolean add(E e) {...}

从两者对比可以看出，java1.4版本是使用Object类作为对象存取的的出参入参，这样的好处自然是可以让ArrayList类满足编写一次适用于多种类型的代码设计，可是这样就暴露以下几个问题了：

当获取一个值时必须进行强制类型转换

ArrayList strs = new ArrayList();
strs.add("hello");
String str = (String) strs.get(0);

这里如果不加(String)强制转换，那么代码在编译期就会报错：Incompatible types，并提示files.get(0)返回的是一个Object对象可是接收的是String类型对象，需要做类型强制转换。

当添加一个值时没有在编译器做类型错误检査

ArrayList files = new ArrayList();
files.add(new File("./hello.text"));
File file = (File)files.get(0);     // 正常
String file = (String)files.get(0); // 编译器正常，运行期报错

代码在编译期不会出错，可是在运行期的时候就会报强转错误：java.lang.ClassCastException，这个问题其实也就是使用Object类的弊端了。

既然java1.4出现了上述问题，那么现在就是用java5版本的泛型来解决上述的问题，如下：

当获取一个值时必须进行强制类型转换（解决）

// 这里第二个<>省略了String，是因为类型推导
ArrayList strs = new ArrayList<>();
strs.add("hello");
String str = strs.get(0);

可以看出java5之后之后就不需要做类型强转了，这是因为get方法的返回类型已经在实例化的时候被给参数化了。

当添加一个值时没有在编译器做类型错误检査（解决）

ArrayList files = new ArrayList<>();
files.add(new File("./../Fibonacci.java"));
File file = (File)files.get(0);             // 正常
String file = (String)files.get(0);         // 编译期就报错了

可以看出1.5之后之后就不需要可能到线上才会发现的bug，在编写代码的时候编辑器就给提前给提示：Inconvertible types; cannot cast "java.io.File" to "java.lang.String"(禁止File类型转换成String类型了)

虽然泛型解决的问题还有很多，但是总的来说都是为了：更优雅的更安全的让容器类解除只能使用具体类型的束缚，从而适用于多种类型。

下面我们就来正式讲一下泛型的语法，以及使用范围：

语法定义：

定义泛型：接口名之后定义该类会使用到的所有泛型。

引用泛型：除了static方法因不能使用外部实例参数外，其他继承、实现、成员变量，成员方法等都可使用。

泛型实参：通过继承类的实例化时传入，不传默认是Object

语法结构：

interface  接口名 <定义泛型标识> extends 父接口名 <引用泛型标识> {
  public 引用泛型标识 var; 
  ...
}

案例 —— 生成器接口：

/**
 * 生成器是一种专门负责创建对象的类，是类似工厂模式，不同的是工厂模式一般需要入参，而生成器不需要。
 * 即生成器是：无需额外的信息就可以知道如何创建对象，一般来说生成器只会定义一个创建对象的方法。
 * 本例子中的创建对象方法就是next
 * @param 
 */
public interface Generator {
  T next();
}

语法定义：

定义泛型：类名之后定义该类会使用到的所有泛型。

引用泛型：除了static方法因不能使用外部实例参数外，其他继承、实现、成员变量，成员方法，方法返回值等都可使用。

泛型实参：类的实例化时钻石符放在类名之后，如：new ArrayList()

语法结构：

class  类名 <定义泛型标识> 
    extends 父类名 <引用泛型标识>, implements 接口名 <引用泛型标识> {
  private 引用泛型标识 var; 
  ...
}

案例 —— 生成器具体实现类:

public class TestBasicGenerator implements Generator {
  private Class type = null;
  // 本来下面写法会更优雅一点，但是因为泛型的类型擦除导致这种写法是会报错的
  // private Class type = T.class;
  public TestBasicGenerator(Class clazz) {
    type = clazz;
  }
  public static  Generator gen(Class clazz) {
    return new TestBasicGenerator(clazz);
  }
  public T next() {
    try {
      return (T) type.newInstance();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  public static void main(String[] args) {
    // 书上的方法，通过静态泛型方法：简单
    Generator gen = TestBasicGenerator.gen(Coffee.class);
    Coffee c =  gen.next();

    // 课后习题，通过实例化方法：复杂
    Generator gen1 = new TestBasicGenerator(Coffee.class);
    Coffee c1 =  gen1.next();
  }
}

语法定义：

定义泛型：该方法修饰符之后定义该方法会使用到的所有泛型。

引用泛型：包括返回值、参数、内部变量，内部方法等，除非该方法是static方法，否则也可以使用类上定义的泛型，两者不冲突。

泛型实参：

显示传递：方法调用时钻石符放在方法名之前，"."号之后，如：New.show("hello")，一般建议用显示传递，方便阅读。

隐式传递：无需传递，编译器会根据上下文（入参或者返回值接收变量）推导出具体的类型，如：New.show("hello")、Map> sls = New.map()（前者根据是非赋值语句的入参推导，后者根据赋值语句的接收变量推导）。

语法结构：

public class 类名 {
    public <定义泛型标识> 返回类型 方法名(引用泛型标识 形参名) {
        ...
    }
}

案例 —— 创建常用容器对象的工具类（简略版）：

public class New {
  public static  Map map() {
          return new HashMap();
  }
  public static  void show(T title) {
          System.out.println(title);
  }
    // Examples:
  public static void main(String[] args) {
    Map> sls = New.map();
    // 显示传递
    New.show("hello");
    // 隐式传递
    New.show("hello");
    // 编译器会报show方法不能传递String类型，证明显示传递为主，隐式传递为辅
    New.show("hello");
  }
}

可变参数方法可以与泛型无缝结合：

案例 —— 入参聚合:

public class GenericVarargs {
  public static  List makeList(T... args) {
    List result = new ArrayList();
    for(T item : args)
      result.add(item);
    return result;
  }
  public static void main(String[] args) {
    ls = makeList("A", "B", "C");
    System.out.println(ls);    // 打印出：[A, B, C]
  }
}

有时您可能希望在泛型类、泛型方法、泛型接口中限制一下传入的泛型实参的类型。例如，对数字进行操作的方法可能只想接受Number子类或者父类的实例，那这个时候就需要用到边界通配符了：

使用上界限制类型参数，需要借助extends关键之，先在<>中写类型参数的标志号，后跟extends，最后才是上界类型（注意：上界类型可以多个，但是最多只允许一个类搭配多个接口，类还必须写在第一位，因为java是单继承多实现），用法一般只用于泛型方法、泛型接口、泛型类这三处语法中的定义泛型的地方。

复杂案例如下（仅做案例）：

// 表示类型实参只能是Number的子类，并且该子类还要实现List接口，否则编译报错（上界不包含上）
public class TestTypeErasure> {
    ...
}

上界通配符

使用下届限制类型参数，需要借助super关键之，先在<>中写无界通配符?，后跟super，最后才是下届具体类型或泛型标识符（注意：这里就只能一个了），用法一般只用于限制容器类值。

复杂案例如下（仅做案例）：

// 表示类型实参可以是Integer类型，或者Integer的父类（下届包含下）
public static void addNumbers(List list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

上面讲下届通配符时需要借助无界通配符，但是它不止有哪一种写法，还可以直接在<>中写?，表示不限定类型参数，类似