Java泛型的理解
泛型类的创建
public class Person<T> {
T hobby;
public T getHobby() {
return hobby;
}
public void setHobby(T hobby) {
this.hobby = hobby;
}
}
泛型接口的创建
// 市场
public interface Market<T> {
T sale();
double refund(T item);
}
泛型的作用
- 帮助检查代码中的类型,提前报错;
- 自动进行类型转换
创建泛型类型的目的
泛型类型的不同实例的具体类型可能会有不同,针对的是实例,因此静态方法不能使用泛型类型的类型参数,也就是那个类名上使用的那个T
泛型的继承
// 批发市场
public interface WholesaleMarket<T> extends Market<T> {
@Override
T sale();
@Override
double refund(T item);
}
具体实现
// 水果批发市场
public class FruitWholesaleMarket implements WholesaleMarket<Fruit> {
@Override
public Fruit sale() {
return null;
}
@Override
public double refund(Fruit item) {
return 0;
}
}
泛型类型参数 <T>
类型参数 <T> 是一个标记符号,代表这个类型内部某个通用的类型
泛型类型参数的上界 <T extends XX>
规定这个类型 <T> 只能是 XX 或 XX 的子类
泛型类型的实例化
其实就是确定 <T> 的实际值
// 左右两边的尖括号都是 ArrayList 的类型参数的实例化
ArrayList<Fruit> fruits = new ArrayList<Fruit>();
// 左边的 T 是 WholesaleMarket 的类型参数的声明,右边的 T 是 Market 的类型参数的实例化
interface WholesaleMarket<T> extends Market<T> {
}
泛型类型实例化的上界 <? extends XX>
只能调用返回值是 泛型类型参数 的方法,不能调用 参数为泛型类型参数 的方法
ArrayList<? extends Fruit> fruits2 = new ArrayList<Apple>();
// 用处
double calcPrice(List<? extends Fruit> fruits) {
double price = 0;
for(Fruit fruit:fruits) {
price += fruit.getPrice();
}
return price;
}
泛型类型实例化的下界 <? super XX>
只能调用参数为 泛型类型参数 的方法,不能调用 返回值是泛型类型参数 的方法
ArrayList<? super Apple> appleList = new ArrayList<Fruit>();
public class Apple implements Fruit {
// 添加到list
public void addToList(List<? super Fruit> list) {
list.add(this);
}
}
由于Java泛型的类型的擦除,所以不允许把一个子类的泛型类型对象 赋值给一个父类的泛型类型引用。泛型类型擦除,不能在第一时间发现错误,从而就在源头就限制。
数组没有类型擦除,所以允许子类数组的对象赋值给父类的数组引用。在操作不同类型数据的时候会第一时间报错。
ArrayList<Apple> apples = new ArrayList<Apple>();
ArrayList<Fruit> fruits = (ArrayList)apples;
fruits.add(new Orange());// 由于泛型类型擦除,这时不会报错
System.out.println("添加橘子成功");
Apple apple = apples.get(0);// 报错
// 数组
Fruit[] fruits = new Apple[10];
fruits[0] = new Orange();// 会报错
泛型方法和类型推断
声明
<E> E method(E item){
return item;
}
// 静态泛型方法
static <E> void method2(){
}
调用
Apple apple = new Apple();
String taste = apple.<String>method("很甜");
// 利用类型推断可以去除尖括号(<String>)
String taste = apple.method("很甜");
泛型方法的实例化
每次泛型方法的调用就是一次对这个泛型方法的实例化。
泛型的意义
泛型的创建者让泛型的使用者在使用的时(实例化时)细化类型信息,从而可以触及到使用者所细化的子类的API.
泛型参数可以是一个方法的返回值类型
T sale();
也可以是放在一个接口的参数里,等着实现类不同的实现
interface Comparable<T>{
int compareTo(T t);
}
class String implements Comparable<String> {
@Override
public int compareTo(String string) {
//...
}
}
类型约束
public <E extends Runnable & Serializable> void method(){
}
Type Parameter 和 Type Argument
Type Parameter 是指 「public interface List<E>」中的 <E> ,表示我要创建一个 List 类,它内部会统一用到一个统一的类型,这个类型姑且称之为 E .
Type Argument 是指「new ArrayList<Fruit>()」中的 <Fruit>,表示那个统一的代号,在这里的类型是 Fruit.
Type Parameter 和 Type Argument:泛型的创建和泛型的实例化。
泛型的类型擦除
运行时,所有的 T 以及尖括号里的东西都会被擦除,List 和 List<String> 以及 List<Integer> 都是一个类型,所有代码中声明的变量或参数或类或接口,在运行是可以通过反射获取到泛型信息,
但是运行时创建的对象,在运行时通过反射也获取不到泛型信息,因为 class 文件中没有,
有个绕弯的方法就是创建一个子类,用这个子类类生成对象,这样由于子类在 class 文件里就有,所以可以通过反射拿到运行时创建的对象的泛型信息,比如 Gson 的 TypeToken 就是使用的这种方式。