【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 list = new ArrayList();

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

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

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

	}

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

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

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

有界的类型参数

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

  • 上界: ,该list只能获取(get)元素,不能添加(add)元素
  • 下界: , 该list只能添加(add)元素,不能获取(get)元素

PECS原则

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

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

【java】泛型介绍_第1张图片

class Food { }

class Fruit extends Food {}

class Banana extends Fruit {}

class Apple extends Fruit {}

class RedApple extends Apple {}

class Green extends Apple {}

 没有泛型上下界的问题

泛型的上界通配符

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

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

List apple2 = new ArrayList();

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

【java】泛型介绍_第2张图片

上界通配符的特点

只能取,不能存!

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

测试代码:

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

		 appleList.add(new Apple());
		 bananaList.add(new Banana());
		 
		 List plate1 = appleList;
		 Fruit f1 = plate1.get(0);
		 List 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 appleList = new ArrayList<>();
		 appleList.add(new Apple());		 
		 List plate1 = appleList;
		 plate1.add(new Apple()); // 报错!

eclipse里报错信息,显示确实不让添加:

这就很奇怪了,list里全都是Fruit子类吗?那我们向list添加它的子类(Apple)为什么不行?

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

【java】泛型介绍_第3张图片

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

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

【java】泛型介绍_第4张图片

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

	     List 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 Fruit为例,它代表的就是任何Fruit的父类及其Fruit本身(共同的祖先Object)。

【java】泛型介绍_第5张图片

 下界通配符的特点

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

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

		// 定义了一个plate,下界为 
		 List plate = new ArrayList<>();

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

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

 居然报错了?!

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

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

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

【java】泛型介绍_第6张图片

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

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

你可能感兴趣的:(Java,java,泛型)