Java 泛型

为什么要用泛型？

我们先来看这么一个场景，我们来定义一个 Point 类，这是一个坐标点，其中有 x, y 两个成员变量，代码如下：

class Point {
    int x;
    int y;

    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
}

对于这样的一类，我们创建该方法的时候，那么我就可以这样创建：

public static void main(String[] args) {
    Point p1 = new Point(1, 2);
    Point p2 = new Point(1, 2);
}

好了。现在有这么一个需求，对于某些点测量值有时候会有小数位，但是也会有 int 类型的点。所以需要重新增加 Double 类型的数据。这是小问题，我们把 Point 中的数据类型改成 Object 的就行了。

class Point {
    Object x;
    Object y;
}

现在既可以存储整数也可以存放小数值。

public static void main(String[] args) {
    // 存放整数
    Point p1 = new Point();
    p1.x = 1;
    p1.y = 2;
    // 存放小数
    Point1 p2 = new Point1();
    p2.x = 2.1;
    p2.y = 3.1;
}

上面的代码存储已经搞定了，那我们来看下，怎么取值。

在上面的 main() 中, p1 存放的是整数， p2 存放的是浮点数，但是定义的时候都是 Object类型，取值的时候需要强转成为相对应的类型，

public static void main(String[] args) {
    // 存放整数
    Point p1 = new Point();
    p1.x = 1;
    p1.y = 2;
    // 存放小数
    Point1 p2 = new Point1();
    p2.x = 2.1;
    p2.y = 3.1;
    // 取整数
    int x1 = (int)p1.x;
    int y1 = (int)p1.y;
    // 取小数
    double x2 = (double)p2.x;
    double y2 = (double)p2.y;
}

我们发现这样每次都是要对数据进行强转，而且还要是在知道数据类型的前提下，不然一不小心就是 ClassCaseExcepton 类型转换异常的灾难。这样的现象我称之为：薛定谔的转型

• 泛型就是为了解决这样的问题而存在的。

泛型的定义

• 泛型类

泛型的定义格式就是：修饰符 class 类名<泛型> {}, 常见的泛型代表有：T, E, K, V等。
一般会有以下使用规范(或者说是建议)：

参数	使用场景
T(type)	类型，class、参数的类型
E(element)	元素，数组、列表的元素
K(key)	键，关键字
V(value)	值，数值

Point 类可以这样写

class Point<T> {
    T y;
    T x;
}

使用的时候，需要传入泛型的类型，这样在后续的取值时，编译器会自动给你检查类型,无需进行强转，如果类型不匹配会报编译异常，也就是类型不对无法通过编译。

Point<Integer> p1 = new Point<Integer>();
p1.x = 1;
p1.y = 2;
Point<Double> p2 = new Point<Double>();
p1.x = 1.1;
p1.y = 2.2;

// 取整数
int x1 = p1.x;
int y1 = p1.y;
// 取小数
double x2 = p2.x;
double y2 = p2.y;

• 泛型方法

定义格式: <泛型> 修饰符 void 方法名(<泛型> 参数名) {}

举个例子，

<T> void test(T t) {
    System.out.println(t.getClass());
}

如果需要带泛型返回值，格式如下：<泛型> 泛型 方法名(<泛型> 参数名) {return 泛型参数}

static <E> E test3(E name) {
    System.out.println(name.getClass());
    return name;
}

• 通配符 ?

除了泛型常见的几个默认格式(T, E, K, V), 还有通配符 ?, 通配符一般只做声明，不能通过创建对象使用；只能作为方法的参数使用。举个例子：

void test4(List<?> list) {
    System.out.println("通配符");
}

• 通配符的上限

通配符的上限指的是：通配符继承某个类，使用 extends 继承关键字

那么就意味着：传入的参数只能是该通配符继承类下的所有子类包括继承类自己。举个例子：

void test5(List<? extends Number> list) {
    System.out.println("通配符的上限");
}

像上面的 test5() 只能传入 List(自身) 或者 ArrayList(List 的子类)。

• 通配符的下限

有上限就肯定有下限，下限是使用 super 关键字来声明。同时，该参数也只能是自己或者他的父类

void test6(List<? super Number> list) {
    System.out.println("通配符的下限");
}

像上面的 test6() 只能传入 Number(自身) 或者 Number的父类 Object 等。

---

人若无名，专心练剑~！