第17章_泛型

gong_yz大约 10 分钟

1、什么是泛型

Java泛型（ generics）是JDK 5中引⼊的⼀个新特性，允许在定义类和接⼜的时候使⽤类型参数（ type parameter）。

声明的类型参数在使⽤时⽤具体的类型来替换。泛型最主要的应⽤是在JDK 5中的新集合类框架中。

泛型最大的好处是可以提高代码的复用性。以List接又为例，我们可以将String、 Integer等类型放入List中，如不用泛型，存放String类型要写⼀个List接口，存放Integer要写另外⼀个List接口，泛型可以很好的解决这个问题。

2、什么是类型擦除

2.1 各种语言中的编译器是如何处理泛型

通常情况下，一个编译器处理泛型有两种方式：

Code specialization。在实例化一个泛型类或泛型方法时都产生一份新的目标代码（字节码or二进制代码）。例如，针对一个泛型List，可能需要针对String，Integer，Float产生三份目标代码。
Code sharing。对每个泛型类只生成唯一的一份目标代码；该泛型类的所有实例都映射到这份目标代码上，在需要的时候执行类型检查和类型转换。

Java编译器通过Code sharing方式为每个泛型类型创建唯一的字节码表示，并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除（type erasure）实现的。

2.2 类型擦除

类型擦除指的是通过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。类型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。

类型擦除的主要过程如下：

将所有的泛型参数用其最左边界（最顶级的父类型）类型替换
移除所有的类型参数

2.3 Java编译器处理泛型的过程

code 1：

public static void main(String[] args) {  
    Map<String, String> map = new HashMap<String, String>();  
    map.put("name", "hollis");  
    map.put("age", "22");  
    System.out.println(map.get("name"));  
    System.out.println(map.get("age"));  
}

反编译后的code 1:

public static void main(String[] args) {  
    Map map = new HashMap();  
    map.put("name", "hollis");  
    map.put("age", "22"); 
    System.out.println((String) map.get("name"));  
    System.out.println((String) map.get("age"));  
}

我们发现泛型都不见了，程序又变回了Java泛型出现之前的写法，泛型类型都变回了原生类型。

code 2：

interface Comparable<A> {
    public int compareTo(A that);
}

public final class NumericValue implements Comparable<NumericValue> {
    private byte value;

    public NumericValue(byte value) {
        this.value = value;
    }
     
    public byte getValue() {
        return value;
    }
     
    public int compareTo(NumericValue that) {
        return this.value - that.value;
    }

}

反编译后的code 2:

interface Comparable {
	public int compareTo( Object that);
}
public final class NumericValue
    implements Comparable
{
	public NumericValue(byte value)
	    {
		this.value = value;
	}
	public byte getValue()
	    {
		return value;
	}
	public int compareTo(NumericValue that)
	    {
		return value - that.value;
	}
	public volatile int compareTo(Object obj)
	    {
		return compareTo((NumericValue)obj);
	}
	private byte value;
}

@MyTarget
public class TargetTest {
	private String name;
	@MyTarget
	    private String getName() {
		return name;
	}
}

code 3

public class Collections {
    public static <A extends Comparable<A>> A max(Collection<A> xs) {
        Iterator<A> xi = xs.iterator();
        A w = xi.next();
        while (xi.hasNext()) {
            A x = xi.next();
            if (w.compareTo(x) < 0)
                w = x;
        }
        return w;
    }
}

反编译后的code 3：

public class Collections
{
	public Collections()
	    {
	}
	public static Comparable max(Collection xs)
	    {
		Iterator xi = xs.iterator();
		Comparable w = (Comparable)xi.next();
		while(xi.hasNext())
		        {
			Comparable x = (Comparable)xi.next();
			if(w.compareTo(x) < 0)
			                w = x;
		}
		return w;
	}
}

