Java学习笔记-泛型初步

1.为什么要使用泛型程序设计

早期Java使用Object来代表任意类型的，但是向下转型有强转的问题，这样程序就不太安全。
如果没有泛型，程序会怎样呢？

Collection、Map集合对元素的类型没有任何限制的

本来我的Collection集合装载的是全部的Dog对象，但是外边把Cat对象存储到集合中，没有错误检查，可以向数组列表中添加任何类的对象。所以，我们需要对集合中的元素类型加以限制。

外边获取该对象，还需要强制转换

把对象扔进集合中，集合是不知道元素的类型是什么的，仅仅知道是Object。因此在get()的时候，返回的是Object。
有了泛型之后：

代码更加简洁（不用强制转换）
程序更加健壮（只要编译时期没有警告，那么运行期间就不会出现ClassCastException异常）
可读性和稳定性（在编写集合的时候，就限定了类型）

泛型提供了一个更好的解决方案：类型参数（type parameters）。ArrayList类有一个类型参数用来指示元素的类型：

ArrayList<String>files=new ArrayList<>();

这使得代码具有更好的可读性。人们一看就知道这个数组列表中包含的是String对象。

2.定义简单泛型类

一个泛型类就是具有一个或多个类型变量的类。 我们使用一个简单的Pair类作为例子。对于这个类来说，我们只关注泛型，而不会为数据存储的细节烦恼。

package generic;

public class Pair<T>{
	private T first;
	private T second;
	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;
	}
}

Pair类引入了一个类型变量T，用尖括号括起来并放在类名的后面。
注意，泛型类可以有多个类型变量。例如，可以定义Pair类，其中第一个域和第二个域使用不同的类型：

public class Pair<T,U>{...}

类定义中的类型变量指定方法的返回类型以及域和局部变量的类型。例如：

private T first;

用具体的类型替换类型变量就可以实例化泛型类型，例如：

Pair<String>

我们来看一个具体的例子，下面的实例使用了Pair类。静态的minmax方法遍历了数组并同时计算出最大值与最小值。它用Pair对象返回了两个结果。

package generic;

public class PairTest {
	public static void main(String[] args){
		String[] words={"Mary","had","a","little","lamb"};
		Pair<String>mm=ArrayAlg.minmax(words);
		System.out.println("min="+mm.getFirst());
		System.out.println("max="+mm.getSecond());
	}
}
class ArrayAlg{
	public static Pair<String> minmax(String[] a){
		if(a==null||a.length==0)
			return null;
		String min=a[0];
		String max=a[0];
		for(int i=1;i<a.length;i++){
			if(min.compareTo(a[i])>0)
				min=a[i];
			if(max.compareTo(a[i])<0)
				max=a[i];
		}
		return new Pair<>(min,max);
	}
}

返回结果：

min=Mary
max=little

3.泛型方法

前面的示例中：

public static Pair<String> minmax(String[] a)

这就是一个典型的泛型方法。泛型方法可以定义在普通类中，也可以定义在泛型类中。

4.类型变量的限定

有的时候，类或方法需要对类型变量加以约束。下面是一个典型的例子。我们要计算数组中的最小元素：

class ArrayAlg{
	public static <T> min(T[] a){
		if(a==null||a.length==0)
			return null;
		String min=a[0];
		for(int i=1;i<a.length;i++){
			if(min.compareTo(a[i])>0)
				min=a[i];
		}
		return min;
	}
}

但是这里有一个问题。

public static Pair1<T> min(T[] a)...

变量min的类型是T，这意味着它可以是任何一个类的对象。怎么才能确信T所属的类有compareTo方法呢？
解决这个问题的方案是将T限制为实现了Comparable接口（只含一个方法compareTo的标准接口）的类。可以通过对类型变量T设置限定实现这一点：

public static<T extends Comparable>min(T[] a)...

但是为什么使用的关键字是extends而不是implements呢？Comparable不是一个接口吗？

<T extends BoundingType>

表示T应该是绑定类型的子类型。T和绑定类型可以是类，也可以是接口。 选择extends的原因是更接近于子类的概念。当然，一个类型变量可以有多个限定。

T extends Comparable&Serializable

最后说一个非常重要的知识点：
Java采用泛型擦除机制来引入泛型。Java中的泛型仅仅是给编译器Javac使用的，确保数据的安全性和免去强制类型转换的麻烦。但是编译一旦完成，所有和泛型有关的类型全部被擦除。

5.泛型的错误使用

我们先看一下下面这一行代码：

List<int> list=new ArrayList<int>();

首先，这样写是错误的。
因为泛型要求能包容的是对象类型，而int是基本类型而不是对象类型。但是基本类型都有其包装类型，也就是

boolean->Boolean
int->Integer
byte->Byte
short->Short
long->Long
float->Float
double->Double
char->Character

如果你想要存放基本类型，就使用包装类去实现：

List<Integer> list=new ArrayList<Integer>();