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等。
个别会有以下应用标准(或者说是倡议)：

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 等。

人若无名，分心练剑~！