《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类满足编写一次适用于多种类型的代码设计，可是这样就暴露以下几个问题了：

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

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

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

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

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版本的泛型来解决上述的问题，如下：

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

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

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

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

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);
    }
}

泛型无界类型通配符

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