1.引言
每个事物都有其存在的原因,每一项技术也都是为了解决某个问题而产生的,因而在学习一项技术之前,我们首先要了解这项技术的产生是为了解决什么问题。
示例:
public class Demo {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(100);
list.add("abc");
list.add(true);
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
String str = (String)o;
System.out.println(str);
}
}
}
这段程序在运行时会报错:java.lang.ClassCastException
这是因为在list中我们依次添加了一个Integer类型,一个String类型和一个布尔类型,而当我们遍历的时候将list中的元素全部当做String类型来处理,因此就产生了类型转换异常,而这种错误在编译时是不会被发现的,只有在运行时才会发现。这就好比你有一个袋子,你可以往里面装任何东西,但真正装了什么只有你自己知道,而别人只有在取东西的时候才知道袋子中具体装了什么。那么能不能提前得知袋子中到底装了什么呢?泛型应运而生。泛型就像一个标签一样贴在袋子上,向别人指明袋子中装了什么东西,而且规定只能向袋子中添加标签所指定的东西。泛型能在编译阶段及时发现错误,大大降低了项目运行时的风险。
下面看看如何使用泛型来解决以上代码出现的问题
public class Demo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(); // 泛型(标签)指定集合(袋子)中为String
list.add("java"); // 往集合(袋子)中添加String元素不会产生错误
list.add(100); // 往集合(袋子)中添加非String元素会报错
}
}
当我们尝试往list中添加Integer类型时会报错,因为泛型指定了list中只能存放String类型,这就保证了集合中元素的唯一性,进而使得错误在编译阶段就能及时发现。
下面将系统地介绍泛型。
2.泛型的定义
JAVA推出泛型以前,程序员可以构建一个元素类型为Object的集合,该集合能够存储任意的数据类型对象,而在使用该集合的过程中,需要程序员明确知道存储每个元素的数据类型,否则很容易引发ClassCastException异常。
为解决这个问题,Java在JDK5中引入了一个新特性即泛型,泛型提供了编译时类型安全监测机制,该机制允许我们在编译时检测到非法的数据类型。泛型的本质就是参数化类型,也就是所操作的数据类型被指定为一个参数。
3.泛型类
3.1 泛型类的定义语法
class 类名称 <泛型标识,泛型标识,...> {
private 泛型标识 变量名;
.....
}
常用的泛型标识:T、E、K、V
看定义可能有点抽象,下面我们来定义一个泛型类
/**
* 泛型类的定义
* @param <T> 泛型标识--类型形参
* 在创建对象的时候指定具体的数据类型
*/
public class Generic<T> {
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
3.2 泛型类的使用语法
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();
Java1.7以后,后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();
下面来具体演示如何使用泛型类,以上方Generic类为例
public class MainClass {
public static void main(String[] args) {
// 在创建泛型类的对象时要指定数据类型(注:不可为基本数据类型,必须为类类型)
// 指定String类型
Generic<String> stringGeneric = new Generic<>("java");
String key1 = stringGeneric.getKey();
System.out.println(key1);
System.out.println("--------------------------------");
// 指定Integer类型
Generic<Integer> integerGeneric = new Generic<>(100);
int key2 = integerGeneric.getKey();
System.out.println(key2);
System.out.println("--------------------------------");
// 泛型类在创建对象的时候如果不指定类型,将按照Object类型来操作
Generic generic = new Generic(new Object());
Object key3 = generic.getKey();
System.out.println(key3);
// 泛型类不支持基本类型
//Generic<int> generic1 = new Generic<>(); // 此时会报错
// 同一泛型类,根据不同的数据类型创建的对象,本质上是同一类型。
System.out.println("--------------------------------");
System.out.println(stringGeneric.getClass());
System.out.println(integerGeneric.getClass());
System.out.println(stringGeneric.getClass() == integerGeneric.getClass());
}
}
程序运行结果:
java
--------------------------------
100
--------------------------------
java.lang.Object@1b6d3586
--------------------------------
class Generic
class Generic
true
3.3 泛型类注意事项
- 泛型类,如果没有指定具体的数据类型,此时,操作类型是Object
- 泛型的类型参数只能是类类型,不能是基本数据类型
- 泛型类型在逻辑上可以看成是多个不同的类型,但实际上都是相同类型
3.4 从泛型类派生子类
- 子类也是泛型类,子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
- 子类不是泛型类,父类要明确泛型的数据类型
class ChildGeneric extends Generic<String>
4.泛型接口
4.1 泛型接口的定义语法
interface 接口名称 <泛型标识, 泛型标识, ...> {
泛型标识 方法名();
.....
}
4.2 泛型接口的使用
- 实现类也是泛型类,实现类和接口的泛型类型要一致
/**
* 泛型接口
* @param <T>
*/
public interface Generator<T> {
T getKey();
}
/**
* 泛型接口的实现类,是一个泛型类,
* 那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
* @param <T>
* @param <E>
*/
public class Pair<T,E> implements Generator<T> {
private T key;
private E value;
public Pair(T key, E value) {
this.key = key;
this.value = value;
}
@Override
public T getKey() {
return key;
}
public E getValue() {
return value;
}
}
- 实现类不是泛型类,接口要明确数据类型
/**
* 实现泛型接口的类,不是泛型类,需要明确实现泛型接口的数据类型。
*/
public class Apple implements Generator<String> {
@Override
public String getKey() {
return "hello generic";
}
}
5.泛型方法
5.1 用法
泛型方法是在调用方法的时候指明泛型的具体类型。
5.2 语法
修饰符 <T, E, ...> 返回值类型 方法名(形参列表) {
方法体...
}
5.3 注意事项
- public与返回值中间非常重要,可以理解为声明此方法为泛型方法。
- 只有声明了的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
- < T >表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
- 与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。
5.4 泛型方法与可变参数
public <E> void print(E... e){
for (E e1 : e) {
System.out.println(e);
}
}
5.5 泛型方法总结
- 泛型方法能使方法独立于类而产生变化
- 如果static方法要使用泛型能力,就必须使其成为泛型方法
/**
* 静态的泛型方法,采用多个泛型类型
* @param t
* @param e
* @param k
* @param <T>
* @param <E>
* @param <K>
*/
public static <T,E,K> void printType(T t, E e, K k) {
System.out.println(t + "\t" + t.getClass().getSimpleName());
System.out.println(e + "\t" + e.getClass().getSimpleName());
System.out.println(k + "\t" + k.getClass().getSimpleName());
}
6.类型通配符
引例:
class Box<E> {
private E content;
public E getContent() {
return content;
}
public void setContent(E content) {
this.content = content;
}
}
public class Demo2 {
public static void main(String[] args) {
Box<Number> box1 = new Box<>();
box1.setContent(100);
Demo2.showBox(box1);
Box<Integer> box2 = new Box<>();
box2.setContent(100);
Demo2.showBox(box2);
}
public static void showBox(Box<Number> box) {
Number content = box.getContent();
System.out.println(content);
}
}
此时语句Demo2.showBox(box2)会报错,这是因为showBox方法中要求传入一个Number类型的Box对象,而对象box2中的类型为Integer,也许很多人会习惯性的认为因为Integer是Number的子类,按照多态的思想应该可以正常接收,但其实这在泛型中是不允许的。为解决这个问题就引入了类型通配符(?)。
6.1 什么是类型通配符
- 类型通配符一般是使用"?"代替具体的类型实参。
- 所以,类型通配符是类型实参,而不是类型形参。
6.2 类型通配符的上限
- 语法:
类/接口<? extends 实参类型>
要求该泛型的类型,只能是实参类型,或实参类型的子类类型。
举例:
public static void showBox(Box<? extends Number> box) {
Number content = box.getContent();
System.out.println(content);
}
6.3 类型通配符的下限
- 语法:
类/接口<? super 实参类型>
要求该泛型的类型,只能是实参类型,或实参类型的父类类型。
举例:
public static void showBox(Box<? super Integer> box) {
Number content = box.getContent();
System.out.println(content);
}
7.类型擦除
7.1 概念
泛型是 Java 1.5 版本才引进的概念,在这之前是没有泛型的概念的,但显然,泛型代码能够很好地和之前版本的代码很好地兼容。
这是因为,泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,专业术语叫做类型擦除。
下面举一个简单的例子:
ArrayList<String> list1 = new ArrayList<String>();
ArrayList<Integer> list2 = new ArrayList<Integer>();
System.out.println(list1.getClass() == list2.getClass());
打印的结果为 true 是因为 List<String>
和 List<Integer>
在 jvm 中的 Class 都是 List.class。
泛型信息被擦除了。
7.2 分类
- 无限制类型擦除
- 有限制类型擦除
- 擦除方法中类型定义的参数
- 桥接方法