011Java泛型

泛型的设计背景：

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。

因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。例如：Collection，List，ArrayList这个就是类型参数，即泛型。

泛型的概念：

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参） 。

从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。

JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

为什么要有泛型：

1. 解决元素存储的安全性问题。
2. 解决获取数据元素时，需要类型强制转换的问题。

泛型的好处：

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。

同时，代码更加简洁、健壮。

泛型注意的问题：

泛型只能是类把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想。

泛型类的构造器如：public GenericClass(){}

泛型不同的引用不能相互赋值。尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。

指定泛型为Object和不指定泛型的区别：

1、表示对象不同：在泛型这里Object就只表示Object不能表示所有对象

2、两种泛型的定义不同：前者是能够确定的泛型，后者是不能够确定的泛型

3、判定方式不同：这是两种不同的定义，所以在判定方法上存在不同

//例如：指定泛型为Object只能表示类型为Object，而不指定泛型能表示所有的对象
private void GenericTest() {
	Map map1 = new HashMap();
	Map<String, Object> map2 = new HashMap<String, Object>();
	Map<Object, Object> map3 = new HashMap<Object, Object>();
	Map<String, String> map4 = new HashMap<String, String>();
	test1(map1);
	test1(map2);
	test1(map3); // 编译错误
	test1(map4); // 编译错误
}

private void test1(Map<String, Object> map) {
}

在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

异常类不能是泛型的 。

不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];

参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。

不能在catch中使用泛型。

自定义泛型：

泛型类：

class Person<T> {
	// 使用T类型定义变量
	private T info;

	// 使用T类型定义一般方法
	public T getInfo() {
		return info;
	}

	public void setInfo(T info) {
		this.info = info;
	}

	// 使用T类型定义构造器
	public Person() {
	}

	public Person(T info) {
	this.info = info;
	}
}

泛型方法：

方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。

在泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型。

泛型方法的格式：

[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常

public class DAO {
	public <E> E get(int id, E e) {
		E result = null;
		return result;
	}
}

通配符的使用：

如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G并不是G的子类型！

1.使用类型通配符：？

比如：List<?> ，Map<?,?>，List<?>是List、List等各种泛型List的父类。

2.读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。

3.写入list中的元素时，不能写入。因为我们不知道c的元素类型，我们不能向其中添加对象。唯一的例外是null，它是所有类型的成员。

将任意元素加入到其中不是类型安全的：

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时错误

因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集合的元素类型。

我们传给add的任何参数都必须是一个未知类型的子类。

因为我们不知道那是什么类型，所以我们无法传任何东西进去。唯一的例外的是null，它是所有类型的成员。另一方面，我们可以调用get()方法并使用其返回值。

返回值是一个未知的类型，但是我们知道，它总是一个Object。

通配符使用注意：

//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}
//注意点2：编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{
}
//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();

有限制的通配符：<?>

允许所有泛型的引用调用。

通配符指定上限：

上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=，只能new泛型类或其子类（或泛型接口子类）的实例

Collection<? extends Hashtable> coll = new ArrayList();

通配符指定下限

下限super：使用时指定的类型不能小于操作的类，即>=，只能new泛型类或其父类的实例

Collection<? super Properties> coll = new ArrayList();

举例：

<? extends Number> (无穷小 , Number] 只允许泛型为Number及Number子类的引用调用。 <? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用。 <? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用。

//extends和super的使用举例
public class SortTest {
	public static void main(String[] args) {
		Collection<? extends Hashtable> coll1 = new ArrayList<Properties>();
		Collection<? super Properties> coll2 = new ArrayList<Hashtable>();
        printCollection1(coll1);
        printCollection2(coll2);
	}

	public static void printCollection1(Collection<? extends Hashtable> coll) {
		// Iterator只能用Iterator<?>或Iterator<? extends Person>.
		Iterator<?> iterator = coll.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}

	public static void printCollection2(Collection<? super Properties> coll) {
		// Iterator只能用Iterator<?>或Iterator<? super Person>.
		Iterator<?> iterator = coll.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}

}