前提
专业术语有时候比较难懂,
胖子觉得,用不严谨的说法,泛型的白话解释就是:
传入的任意对象(注意是对象)
泛型一般有三种:泛型类、泛型接口、泛型方法
泛型类:典型泛型类—ArrayList
public class A<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
//这样可以
A<Integer> a1 = new A();
A<String> a2 = new A();
//这样不行
A<int> a3 = new A();
泛型接口:典型泛型接口—List
public interface IA<T> {
T next();
}
//第一种
public class A<T> implements IA<T> {
@Override
public T next() {
return null;
}
}
//第二种
public class A implements IA<String> {
@Override
public String next() {
return null;
}
}
泛型方法:典型的泛型方法—Objects下的requireNonNull
public static <T> T requireNonNull(T var0) {
if (var0 == null) {
throw new NullPointerException();
} else {
return var0;
}
}
//使用
Integer integer = null;
Objects.requireNonNull(integer);//这里会抛一个NullPointerException
敲黑板
泛型里,最烧脑的,应该属于extends、super了。
说到底,extends、super其实就是用来约束传入的泛型的
比如:
extends
//<T extends 可以多个>,
//规则:
//<T extends 类&接口&接口>,类有且只能有一个,接口可以有多个。有类的情况下,类必须是第一个
public class AClass<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
};
-------
public class BClass{};
public class CClass extends BClass{};
-----
public class DClass{};
-----
public static void print(AClass<? extends BClass> par) {
}
//使用
AClass<CClass> cClass = new AClass();
AClass<BClass> bClass = new AClass();
AClass<DClass> dClass = new AClass();
print(cClass);
print(bClass);
print(dClass);//编译不通过。因为DClass不是BClass的派生类
//接着
AClass<? extends BClass> aClass = new AClass();
BClass bClass1 = new BClass();
CClass cClass1 = new CClass();
aClass.setT(bClass1);//编译不通过。因为set时,编译器只知道set的是BClass的子类,但具体是哪一个子类,编译器是无法知道的。
aClass.setT(cClass1);//编译不通过。
BClass bClass = aClass.getT();//这样可以。因为插入的肯定是BClass的派生类
为什么呢?请了解PECS原则
PECS原则全称"Producer Extends, Consumer Super",即上界生产,下界消费。
通俗点:频繁往外读取内容的,适合用上界Extends
super
public static void main(String[] args) {
AClass<BClass> bClass = new AClass();
AClass<CClass> cClass = new AClass();
print(bClass);
print(cClass);//编译错误。CClass不是BClass的超类
//再来
AClass<? super BClass> bClass = new AClass();
bClass.setT(new CClass());
bClass.setT(new BClass());
bClass.setT(new Object());//这里编译错误。因为如果插入的是BClass的超类,编译器就无法安全的转型为BClass。
Object t = bClass.getT();//可以get,但是返回的是Object。因为编译器没办法知道返回的是什么超类,但是可以确定,肯定是Object的子类
//这里胖子有疑问?
//既然jdk限制不让set超类,那get时,不就可以返回最上级的父类类吗?为什么还是返回Object呢?
//有大神知道,可以告知小弟一下。
//PECS原则全称"Producer Extends, Consumer Super",即上界生产,下界消费。
//经常往里插入的,适合用下界Super
}
public static void print(AClass<? super BClass> par) {
System.out.println(par.getT());
}
最后
AClass<BClass> bClass = new AClass();
AClass<CClass> cClass = new AClass();
bClass和cClass没有什么实质性关系。在编译时,编译器会有一个叫“泛型擦除”,
执行 javap -c -s "路径"
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
Code:
0: new #2 // class com/java/basic/Generic/AClass
3: dup
4: invokespecial #3 // Method com/java/basic/Generic/AClass."<init>":()V
7: astore_1
8: new #2 // class com/java/basic/Generic/AClass
11: dup
12: invokespecial #3 // Method com/java/basic/Generic/AClass."<init>":()V
------
最后会变成:
AClass bClass = new AClass();
AClass cClass = new AClass();
结束
放空自己,重新出发。