Java 泛型

老衲

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


人若无名,专心练剑~!

阅读 1.1k
29 声望
0 粉丝
0 条评论
29 声望
0 粉丝
宣传栏