Java基础知识18-泛型


什么是泛型

就本质而言, 术语"泛型"的意思是参数化类型. 参数化类型很重要, 因为使用该特性创建的类, 接口以及方法, 可以作为参数指定所操作数据的类型.

一个简单的泛型示例

class Gen<T> {
    T ob;

    Gen(T o) {
        this.ob = o;
    }

    T getOb() {
        return this.ob;
    }

    void showType() {
        System.out.println("Type of T is " + this.ob.getClass().getName());
    }
}

public class GenDemo {
    public static void main(String[] args) {
        Gen<Integer> iOb = new Gen<Integer>(88);
        iOb.showType();

        int v = iOb.getOb();
        System.out.println("value: " + v);

        System.out.println();

        Gen<String> strOb = new Gen<>("Generics Test");
        strOb.showType();

        String str = strOb.getOb();
        System.out.println("value: " + str );
    }
}

下面详细分析该程序.
首先, 注意下面这行代码声明泛型类 Gen 的方式:

class Gen<T> {

其中, T 是类型参数的名称. 这个名称是实际类型的占位符, 当创建对象时, 将实际类型传递给 Gen. 因此在 Gen 中, 只需要类型参数, 就是用 T.

注意 T 被包含在<>中, 只要是声明类型参数, 就需要在尖括号中指定, 因为 Gen 使用类型参数, 所以 Gen 是泛型类, 也成为参数化类型.

接下来使用 T 声明 ob, 如下所示:

T ob;

前面解释过, T 是将在创建 Gen 对象时指定的实际类型的占位符. 因此, ob 是传递给 T 的那种实际类型的对象. 例如, 如果将String 传递给 T , ob 将是String 类型.

现在分析 Gen 的构造函数:

    Gen(T o) {
        this.ob = o;
    }

注意参数 o 的类型是 T, 这意味着 o 的实际类型取决于创建 Gen 对象时传递给 T 的类型. 此外, 因为参数 o 和成员变量 ob 的类型都是T, 所以在创建 Gen 对象时, 它们将具有相同的类型.

还可以使用类型参数 T 指定方法的返回类型, 就像 getOb() 方法那样, 如下所示:

    T getOb() {
        return this.ob;
    }

因为 ob 也是T类型, 所以 ob 的类型和 getOb() 方法指定的返回类型是兼容的.

showType() 方法通过对 Class 对象调用 getName() 方法显式 T 的类型, 而这个 Class 对象是通过对 ob 调用 getClass() 方法返回的.

GenDemo 类演示了泛型化的 Gen 类. 它首先创建整形版本的 Gen类, 如下所示:

Gen<Integer> iOb

请仔细分析这个声明. 首先, 注意类型 Integer 是在 Gen 后面的尖括号中指定. 在此, Integer 是传递给 Gen 的类型参数. 对T 的所有引用都被转化为对 Integer 的引用. 因此对于这个声明, ob 是 Integer 类型, 并且 getob() 方法的返回类型是 Integer.

该代码将一个引用赋给 iOb:

iOb = new Gen<Integer>(88);

注意在调用 Gen 构造函数时, 仍然指定了类型参数 Integer. 这是必须的, 因为将其赋值的对象类型是 Gen<Integer>. 因此, new 返回的引用必须是 Gen<Integer> 类型.如果不是的话, 就会产生编译错误.

接下来, 程序使用下面这行代码获取 ob 的值:

int v = iOb.getOb();

因为 getob() 方法的返回类型是 T, 当声明 iOb 时 T 已被替换为 Integer 类型, 所以 getob() 方法的返回类型也是 Integer, 当返回值赋值给 v 时会自动拆箱为 int 类型.

接下来, GemDemo 声明了 Gem<String> 类型的对象:

Gen<String> strOb = new Gen<>("Generics Test");

因为类型参数是 String, 所以使用 String 替换 Gen 中的 T,这会创建Gen的String版本, 就像程序中剩余代码所演示的那样.

泛型使用引用类型

当声明泛型类的实例时, 传递过来的参数必须是引用类型. 不能使用基本类型, 如果 int 或 char. 例如, 对 Gen, 可以将任何类型传递给 T, 但是不能将基本类型传递给类型参数T ,所以, 一下声明是非法的.

Gen<int> intOb = new Gen<int>(53);

带两个类型参数的泛型类

class TwoGen<T, V> {
    T ob1;
    V ob2;

    TwoGen (T o1, V o2) {
        this.ob1 = o1;
        this.ob2 = o2;
    }

    void showTypes() {
        System.out.println("Type of T is " + ob1.getClass().getName());
        System.out.println("Type of V is " + ob2.getClass().getName());
    }

    T getOb1() {
        return ob1;
    }

    V getOb2() {
        return ob2;
    }

}


public class SimpGen {
    public static void main(String[] args) {

        TwoGen<Integer, String> tgObj =
                new TwoGen<>(88, "Generics");

        tgObj.showTypes();

        int v = tgObj.getOb1();
        System.out.println("value: " + v);

        String str = tgObj.getOb2();
        System.out.println("value: " + str);
    }
}

注意 TwoGen 的声明方式:

class TwoGen<T, V> {

在此指定了两个类型参数: T 和 V, 使用逗号将他们隔开. 创建对象时必须为 TwoGen 传递两个类型参数, 如下所示:

TwoGen<Integer, String> tgObj =
                new TwoGen<>(88, "Generics");

在此, Integer 替换 T, String 替换 V.
在这个例子中, 尽管两个类型参数是不同的, 但是可以将两个类型参数设置为相同的类型. 例如, 下面这行代码是合法的:

TwoGen<String, String> x=
                new TwoGen<>("A", "B");

在此, T 和 V 都是 String 类型. 当然, 如果类型参数总是相同的, 就不必使用两个类型参数了.

推荐阅读更多精彩内容

  • 简介 泛型的意思就是参数化类型,通过使用参数化类型创建的接口、类、方法,可以指定所操作的数据类型。比如:可以使用参...
    零度沸腾_yjz阅读 2,939评论 1 15
  • Java泛型总结# 泛型是什么## 从本质上讲,泛型就是参数化类型。泛型十分重要,使用该特性可以创建类、接口以及方...
    kylinxiang阅读 486评论 0 1
  • 日子,就像上了梭子的一台织布机,经线里织着日光、星光,纬线里织着生活百味,人在这样的织布机上滚着,终日忙忙碌碌,不...
    九月流云阅读 529评论 15 45
  • 彭小六“梦想领读会”作业·当不了总统,但你可以借鉴一下法国新总统的成长历程! 作者:华小明 9岁的马克龙成为法国历...
    BigQ个人成长阅读 424评论 0 50
  • 文/点苍 01 我二十几岁初入职场,进了一家大型水利单位,到2013年辞职,除去中间停薪留职去广州工作的一年,在同...
    点苍阅读 4,142评论 18 84
  • 1、感恩王老师,感恩王老师教我技巧,让我学习起来少走弯路!谢谢你!感恩你! 2、感恩父亲,谢谢爸爸一早送我去学习!...
    海清_3a07阅读 35评论 0 3