【java】泛型介绍

概念

Java 泛型（generics）是 JDK 5 中引入的一个新特性，泛型提供了编译时类型安全检测机制。

本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

java 中泛型标记符

• E - Element (在集合中使用，因为集合中存放的是元素)
• T - Type（Java 类）
• K - Key（键）
• V - Value（值）
• N - Number（数值类型）
• ？ - 通配符，表示不确定的 java 类型

先来看看不使用泛型的例子：

public class GenericTest {

	public static void main(String[] args) {
		List list = new ArrayList();

		Cat cat = new Cat();
		Dog dog = new Dog();

		list.add(cat);
		list.add(dog);

		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			// 通过Iterator取出的每一项都是object类型，下面语法是错误的
			// Animal a = iterator.next(); // Type mismatch: cannot convert from Object to
			// Animal
			// 需要向下转型，获取Animal类
			Animal a = (Animal) iterator.next();
			// 判断是Cat还是Dog类的实例并调用相应方法
			if (a instanceof Cat) {
				((Cat) a).catCall();
			} else {
				((Dog) a).dogCall();
			}
		}

	}

}

class Animal {

	public void call() {
		System.out.println("动物的叫声~");
	}
}

class Cat extends Animal {

	public void catCall() {
		System.out.println("喵喵喵~");
	}
}

class Dog extends Animal {

	public void dogCall() {
		System.out.println("汪汪汪~");
	}
}

使用泛型后的代码：

public static void main(String[] args) {
		List<Animal> list = new ArrayList<Animal>();

		Cat cat = new Cat();
		Dog dog = new Dog();

		list.add(cat);
		list.add(dog);

		Iterator<Animal> iterator = list.iterator();
		while (iterator.hasNext()) {
	
			Animal a = iterator.next();
			if (a instanceof Cat) {
				((Cat) a).catCall();
			} else {
				((Dog) a).dogCall();
			}
		}

	}

Tips：‘<>’钻石语法，自动检测类型。即这样写也可以 List<Animal> list = new ArrayList<>();

（推荐）引用与具体实例的泛型是保持一致。

使用泛型List<Animal>，表示此集合中就只能存放Animal类型的数据了，起到了统一集合中元素的数据类型的作用。如果试图存储非Animal类型（及其子类），程序会在编译期间报错。

有界的类型参数

目的是限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends/super关键字，最后紧跟它的上界/下界。

• 上界：<? extends T> ，该list只能获取（get）元素，不能添加（add）元素
• 下界：<? super T> ， 该list只能添加（add）元素，不能获取（get）元素

PECS原则

全称 Producter Extends, Consumer Super，即 供应者使用 Extends,消费者使用 Super。

示例代码中有如下继承关系，以便理解：

class Food { }

class Fruit extends Food {}

class Banana extends Fruit {}

class Apple extends Fruit {}

class RedApple extends Apple {}

class Green extends Apple {}

 没有泛型上下界的问题

泛型的上界通配符<? extends T>

//	Apple是Fruit的子类，语法正确
	Fruit apple = new Apple();
//	Type mismatch: cannot convert from ArrayList<Pecs.Apple> to List<Pecs.Fruit>
	List<Fruit> apple2 = new ArrayList<Apple>(); // 编译报错

显然ArrayList<Pecs.Apple>与List<Pecs.Fruit>之间不存在继承引用关系。这时候，就需要上下界的帮助了。例如使用上界通配符 ? extends Fruit，就能解决问题。

List<? extends Fruit> apple2 = new ArrayList<Apple>();

那么这个怎么来理解呢？在上面的例子中，？ extends Fruit代表任何继承了Fruit的子类（包含Fruit本身），都可以装进去（如下图）。

上界通配符的特点

只能取，不能存！

怎么个说法呢？先说“只能取”，这个很好理解，集合中都是Fruit的子类，那么取出来的元素必然都能用Fruit来进行引用。

测试代码：

		 List<Apple> appleList = new ArrayList<>();
		 List<Banana> bananaList = new ArrayList<>();

		 appleList.add(new Apple());
		 bananaList.add(new Banana());
		 
		 List<? extends Fruit> plate1 = appleList;
		 Fruit f1 = plate1.get(0);
		 List<? extends Fruit> plate2 = bananaList;
		 Fruit f2 = plate2.get(0);
		 // com.camphor.Apple,com.camphor.Banana
		 System.out.printf("%s,%s", f1.getClass().getName(), f2.getClass().getName());

“不能存”又该如何理解呢？往下慢慢看，你就知道了。

	     List<Apple> appleList = new ArrayList<>();
		 appleList.add(new Apple());		 
		 List<? extends Fruit> plate1 = appleList;
		 plate1.add(new Apple()); // 报错！

eclipse里报错信息，显示确实不让添加：

这就很奇怪了，list里全都是Fruit子类吗？那我们向list添加它的子类（Apple）为什么不行？

我们重新捋一捋，首先plate1引用的是appleList，而这个appleList中的泛型限定上界为Apple，那这也就意味着plate1的泛型也该是Apple，我们向其中添加Apple元素（RedApple和GreenApple）都没有问题，它们都能转为Apple类型（向上转型）。

回过头来看，虽说 <? extends Fruit>，它表示的是任何继承了Fruit的子类，没问题吧，照这么说添加Banana应该也可以啊，但是不行！别忘了，我们已经将plate的指向到了appList，而appleList规定了泛型是Apple。如果向其中添加Banana，它能转换成Apple吗？答案是否定的。

为了保证绝对安全，限制了上界不能进行添加元素，以免发生转型失败的问题。

附：一种同时能容纳Apple和Banana两种水果的盘子。

	     List<? extends Fruit> plate3 = Arrays.asList(new Apple(), new Banana());
		 Fruit apple = plate3.get(0);
		 Fruit banana = plate3.get(1);
		 System.out.printf("%s,%s", apple.getClass().getName(),            
         banana.getClass().getName());

 泛型的下界通配符<? super T>

以? super Fruit为例，它代表的就是任何Fruit的父类及其Fruit本身（共同的祖先Object）。

 下界通配符的特点

“只能存，不能取”，其实倒也不是绝对不能取，只是为了区分上下界，让它们的特点完全相反，都把下界的特点都写成了不能取。在代码中实践是能取出来，只不过会使其中的元素类型失效，取出来的元素类型都是Object。

如下代码解释了“能存”：

		// 定义了一个plate，下界为 <? super Apple>
		 List<? super Apple> plate = new ArrayList<>();

		 plate.add(new Apple());
		 plate.add(new RedApple());
		 plate.add(new GreenApple());

以上代码能正常编译运行，那既然是Apple类型的任何父类，试着往其中添加Fruit，Food。

 居然报错了？！

 这不由得又绕回上面提到的“绝对安全”，会不会还出现上文中转型失败的情况？虽然说添加Apple，Fruit和Food类型都在下界范围内，但是谁能保证你就是添加的这几个类型的元素呢？比如上图我向其中添加Banana，它肯定会出问题的。

那为什么又让添加Apple及其子类呢，因为它绝对安全，它们都可以安全的转型成Apple类（向上转型），根本不会出啥毛病，所以是可以添加的。下界通配符“能存”元素就是这种体现。

附：什么叫“其实也能取”。

因为? super Apple这个范围太大了，无法准确知道你拿出来是具体什么类型，只能用最高的Object来进行引用，导致其中元素类型失效了。

 参考：“界限”带来的灵活性 —— Java泛型的上下界