前阵子给公司新人培训Java 基础相关的一些点,系统整理了一下泛型相关的知识点。特来分享一下。希望能让一些对泛型不熟悉的同学完全掌握Java 泛型的相关知识点。
开始之前,先给大家来一道测试题。
List<String> strList = new ArrayList<String>(); List<Integer> integerList = new ArrayList<Integer>(); System.out.println(strList.getClass() == integerList.getClass());
请问,上面代码最终结果输出的是什么?熟悉泛型的同学应该能够答出来,而对泛型有所了解,但是了解不深入的同学可能会答错。
泛型概述
泛型的定义和使用
通配符 ?
List<String>
传递给一个接受 List<Object>
参数的方法吗? 最早的“泛型编程”的概念起源于C++的模板类(Template),Java 借鉴了这种模板理念,只是两者的实现方式不同。C++ 会根据模板类生成不同的类,Java 使用的是类型擦除的方式。
Java1.5 发行版本中增加了泛型(Generic)。
-- 《Java 编程思想》
容器就是要存放要使用的对象的地方。数组也是如此,只是相比较的话,容器类更加的灵活,具有更多的功能。所有的程序,在运行的时候都要求你持有一大堆的对象,所以容器类算得上最需要具有重用性的类库之一了。
看下面这个例子,
public class AutoMobile { } /** * 重用性不好的容器类 */ public class Holder1 { private AutoMobile a; public Holder1(AutoMobile a) { this.a = a; } //~~ } /** * 想要在java5 之前实现可重用性的容器类 * @author Richard_yyf * @version 1.0 2019/8/29 */ public class Holder2 { private Object a; public Holder2(Object a) { this.a = a; } public Object getA() { return a; } public void setA(Object a) { this.a = a; } public static void main(String[] args) { Holder2 h2 = new Holder2(new AutoMobile()); AutoMobile a = (AutoMobile) h2.getA(); h2.setA("Not an AutoMobile"); String s = (String) h2.getA(); h2.setA(1); Integer x = (Integer) h2.getA(); } } /** * 通过泛型来实现可重用性 * 泛型的主要目的是指定容器要持有什么类型的对象 * 而且由编译器来保证类型的正确性 * * @author Richard_yyf * @version 1.0 2019/8/29 */ public class Holder3WithGeneric<T> { private T a; public Holder3WithGeneric(T a) { this.a = a; } public T getA() { return a; } public void setA(T a) { this.a = a; } public static void main(String[] args) { Holder3WithGeneric<AutoMobile> h3 = new Holder3WithGeneric<>(new AutoMobile()); // No class cast needed AutoMobile a = h3.getA(); } }
通过上述对比,我们应该可以理解类型参数化具体是什么个意思。
在没有泛型之前,从集合中读取到的每一个对象都需要进行转换。如果有人不小心插入了类型错误的对象,在运行时的转换处理就会出错。这显然是不可忍受的。
泛型的出现,给Java带来了不一样的编程体验。
Holder<AutoMobile>
这个类型显化的效果,程序员能够一目了然猜测出这个容器类持有的数据类型。 泛型按照使用情况可以分为 3 种。
定义格式:
public class 类名 <泛型类型1,...> { ... }
尖括号 <>
中的 字母 被称作是类型参数,用于指代任何类型。我们常看到 <T>
的写法,事实上,T 只是一种习惯性写法,如果你愿意。你可以这样写。
public class Test<Hello> { Hello field1; }
但出于规范和可读性的目的,Java 还是建议我们用单个大写字母来代表类型参数。常见的如:
定义格式:
public <泛型类型> 返回类型 方法名(泛型类型 变量名) { ... }
注意事项:
<T>
中的 T
被称为类型参数,而方法中的 T
被称为参数化类型,它不是运行时真正的参数。 /** * 泛型类与泛型方法的共存现象 * @author Richard_yyf * @version 1.0 2019/8/29 */ public class GenericDemo2<T> { public void testMethod(T t){ System.out.println(t.getClass().getName()); } public <T> T testMethod1(T t){ return t; } public static void main(String[] args) { GenericDemo2<String> t = new GenericDemo2<>(); t.testMethod("generic"); Integer integer = 1; Integer i = t.testMethod1(integer); } }
当然,现实场景下千万不要去作死写出这么难以阅读的代码。
泛型接口和泛型类差不多。
定义格式:
public interface 接口名<泛型类型> { ... }
public interface GenericInterface<T> { void show(T t); } public class GenericInterfaceImpl<String> implements GenericInterface<String>{ @Override public void show(String o) { } }
除了用 <T>
表示泛型外,还有 <?>
这种形式。 ? 被称为通配符。
为什么要引进这个概念呢?先来看下下面的Demo.
public class GenericDemo2 { class Base{} class Sub extends Base{} public void test() { // 继承关系 Sub sub = new Sub(); Base base = sub; List<Sub> lsub = new ArrayList<>(); // 编译器是不会让下面这行代码通过的, // 因为 Sub 是 Base 的子类,不代表 List<Sub>和 List<Base>有继承关系。 List<Base> lbase = lsub; } }
在现实编码中,确实有这样的需求,希望泛型能够处理 某一范围内的数据类型 ,比如某个类和它的子类,对此 Java 引入了通配符这个概念。
通配符有 3 种形式。
<?> <? extends T> <? super T>
<?>
无限定通配符经常与容器类配合使用,它其中的 ? 其实代表的是未知类型,所以涉及到 ? 时的操作,一定与具体类型无关。
// Collection.java public interface Collection<E> extends Iterable<E> { boolean add(E e); } public class GenericDemo3 { /** * 测试 无限定通配符 <?> * @param collection c */ public void testUnBoundedGeneric(Collection<?> collection) { collection.add(123); collection.add("123"); collection.add(new Object()); // 你只能调用 Collection 中与类型无关的方法 collection.iterator().next(); collection.size(); } }
无需关注 Collection 中的真实类型, 因为它是未知的 。所以,你只能调用 Collection 中与类型无关的方法。
有同学可能会想, <?>
既然作用这么渺小,那么为什么还要引用它呢?
个人认为,提高了代码的可读性,程序员看到这段代码时,就能够迅速对此建立极简洁的印象,能够快速推断源码作者的意图。
(用的很少,但是要理解)
为了接下去的说明方便,先定义一下几个类。
class Food {} class Fruit extends Food {} class Apple extends Fruit {} class Banana extends Fruit {} // 容器类 class Plate<T> { private T item; public Plate(T item) { this.item = item; } public T getItem() { return item; } public void setItem(T item) { this.item = item; } }
<?>
代表着类型未知,但是我们的确需要对于类型的描述再精确一点,我们希望在一个范围内确定类别,比如类型 T 及 类型 T 的子类都可以放入这个容器中。
在这个体系中,上限通配符 Plate<? extends Fruit>
覆盖下图中蓝色的区域。
边界让Java不同泛型之间的转换更容易了。但不要忘记,这样的转换也有一定的副作用。那就是容器的部分功能可能失效。
public void testUpperBoundedBoundedGeneric() { Plate<? extends Fruit> p = new Plate<>(new Apple()); // 不能存入任何元素 p.setItem(new Fruit()); // error p.setItem(new Apple()); // error // 读出来的元素需要是 Fruit或者Fruit的基类 Fruit fruit = p.getItem(); Food food = p.getItem(); // Apple apple = p.getItem(); }
原因是编译器只知道容器内是Fruit或者它的派生类,但具体是什么类型不知道。可能是Fruit?可能是Apple?也可能是Banana,RedApple,GreenApple?
相对应的,还有下限通配符 <? super T>
对应刚才那个例子, Plate<? super Fruit>
覆盖下图中红色的区域。
public void testLowerBoundedBoundedGeneric() { // Plate<? super Fruit> p = new Plate<>(new Food()); Plate<? super Fruit> p = new Plate<>(new Fruit()); // 存入元素正常 p.setItem(new Fruit()); p.setItem(new Apple()); // 读取出来的东西,只能放在Object中 Apple apple = p.getItem(); // error Object o = p.getItem(); }
因为下界规定了元素的最小粒度的下限,实际上是放松了容器元素的类型控制。既然元素是Fruit的基类,往里面存比Fruit粒度小的类都可以。但是往外读取的话就费劲了,只有所有类的基类Object可以装下。但这样一来元素类型信息就都丢失了。
泛型是 Java 1.5 版本才引进的概念,在这之前是没有泛型的概念的,但显然,泛型代码能够很好地和之前版本的代码很好地兼容。
这是因为, 泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉
List<String> strList = new ArrayList<String>(); List<Integer> integerList = new ArrayList<Integer>(); System.out.println(strList.getClass() == integerList.getClass());
==== output ===== true =================
打印的结果为 true 是因为 List<String>
和 List<Integer>
在 jvm 中的 Class 都是 List.class。
泛型信息被擦除了。
/** * 类型擦除 相关类 * * @author Richard_yyf * @version 1.0 2019/8/29 */ public class EraseHolder<T> { T data; public EraseHolder(T data) { this.data = data; } public static void main(String[] args) { EraseHolder<String> holder = new EraseHolder<>("hello"); Class clazz = holder.getClass(); System.out.println("erasure class is:" + clazz.getName()); Field[] fs = clazz.getDeclaredFields(); for ( Field f:fs) { // 那我们可不可以说,泛型类被类型擦除后,相应的类型就被替换成 Object 类型呢? System.out.println("Field name "+f.getName()+" type:"+f.getType().getName()); } EraseHolder2<String> holder2 = new EraseHolder2<>("hello"); clazz = holder2.getClass(); fs = clazz.getDeclaredFields(); for ( Field f:fs) { System.out.println("Field name "+f.getName()+" type:"+f.getType().getName()); } } static class EraseHolder2<T extends String> { T data; public EraseHolder2(T data) { this.data = data; } } }
利用类型擦除的原理,用反射的手段就绕过了正常开发中编译器不允许的操作限制。
public class EraseReflectDemo { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(23); // can't add here // 因为泛型的限制 boolean add(E e); list.add("123"); // error // 利用反射可以绕过编译器去调用add方法 // 又因为类型擦除时 boolean add(E e); 等同于 boolean add(Object e); try { Method method = list.getClass().getDeclaredMethod("add", Object.class); method.invoke(list, "test"); method.invoke(list, 42.9f); } catch (Exception e) { e.printStackTrace(); } for (Object o : list) { System.out.println(o); } } }
==== output ===== 23 test 42.9 =================