Java泛型的理解

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);
}

泛型的作用

1. 帮助检查代码中的类型，提前报错；
2. 自动进行类型转换

创建泛型类型的目的

泛型类型的不同实例的具体类型可能会有不同，针对的是实例，因此静态方法不能使用泛型类型的类型参数，也就是那个类名上使用的那个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 就是使用的这种方式。