黑马程序员——Java泛型知识点

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、Java没有泛型之前

1.Java集合对元素类型没有任何限制，这样可能引发一些问题。例如，想创建一个保存Dob对象的集合，但程序也可以轻易地将Cat对象“扔”进去，这样可能会引发异常。

2.集合并不能保存对象的状态信息，集合只知道它存放的是Object，因此取出集合元素后通常还需要进行强制类型转换，这种强制类型转换可能会引发ClassCastException异常。

如下面的程序：

public class ListError {
	
	public static void main(String[] args){
		List dogList = new ArrayList();
		dogList.add(new Dog());
		dogList.add(new Cat());
		
		for(int i=0; i<dogList.size(); i++){
			Dog dog = (Dog)dogList.get(i);
		}
	}

}
class Dog{
}
class Cat{
}

上面的程序创建了一个List集合，只希望保存Dog对象，却也能将Cat对象“扔"进集合dogList中，于是程序试图将一个Cat对象转换成Dog类型，这将导致程序引发ClassCastException异常。

二、引入泛型后

如下面的程序：

public class ListRight {
	
	public static void main(String[] args){
		List<Dog> dogList = new ArrayList<Dog>();
		dogList.add(new Dog());
//		dogList.add(new Cat());//这里将引起编译错误
		
		for(int i=0; i<dogList.size(); i++){
			Dog dog = (Dog)dogList.get(i);
		}
	}

}
class Dog{
}
class Cat{
}

上面程序成功创建了一个只能保存Dog对象的集合:dogList，不能保存其它类型的对象。创建这种只能保存特定类型对象的集合的方法就是泛型：在集合接口、类增加尖括号，尖括号里放一个数据类型，即表明这个集合只能保存这种类型的对象。

而上面的程序在取集合中的数据时，不需要强制类型转换，因为集合dogList对象能记住它保存的对象都是Dog类型。这就是泛型的作用。

三、深入泛型

所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参将在声明变量、创建对象、调用方法时动态地指定，即传入实际的类型参数。

1.定义泛型接口、类

如下代码：

public interface InterfaceTest<E>{
	public void add(E x);
	public E get();
}
public class ClazzTest<T>{
	T info;
	public void setInfo(T info){
		this.info = info;
	}
	public T getInfo(){
		return this.info;
	}
}

2.从泛型类派生子类

当创建了带泛型声明的接口、父类之后，可以为该接口创建实现类，可以为该接口创建实现类，或者从该父类派生子类，但需要指出的是，当使用这些接口、父类时不能再包含类型形参。如下面的代码是错误的：

//定义类A继承Apple类，Apple类不能跟类型形参
public class A extends Apple<T>{}

如果想从Apple类派生一个子类，则可以改为如下代码：

//使用Apple类时，为T形参传入String类型
public class A extends Apple<String>{}

调用方法时必须为所有的数据形参传入参数值，与调用方法不同的是，使用类、接口时可以不为类型形参传入实际的类型参数，即如下代码也是正确的：

//使用Apple类时，没有为T形参传入实际的类型参数
public class A extends Apple{}

如果从Apple<String>类派生子类，则在Apple类中所有使用T类型形参的地方都将被替换成String类型，即它的子类将会继承到String getInfo()和void setInfo(String info)两个方法，如果子类需要重新父类的方法，就必须注意这点。下面程序示范了这一点：

public class A extends Apple<String>{
	
	public String getInfo(){
		return "子类的"+this.info;
	}
	//下面的方法是错误的，重写父类方法是返回值类型不一致
//	public Object getInfo(){
//		return "子类的"+this.info;
//	}

}
class Apple<T>{
	T info;
	public T getInfo(){
		return info;
	}
	public void setInfo(T info){
		this.info = info;
	}
}

3.类型通配符

(1)使用类型通配符

前面讲到，当使用一个泛型类时（包括声明变量和创建对象），都应该为这个泛型类传入一个类型实参。如果没有传入类型实参，编译器就会提出泛型警告。假设现在需要定义一个方法，该方法里有一个集合形参（如List集合），集合形参的元素类型是不确定的，那应该怎样定义呢？

为了表示各种泛型List的父类，我们使用类型通配符，类型通配符是一个问号（？），讲一个问号作为类型实参传递给List集合，写作:List<?>(意思是未知类型元素的List)。类型通配符（？）可以匹配任何类型。

如下面程序：

	public void test(List<?> c){
		for(int i=0; i<c.size(); i++){
			System.out.println(c.get(i));
		}
	}

但这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素加入到其中。如下面代码将引起编译错误。

List<?> c = new ArrayList<String>();
//下面程序引起编译错误
c.add(new Object());

(2)设定类型通配符的上限

还有一种情形是，我们不想使这个List<?>是任何泛型List的父类，只想表示它是某一类泛型List的父类。也就是被限制的泛型通配符，表示如下：

//它表示所有Shape泛型List的父类
List<? extends Shape>

（3）设定类型通配符的下限

用法格式如下：

<? super Type>,这个通配符表示它必须是Type本身，或是Type的父类。

(4)设定类型形参的上限

Java泛型不仅允许在使用通配符形参时设定上限，而且可以在定义类型形参时设定上限，用于表示传给该类型形参的实际类型要么是该上限类型，要么是该上限类型的子类。

下面程序示范了这种用法：

public class Apple<T extends Number>{
	T col;
	public static void main(String[] args){
		Apple<Integer> ai = new Apple<Integer>();
		Apple<Double> ad = new Apple<Double>();
		//下面代码引发编译异常，下面代码试图把String类型传递给T形参
		//但String不是Number的子类型
		Apple<String> as = new Apple<String>();
	}
}

四、泛型方法

泛型方法的用法格式如下：

修饰符  <T, S>  返回值类型  方法签名（形参列表）

{

      //方法体...

}

与类、接口中使用泛型参数不同的是，方法中的泛型参数无需显式传入实际类型参数。

泛型方法与类型通配符的区别：

大多数时候都可以使用泛型方法来代替类型通配符。例如，对应Java的Collection接口中两个方法定义：

public interface Collection<E>{
	boolean containsAll(Collection<?> c);
	boolean addAll(Collection<? extends E> c);
	...
}

上面集合中两个方法的形参都采用了类型通配符的形式，也可以采用泛型方法的形式，如下所示：

public interface Collection<E>{
	<T> boolean containsAll(Collection<T> c);
	<T extends E> boolean addAll(Collection<T> c);
}

如果某个方法中的一个形参（a)的类型或返回值的类型依赖于另一个形参（b）的类型，则形参（b）的类型声明不应该使用通配符——因为形参（a）或返回值的类型依赖于形参（b）的类型，如果形参（b）的类型无法确定，程序就无法定义形参（a）的类型。在这种情况下，只能考虑使用在方法签名中声明类型形参——也就是泛型方法。

五、擦除和转换

当把一个具有泛型信息的对象付给另一个没有泛型信息的变量时，所有在尖括号之间的类型信息都将被扔掉。比如一个List<String>类型被转换为List,则该List对集合元素的类型检查变成了类型变量的上限，即Object。如果试图重新转换为List<String>，编译可以通过，但取出元素时将引发异常。

下面程序示范了这种擦除：

public class ErasureTest{
	public static void main(String[] args){
		List<Integer> li = new ArrayList<Integer>();
		li.add(6);
		li.add(9);
		List list = li;
		//下面代码引起“未经检查的转换”警告，编译、运行时完全正常
		List<String> ls = list;
		//只要访问ls的元素，如下代码将引发运行时异常
		System.out.println(ls.get(0));
	}
}