Android架构师必备技能 | 深入Java泛型（上）

泛型的定义与作用

一，什么是泛型

泛型是Java SE 1.5 的新特性。
泛型的本质是参数化类型，也就是说，泛型就是将所操作的数据类型作为参数的一种语法。

public class Paly<T>{
    T play(){}
}

其中T就是作为一个类型参数在Play被实例化的时候所传递来的参数，比如：

Play<Integer> playInteger=new Play<>();

这里 T 就会被实例化为 Integer。

二，泛型的作用

泛化

• 可以用T代表任意类型Java语言中引入泛型，是一个较大的功能增强；
• 不仅语言、类型系统和编译器有了较大的变化，以支持泛型；
• 类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了，这带来了很多好处；

类型安全

• 泛型的主要目标是提高 Java 程序的类型安全；
• 编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常；
• 符合越早出错代价越小原则；

消除强制类型转换

• 泛型的一个附带好处是，使用时直接得到目标类型，消除许多强制类型转换；
• 所得即所需，这使得代码更加可读，并且减少了出错机会；

向后兼容

• 支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序，但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。

泛型通配符与嵌套

一，泛型通配符

我们在定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符。

泛型中有三种通配符形式：

• 无限制通配符 < ?>
• 上界通配符 < ? extends E>
• 下界通配符 < ? super E>

无限制通配符 <?>
要使用泛型，但是不确定或者不关心实际要操作的类型，可以使用无限制通配符 <?>，表示可以持有任何类型。

上界通配符 < ? extends E>

extends 关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 E 或者 E 的子类，编辑不成功
• 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

例：

/**
 * 有限制的通配符之 extends （有上限），表示参数类型 必须是 BookBean 及其子类，更灵活
 * @param arg1
 * @param arg2
 * @param <E>
 * @return
 */
private <K extends ChildBookBean, E extends BookBean> E test2(K arg1, E arg2){
    E result = arg2;
    arg2.compareTo(arg1);
    //.....
    return result;

类型参数列表中如果有多个类型参数上限，用逗号分开。

下界通配符 < ? super E>

super 关键字声明了类型的下界，表示参数化的类型可能是指定的类型，或者是此类型的父类

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

代码：

private <E> void add(List<? super E> dst, List<E> src){
    for (E e : src) {
        dst.add(e);
    }
}

上面的 dst 类型 “大于等于” src 的类型，这里的“大于等于”是指 dst 表示的范围比 src 要大，因此装得下 dst 的容器也就能装 src。

二，泛型嵌套

泛型嵌套的使用

• 创建一个PO类

/**
 * 测试泛型的嵌套
 * @author Administrator
 *
 * @param <T>
 */
public class Class01<T> {
 
	private T stu;

	public T getStu() {
		return stu;
	}
	public void setStu(T stu) {
		this.stu = stu;
	}
}

泛型的嵌套使用及 HashMap 中的典型泛型嵌套使用方法

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
import java.util.Map.Entry;;
 
/**
 * 泛型的嵌套 --->由外向内拆分
 * @author Administrator
 *
 */
public class Generics {
	public static void main(String[] args) {
		Student01<String> stu = new Student01<String>();
		
		stu.setScore("AA");
		System.out.println(stu.getScore());
		
		//嵌套 --->多层包裹
		Class01<Student01<String>> c1 = new Class01<Student01<String>>();
		c1.setStu(stu);
		stu = c1.getStu();
		String score = stu.getScore();
		System.out.println(score);
		
		//HashMap中的泛型嵌套
		
		Map<String, String> map = new HashMap<String, String>();
		
		map.put("01", "AA");
		map.put("02", "BB");
		
		Set<Entry<String,String>> entrySet = map.entrySet();
		//增强的for循环,遍历entrySet
		for (Entry<String, String> entry : entrySet) {
			System.out.println(entry);
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+"--->"+value);
		}
	}
}