第2个泛型类Comparable <A>擦除后 A被替换为最左边界Object。Comparable<NumericValue>的类型参数NumericValue被擦除掉，但是这直接导致NumericValue没有实现接口Comparable的compareTo(Object that)方法，于是编译器充当好人，添加了一个桥接方法。

第3个示例中限定了类型参数的边界<A extends Comparable<A>> A，A必须为Comparable<A>的子类，按照类型擦除的过程，先讲所有的类型参数 ti换为最左边界Comparable<A>，然后去掉参数类型A，得到最终的擦除后结果。

3、泛型带来的问题

3.1 当泛型遇到重载

public class GenericTypes {  

    public static void method(List<String> list) {  
        System.out.println("invoke method(List<String> list)");  
    }  
     
    public static void method(List<Integer> list) {  
        System.out.println("invoke method(List<Integer> list)");  
    }  

}

上面这段代码，有两个重载的函数，因为他们的参数类型不同，一个是List<String>另一个是List<Integer> ，但是，这段代码是编译通不过的。因为我们前面讲过，参数List<Integer>和List<String>编译之后都被擦除了，变成了一样的原生类型List，擦除动作导致这两个方法的特征签名变得一模一样。

3.2 当泛型遇到catch

如果我们自定义了一个泛型异常类GenericException，那么，不要尝试用多个catch取匹配不同的异常类型，例如你想要分别捕获GenericException、GenericException，这也是有问题的。

3.3 当泛型内包含静态变量

public class StaticTest{
    public static void main(String[] args){
        GT<Integer> gti = new GT<Integer>();
        gti.var=1;
        GT<String> gts = new GT<String>();
        gts.var=2;
        System.out.println(gti.var);
    }
}
class GT<T>{
    public static int var=0;
    public void nothing(T x){}
}

答案是——2！由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，泛型类的所有静态变量是共享的。

3.4 总结

虚拟机中没有泛型，只有普通类和普通方法,所有泛型类的类型参数在编译时都会被擦除,泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。

创建泛型对象时请指明类型，让编译器尽早的做参数检查（Effective Java，第23条：请不要在新代码中使用原生态类型）

不要忽略编译器的警告信息，那意味着潜在的ClassCastException等着你。

静态变量是被泛型类的所有实例所共享的。对于声明为MyClass<T>的类，访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass<String>还是new MyClass<Integer>创建的对象，都是共享一个静态变量。

泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是无法区分两个异常类型MyException<String>和MyException<Integer>的。对于JVM来说，它们都是 MyException类型的。也就无法执行与异常对应的catch语句。

4、泛型中K、T、V、E、？等的含义

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的java类型（无限制通配符类型）
S、U、V - 2nd、3rd、4th types
Object - 是所有类的根类，任何类的对象都可以设置给该Object引用变量，使用的时候可能需要类型强制转换，但是用使用了泛型T、E等这些标识符后，在实际用之前类型就已经确定了，不需要再进行类型强制转换。

5、限定通配符和非限定通配符

5.1 限定通配符

限定通配符对类型进⾏限制，泛型中有两种限定通配符：

表示类型的上界，格式为：<？ extends T>，即类型必须为T类型或者T子类
表示类型的下界，格式为：<？ super T>，即类型必须为T类型或者T的父类

泛型类型必须⽤限定内的类型来进⾏初始化，否则会导致编译错误。

5.2 ⾮限定通配符

<?>是非限定通配符，表示可以用任意泛型类型来代替他，即可以把任意类型List复制给List<?>：

List<Apple> apple = new ArrayList<Apple>();
List<Anything> anythings = new ArrayList<Anything>();
List<?> fruits = apple;
List<?> fruits = anythings;

6、上下界限定符extends 和 super

<? extends T>和<? super T>是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念。

<? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”，即泛型中的类必须为当前类的子类或当前类。

<? super T>：是指 “下界通配符（Lower Bounds Wildcards）”，即泛型中的类必须为当前类或者其父类。

