Java程序员必备基础：泛型解析
前言
整理了Java泛型的相关知识，算是比较基础的，但愿你们一块儿学习进步。 java
1、什么是Java泛型
Java 泛型（generics）是 JDK 5 中引入的一个新特性，其本质是参数化类型，解决不肯定具体对象类型的问题。其所操做的数据类型被指定为一个参数（type parameter）这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法。面试
泛型类
泛型类（generic class) 就是具备一个或多个类型变量的类。一个泛型类的简单例子以下：编程
//常见的如T、E、K、V等形式的参数经常使用于表示泛型，编译时没法知道它们类型，实例化时须要指定。
public class Pair <K,V>{
private K first;
private V second;
public Pair(K first, V second) {
this.first = first;
this.second = second;
}
public K getFirst() {
return first;
}
public void setFirst(K first) {
this.first = first;
}
public V getSecond() {
return second;
}
public void setSecond(V second) {
this.second = second;
}
public static void main(String[] args) {
// 此处K传入了Integer，V传入String类型
Pair<Integer,String> pairInteger = new Pair<>(1, "第二");
System.out.println("泛型测试，first is " + pairInteger.getFirst()
+ " ,second is " + pairInteger.getSecond());
}
}
复制代码
运行结果以下：数组
泛型测试，first is 1 ,second is 第二
复制代码
泛型接口
泛型也能够应用于接口。安全
public interface Generator<T> {
T next();
}
复制代码
实现类去实现这个接口的时候，能够指定泛型T的具体类型。bash
指定具体类型为Integer的实现类：app
public class NumberGenerator implements Generator<Integer> {
@Override
public Integer next() {
return new Random().nextInt();
}
}
复制代码
指定具体类型为String的实现类：dom
public class StringGenerator implements Generator<String> {
@Override
public String next() {
return "测试泛型接口";
}
}
复制代码
泛型方法
具备一个或多个类型变量的方法，称之为泛型方法。ide
public class GenericMethods {
public <T> void f(T x){
System.out.println(x.getClass().getName());
}
public static void main(String[] args) {
GenericMethods gm = new GenericMethods();
gm.f("字符串");
gm.f(666);
}
}
复制代码
运行结果：post
java.lang.String
java.lang.Integer
复制代码
2、泛型的好处
Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，而且全部的强制转换都是自动和隐式的，提升代码的重用率。
咱们先来看看一个只能持有单个对象的类。
public class Holder1 {
private Automobile a;
public Holder1(Automobile a) {
this.a = a;
}
public Automobile getA() {
return a;
}
}
复制代码
咱们能够发现，这个类的重用性不怎样。要使它持有其余类型的任何对象，在jdk1.5泛型以前，能够把类型设置为Object，以下：
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 holder2 = new Holder2(new Automobile());
//强制转换
Automobile automobile = (Automobile) holder2.getA();
holder2.setA("测试泛型");
String s = (String) holder2.getA();
}
}
复制代码
咱们引入泛型，实现功能那个跟Holder2类一致的Holder3，以下：
public class Holder3<T> {
private T a;
public T getA() {
return a;
}
public void setA(T a) {
this.a = a;
}
public Holder3(T a) {
this.a = a;
}
public static void main(String[] args) {
Holder3<Automobile> holder3 = new Holder3<>(new Automobile());
Automobile automobile = holder3.getA();
}
}
复制代码
所以，泛型的好处很明显了：
- 不用强制转换，所以代码比较简洁；（简洁性）
- 代替Object来表示其余类型对象，与ClassCastException异常划清界限。（安全性）
- 泛型使代码可读性加强。（可读性）
3、泛型通配符
咱们定义泛型时，常常遇见T，E，K，V，？等通配符。本质上这些都是通配符，是编码时一种约定俗成的东西。固然，你换个A-Z中另外一个字母表示没有关系，可是为了可读性，通常有如下定义：
- ？ 表示不肯定的 java 类型
- T (type) 表示具体的一个java类型
- K V (key value) 分别表明java键值中的Key Value
- E (element) 表明Element
为何须要引入通配符呢，咱们先来看一个例子：
class Fruit{
public int getWeigth(){
return 0;
}
}
//Apple是水果Fruit类的子类
class Apple extends Fruit {
public int getWeigth(){
return 5;
}
}
public class GenericTest {
//数组的传参
static int sumWeigth(Fruit[] fruits) {
int weight = 0;
for (Fruit fruit : fruits) {
weight += fruit.getWeigth();
}
return weight;
}
static int sumWeight1(List<? extends Fruit> fruits) {
int weight = 0;
for (Fruit fruit : fruits) {
weight += fruit.getWeigth();
}
return weight;
}
static int sumWeigth2(List<Fruit> fruits){
int weight = 0;
for (Fruit fruit : fruits) {
weight += fruit.getWeigth();
}
return weight;
}
public static void main(String[] args) {
Fruit[] fruits = new Apple[10];
sumWeigth(fruits);
List<Apple> apples = new ArrayList<>();
sumWeight1(apples);
//报错
sumWeigth2(apples);
}
}
复制代码
咱们能够发现，Fruit[]与Apple[]是兼容的。List<Fruit>与List<Apple>不兼容的，集合List是不能协变的，会报错，而List与List<? extends Fruits> 是OK的，这就是通配符的魅力所在。通配符一般分三类：
- 无边界通配符，如List<?>
- 上边界限定通配符,如<? extends E>;
- 下边界通配符，如<? super E>;
?无边界通配符
无边界通配符，它的使用形式是一个单独的问号：List<?>，也就是没有任何限定。
看个例子：
public class GenericTest {
public static void printList(List<?> list) {
for (Object object : list) {
System.out.println(object);
}
}
public static void main(String[] args) {
List<String> list1 = new ArrayList<>();
list1.add("A");
list1.add("B");
List<Integer> list2 = new ArrayList<>();
list2.add(100);
list2.add(666);
//报错，List<?>不能添加任何类型
List<?> list3 = new ArrayList<>();
list3.add(666);
}
}
复制代码
无界通配符(<?>)能够适配任何引用类型，看起来与原生类型等价，但与原生类型仍是有区别，使用 无界通配符则代表在使用泛型 。同时，List<?> list不能够添加任何类型，由于并不知道实际是哪一种类型。可是List list由于持有的是Object类型对象，因此能够add任何类型的对象。
上边界限定通配符 < ? extends E>
使用 <? extends Fruit> 形式的通配符，就是上边界限定通配符。 extends关键字表示这个泛型中的参数必须是 E 或者 E 的子类，请看demo：
class apple extends Fruit{}
static int sumWeight1(List<? extends Fruit> fruits) {
int weight = 0;
for (Fruit fruit : fruits) {
weight += fruit.getWeigth();
}
return weight;
}
public static void main(String[] args) {
List<Apple> apples = new ArrayList<>();
sumWeight1(apples);
}
复制代码
可是，如下这段代码是不可行的：
static int sumWeight1(List<? extends Fruit> fruits){
//报错
fruits.add(new Fruit());
//报错
fruits.add(new Apple());
}
复制代码
- 在
List<Fruit>里只能添加Fruit类对象及其子类对象（如Apple对象，Oragne对象），在List<Apple>里只能添加Apple类和其子类对象。 - 咱们知道
List<Fruit>、List<Apple>等都是List<？ extends Fruit>的子类型。假设一开始传参是List<Fruit> list,两个添加没问题，那若是传来List<Apple> list，添加就失败了，编译器为了保护本身，直接禁用添加功能了。 - 实际上，不能往List<? extends E> 添加任意对象，除了null。
下边界限定通配符 < ? super E>
使用 <? super E> 形式的通配符，就是下边界限定通配符。 super关键字表示这个泛型中的参数必须是所指定的类型E，或者是此类型的父类型，直至 Object。
public class GenericTest {
private static <T> void test(List<? super T> dst, List<T> src){
for (T t : src) {
dst.add(t);
}
}
public static void main(String[] args) {
List<Apple> apples = new ArrayList<>();
List<Fruit> fruits = new ArrayList<>();
test(fruits, apples);
}
}
复制代码
能够发现，List<? super E>添加是没有问题的，由于子类是能够指向父类的，它添加并不像List<? extends E>会出现安全性问题，因此可行。
4、泛型擦除
什么是类型擦除
什么是Java泛型擦除呢？ 先来看demo：
Class c1 = new ArrayList<Integer>().getClass();
Class c2 = new ArrayList<String>().getClass();
System.out.println(c1 == c2);
/* Output
true
*/
复制代码
ArrayList <Integer> 和ArrayList <String> 很容易被认为是不一样的类型。可是这里输出结果是true，这是由于Java泛型是使用擦除实现的，不论是ArrayList<Integer>() 仍是new ArrayList<String>()，在编译生成的字节码中都不包含泛型中的类型参数，即都擦除成了ArrayList，也就是被擦除成“原生类型”，这就是泛型擦除。
类型擦除底层
Java泛型在编译期完成，它是依赖编译器实现的。其实，编译器主要作了这些工做：
- set()方法的类型检验
- get()处的类型转换，编译器插入了一个checkcast语句，
再看个例子：
public class GenericTest<T> {
private T t;
public T get() {
return t;
}
public void set(T t) {
this.t = t;
}
public static void main(String[] args) {
GenericTest<String> test = new GenericTest<String>();
test.set("jay@huaxiao");
String s = test.get();
System.out.println(s);
}
}
/* Output
jay@huaxiao
*/
复制代码
javap -c GenericTest.class反编译GenericTest类可得
public class generic.GenericTest<T> {
public generic.GenericTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public T get();
Code:
0: aload_0
1: getfield #2 // Field t:Ljava/lang/Object;
4: areturn
public void set(T);
Code:
0: aload_0
1: aload_1
2: putfield #2 // Field t:Ljava/lang/Object;
5: return
public static void main(java.lang.String[]);
Code:
0: new #3 // class generic/GenericTest
3: dup
4: invokespecial #4 // Method "<init>":()V
7: astore_1
8: aload_1
9: ldc #5 // String jay@huaxiao
11: invokevirtual #6 // Method set:(Ljava/lang/Object;)V
14: aload_1
15: invokevirtual #7 // Method get:()Ljava/lang/Object;
18: checkcast #8 // class java/lang/String
21: astore_2
22: getstatic #9 // Field java/lang/System.out:Ljava/io/PrintStream;
25: aload_2
26: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
29: return
}
复制代码
- 看第11，set进去的是原始类型Object（#6）；
- 看第15，get方法得到也是Object类型（#7），说明类型被擦出了。
- 再看第18，它作了一个checkcast操做，是一个String类型，强转。
5、泛型的限制与局限
使用Java泛型须要考虑如下一些约束与限制，其实几乎都跟泛型擦除有关。
不能用基本类型实例化类型化参数
不能用类型参数代替基本类型。所以， 没有 Pair<double>, 只 有Pair<Double>。 固然, 其缘由是类型擦除。擦除以后， Pair 类含有 Object 类型的域， 而 Object 不能存储 double值。
运行时类型查询只适用于原始类型
如，getClass()方法等只返回原始类型，由于JVM根本就不知道泛型这回事，它只知道原始类型。
if(a instanceof Pair<String>) //ERROR,仅测试了a是不是任意类型的一个Pair，会看到编译器ERROR警告
if(a instanceof Pair<T>) //ERROR
Pair<String> p = (Pair<String>) a;//WARNING,仅测试a是不是一个Pair
Pair<String> stringPair = ...;
Pair<Employee> employeePair = ...;
if(stringPair.getClass() == employeePair.getClass()) //会获得true，由于两次调用getClass都将返回Pair.class
复制代码
不能建立参数化类型的数组
不能实例化参数化类型的数组， 例如：
Pair<String>[] table = new Pair<String>[10]; // Error
复制代码
不能实例化类型变量
不能使用像 new T(...)，newT[...] 或 T.class 这样的表达式中的类型变量。例如， 下面的Pair<T> 构造器就是非法的：
public Pair() { first = new T(); second = new T(); } // Error
复制代码
使用泛型接口时，须要避免重复实现同一个接口
interface Swim<T> {}
class Duck implements Swim<Duck> {}
class UglyDuck extends Duck implements Swim<UglyDuck> {}
复制代码
能够消除对受查异常的检查
@SuppressWamings("unchecked")
public static <T extends Throwable〉void throwAs(Throwable e) throws T { throw (T) e; }
复制代码
定义API返回报文时，尽可能使用泛型；
public class Response<T> extends BaseResponse {
private static final long serialVersionUID = -xxx;
private T data;
private String code;
public Response() {
}
public T getData() {
return this.data;
}
public void setData(T data,String code ) {
this.data = data;
this.code = code;
}
}
复制代码
6、Java泛型常见面试题
Java泛型常见几道面试题
- Java中的泛型是什么 ? 使用泛型的好处是什么?（第一，第二小节可答）
- Java的泛型是如何工做的 ? 什么是类型擦除 ? （第四小节可答）
- 什么是泛型中的限定通配符和非限定通配符 ? （第三小节可答）
- List<? extends T>和List <? super T>之间有什么区别 ?（第三小节可答）
- 你了解泛型通配符与上下界吗？（第三小节可答）
参考与感谢
- 《Java编程思想》
- 《Java核心技术》
- 聊一聊-JAVA 泛型中的通配符 T，E，K，V，？
- Java泛型的局限和使用经验
- Java泛型之类型擦除
我的公众号
- 若是你是个爱学习的好孩子，能够关注我公众号，一块儿学习讨论。
- 若是你以为本文有哪些不正确的地方，能够评论，也能够关注我公众号，私聊我，你们一块儿学习进步哈。
相关文章
- 1. 黑马 程序员——Java基础---泛型
- 2. Java程序员必备基础图
- 3. Java程序员必备基础：内部类解析
- 4. 程序员必备的网络基础
- 5. PHP程序员必备基础
- 6. 基础篇：深刻解析JAVA泛型
- 7. Java基础-泛型详解
- 8. Java泛型编程基础
- 9. Java程序员必备：最广泛使用的java库！
- 10. 【Java基础】【泛型】
- 更多相关文章...
- • C# 泛型（Generic） - C#教程
- • Swift 泛型 - Swift 教程
- • Kotlin学习（二）基本类型
- • Java 8 Stream 教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 黑马 程序员——Java基础---泛型
- 2. Java程序员必备基础图
- 3. Java程序员必备基础：内部类解析
- 4. 程序员必备的网络基础
- 5. PHP程序员必备基础
- 6. 基础篇：深刻解析JAVA泛型
- 7. Java基础-泛型详解
- 8. Java泛型编程基础
- 9. Java程序员必备：最广泛使用的java库！
- 10. 【Java基础】【泛型】