Core Java笔记 7.泛型(I) - 概念，语法与原理

CoreJava

---

本章重点：

• 为何要使用泛型
• 定义泛型类
• 定义泛型方法
• 原理：Java 泛型代码机制
• 泛型与多态的冲突与解决

---

本文主要介绍 Java 泛型的概念和定义，以及 Java 泛型机制的实现原理。

为何要使用泛型

使用泛型程序设计，可以避免随处可见的 Object 以及强制转换，提高了代码的安全性和可读性。

---

定义泛型类

类型参数(type parameters): Java 和C++一样，通过引入类型参数进行泛型编程。

泛型类(generic class): 指含有一个或者多个类型参数的类。

e.g.

package corejava.generic;
/**
 * Created by guolong.fan on 15/5/4.
 */
 class Pair<T> {
    public Pair() { first = null; second = null;}
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() { return first; }
    public T getSecond() { return second; }
    public void setFirst(T newValue) { first = newValue; }
    public void setSecond(T newValue) { second = newValue; }
    private T first;
    private T second;
}
public class PairTest {
    public static void main(String[] args) {
        String[] words = { "Mary", "had", "a", "little", "lamb" };
        Pair<String> mm = minmax(words);
        System.out.println("min = " + mm.getFirst());
        System.out.println("max = " + mm.getSecond());
    }
    // 后面会引入 泛型方法 写更加通用的方法
    public static Pair<String> minmax(String[] a) {
        if (a == null || a.length == 0) return null;
        String min = a[0];
        String max = a[0];
        for (String ele : a) {
            if (min.compareTo(ele) > 0) min = ele;
            if (max.compareTo(ele) < 0) max = ele;
        }
        return new Pair<String>(min, max);
    }
}

---

定义泛型方法

可以在普通类中定义泛型方法。

概念： 类型推断， 类型限定，多类型限定。

e.g.

package corejava.generic;
/**
 * Created by guolong.fan on 15/5/4.
 */
class ArrayAlg {
    // 概念1: 最简单的泛型方法(无类型限定)
    public static <T> T getMiddle(T[] a) {
        return a[a.length/2];
    }
    // 概念2. 类型限定：<T extends Comparable>
    public static <T extends Comparable> T min(T[] a) {
        if (a == null || a.length == 0) return null;
        T min = a[0];
        for (T ele : a) {
            if (min.compareTo(ele) > 0) min = ele;
        }
        return min;
    }
    // 概念3. 多类型限定： <T extends Comparable & Serializable>
    // 概念4. Comparable 本身是泛型，下一讲会介绍完整的限定写法.
}
public class ArrayAlgTest {
    public static void main(String[] args) {
        String[] names = { "John", "Q.", "Public" };
        // 概念4. 类型推断
        String middle = ArrayAlg.<String>getMiddle(names);
        // 简化写法. 编译器会做类型推断.
        // String middle = ArrayAlg.getMiddle(names);    
        // 概念5. 基本类型无法用于泛型(见后面详解)
        // int midVal = ArrayAlg.getMiddle(new double[] {120.2, 14, 34}); // Compile ERROR!!!
    }
}

---

原理：Java 泛型代码机制

泛型类可以看成普通类的工厂! JVM 没有泛型类型对象 —— 所有对象都是普通类对象。泛型是编译器行为. 这是 Java 和C++泛型的本质区别，也是 Java 泛型表达能力弱的根源.

编译器如何编译 Java 泛型代码

过程：
1. 擦除(Erase): 泛型类和泛型方法无论何时定义泛型类型，都会自动提供一个对应的原始类型(raw type). 例如: Pair 的原始类型就是 Pair。
2. 使用端(具体的泛型类)：泛型代码块翻译

1. erase

泛型类和泛型方法的擦除策略： 分为两种情况：有限定[只有泛型方法才有限定]和无限定(即默认 Object 限定). 无限定采用 Object 进行擦除(这是 Java 泛型不支持基本类型的原因)，
限定采用第一个限定(即extends 后面的第一个接口/类)擦除.

Pair 会被擦除为：

class Pair {
    public Pair() { first = null; second = null;}
    public Pair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }
    public Object getFirst() { return first; }
    public Object getSecond() { return second; }
    public void setFirst(Object newValue) { first = newValue; }
    public void setSecond(Object newValue) { second = newValue; }
    private Object first;
    private Object second;
}

限定切换与性能

对于诸如：多限定的泛型类/泛型方法，会产生切换限定的概念, 采用第一个类型进行擦除，代码必要时会插入强类型转换来切换限定，所以为了提高效率（减少强制转换），应该将 tagging 接口放在末尾，主要看哪个使用的多。

2. 泛型代码块翻译

使用端使用具体的泛型类，这时候编译器实际上是通过添加强制转换代码来完成的。

e.g.

Pair<Employee> buddies = ...;
Employee buddy = buddies.getFirst();
// 会被翻译成两条指定：
Object obj = buddies.getFirst();
Employee buddy = (Employee) obj;

---

泛型与多态的冲突与解决

问题1: 类型擦除与多态冲突

假如：

public class DateInterval extends Pair<Date> {
    @Override
    public void setSecond(Date second) {
        if (second.compareTo(getFirst()) >= 0) {
            super.setSecond(second);
        }
    }
}

DateInterval 会被 erase 为：

public class DateInterval extends Pair {
    @Override
    public void setSecond(Date second) {
        ... ...
    }
    ... ... 
}

这时候 DateInterval 就会有两个 setSecond 方法，一个是从 Pair 继承而来的方法，一个是 @Override 的 setSecond 方法。

那么问题来了，多态不是失效啦么？？@Override应该会导致编译出错啊(@Override会执行编译检查)？那么 Java 编译器是如何解决的呢？？

分析：

➜  javap -private DateInterval
Compiled from "DateInterval.java"
public class corejava.generic.DateInterval extends corejava.generic.Pair{
    public corejava.generic.DateInterval();
    public void setSecond(java.util.Date);
    public void setSecond(java.lang.Object); // 注: bridge method.
}

其实 Java 编译器会为 DateInterval 类生成一个 bridge method.
这个 bridge method 大致实现是：

public void setSecond(java.lang.Object) { 
    setSecond((Date) second);
}

这样就保证了 Java 多态语义，其实 @Override 的是 setSecond(Object).

问题2: 返回值冲突与解决

如果返回值出现冲突
e.g.

public class DateInterval extends Pair<Date> {
    ... 
    @Override
    public Date getSecond() {
        return (Date)super.getSecond().clone();
    }
}

分析:

➜  generic  javap -private DateInterval 
Compiled from "DateInterval.java"     
public class corejava.generic.DateInterval extends corejava.generic.Pair{
    public corejava.generic.DateInterval();
    public java.util.Date getSecond();
    public java.lang.Object getSecond();  // 注: bridge method
}

一个惊人的发现: 竟然有两个方法名和参数完全一样的方法，你没看错，真的有两个，你需要知道的是：JVM 能够正确处理调用哪个方法(其实就是调用 bridge method, bridge method 再调用协变方法).

Java SE5.0 中增加了一个额外的特性: 协变。也是通过 bridge method 实现的。

小总结

1. JVM 中没有泛型，只有普通类和普通方法.
2. 所有的类型参数都用它们的限定类型替换（erase）.
3. bridge method 用来解决泛型和多态的冲突.
4. 为保持类型安全性，编译器必要时插入强制类型转换.