先看一个列子：

public class Food {}
public class Fruit extends Food {}
public class Apple extends Fruit {}
public class Banana extends Fruit{}

public class GenericTest {
	public void testExtends(List<? extends Fruit> list){
		//报错,extends为上界通配符,只能取值,不能放.
		//因为Fruit的子类不只有Apple还有Banana,这里不能确定具体的泛型到底是Apple还是Banana，所以放入任何一种类型都会报错
		//list.add(new Apple());
		//可以正常获取
		Fruit fruit = list.get(1);
	}
	public void testSuper(List<? super Fruit> list){
		//super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲，
		//无法确定Fruit的父类是否只有Food一个(Object是超级父类)
		//因此放入Food的实例编译不通过
		list.add(new Apple());
		//        list.add(new Food());
		Object object = list.get(1);
	}
}

在testExtends方法中，因为泛型中用的是extends，在向list中存放元素的时候，我们并不能确定List中的元素的具体类型，即可能是Apple也可能是Banana。因此调用add方法时，不论传入new Apple()还是new Banana()，都会出现编译错误。

理解了extends之后，再看super就很容易理解了，即我们不能确定testSuper方法的参数中的泛型是Fruit的哪个父类，因此在调用get方法时只能返回Object类型。结合extends可见，在获取泛型元素时，使用extends获取到的是泛型中的上边界的类型(本例子中为Fruit),范围更小。

在使用泛型时，存取元素时用super,获取元素时，用extends。

频繁往外读取内容的，适合用上界Extends。经常往里插入的，适合用下界Super。

7、`List<Object>`和原始类型List之间的区别

原始类型List和带参数类型List<Object>之间的主要区别是：在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查。

通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。

它们之间的第二点区别是，你可以把任何带参数的类型传递给原始类型List，但却不能把List<String>传递给接受 List<Object>的方法，因为会产生编译错误。

8、`List<?>`和`List<Object>`之间的区别

List<?> 是一个未知类型的List，而List<Object> 其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>，却不能把List<String>赋值给 List<Object>。

9、泛型的PECS原则

PECS指的是Producer Extends Consumer Super，这是在集合中使用限定通配符的一个原则。

如果只是从一个泛型集合中提取元素，那么它是一个生成器（Producer），应该使用Extends：

List<? extends Fruit> fruits = new ArrayList<>();
fruits.add(new Apple()); //编译失败

当我们尝试向一个生成器中添加元素时，会编译失败。这是因为编译器只知道List中的元素是Fruit及其子类，但具体是哪张类型编译器是不知道的。

如果只是向集合中填充元素，那么它是一个消费者（Consumer），应该使用Super：

List<? super Apple> apples = new ArrayList();
Fruit a = apples.get(0);

当我们尝试从消费者中提取元素时，也会编译失败。这是因为编译器只知道这个List中的元素是Apple及其子类，但具体是那种类型编译器是不知道的。

简单的说，在集合中，频繁的往外读取内容的场景，适合用<？Extends T>; 经常向集合中插入内容的场景，适合用<? Super T>。

另外，如果想在同一个集合中同时使用这两种方法，则不应该使用Extends或Super。

第17章_泛型

# 1、什么是泛型

# 2、什么是类型擦除

# 2.1 各种语言中的编译器是如何处理泛型

# 2.2 类型擦除

# 2.3 Java编译器处理泛型的过程

# 3、泛型带来的问题

# 3.1 当泛型遇到重载

# 3.2 当泛型遇到catch

# 3.3 当泛型内包含静态变量

# 3.4 总结

# 4、泛型中K、T、V、E、？等的含义

# 5、限定通配符和非限定通配符

# 5.1 限定通配符

# 5.2 ⾮限定通配符

# 6、上下界限定符extends 和 super

# 7、List<Object>和原始类型List之间的区别

# 8、List<?>和List<Object>之间的区别

# 9、泛型的PECS原则