泛型, 先睹为快

  • 泛型的由来
  • 泛型并非无所不能
  • 泛型的编写规则
  • 类型变量的限定
  • 泛型类的继承关系
  • 通配符?
  • 泛型的其他约束
  •  

    正文

    我的博客即将入驻“云栖社区”,诚邀技术同仁一同入驻。

    参考书籍

    《Java核心技术:卷1》

    泛型, 先睹为快

    先通过一个简单的例子说明下Java中泛型的用法:

    泛型的基本形式类似于模板, 通过一个类型参数T, 你可以"私人定制"一个类,具体定制的范围包括实例变量的类型返回值的类型传入参数的类型

    Foo.java

    复制代码
    public class Foo <T> {
      // 约定实例变量的类型
      private T data;
      // 约定返回值的类型
      public T getData () {
        return this.data;
      }
      // 约定传入参数的类型
      public void setData (T data) {
        this.data = data;
      }
    }
    复制代码

     

    Test.java

    public class Test {
      public static void main (String args[]) {
        Foo<String> s = new Foo<String> ();
      }
    }

     

    泛型的由来

    泛型设计源于我们的编写类时的一个刚需:想让我们编写的处理类能够更加"通用", 而不是只能处理某些特定的对象或场景。或者说:我们希望我们的类能实现尽可能多的复用。举个栗子:一般来说,你并不想要编写多个分别处理不同数据类型,但内在逻辑代码却完全一样的类。因为这些处理类可能除了数据类型变换了一下外,所有代码都完全一致。“只要写一个模板类就OK了嘛~ 等要使用的时候再传入具体的类型,多省心”, 当你这么思考的时候:浮现在你脑海里的,就是泛型程序设计(Generic pogramming)的思想

    在介绍Java的泛型机制之前, 先让我们来看看, 还没加入泛型机制的“泛型程序设计”是怎样子的

    泛型程序设计1.0: 不用Java泛型机制

    下面我们编写一个存储不同的对象的列表类,列表有设置(set)和取值(get)两种操作。
    假设这个列表类为ObjArray,同时尝试存储的值为String类型,则:
    1.在ObjArray类里我们维护一个数组arr, 为了将来能容纳不同的对象, 将对象设为Object类型(所有对象的父类)
    2.在实例化ObjArray后, 通过调用set方法将String存入Object类型的数组中; 而在调用get方法时, 要对取得的值做强制类型转换—从Object类型转为String类型


    ObjArray.java:

    复制代码
    public class ObjArray  {
      private Object [] arr;
      public ObjArray(int n) {
        this.arr = new Object[n];
      }
      public void set (int i, Object o) {
        this.arr[i] = o;
      }
      public Object get (int i) {
        return this.arr[i];
      }
    }
    复制代码

     


    Test.java:

    复制代码
    /**
     * @description: 测试代码
     */
    public class Test {
      public static void main (String args[]) {
        ObjArray arr = new ObjArray(3);
        arr.set(0, "彭湖湾");
        // get操作时要做强制类型转换
        String n =(String)arr.get(0);
        // 输出 "彭湖湾"
        System.out.print(n);
      }
    }
    复制代码

     

     

     

    如果不使用泛型机制,但又想要实现泛型程序设计,就会编写出类似这样的代码。

    泛型程序设计2.0: 使用Java泛型机制

    让我们来看看使用泛型机制改进后的结果。
    看起来大约是这样:


    GenericArray.java

    复制代码
    public class GenericArray<T>  {
      public void set (int i, T o) {
        // ...
      }
      public T get (int i) {
        // ...
      }
    }
    复制代码

     【具体代码下面给出】

     

    Test.java:

    复制代码
    public class Test {
      public static void main (String args[]) {
        GenericArray<String> arr = new <String>GenericArray(3);
        arr.set(0, "彭湖湾");
        // 不用做强制类型转换啦~~
        String s =arr.get(0);
        // 输出: 彭湖湾
        System.out.print(s);
      }
    }
    复制代码

     

    我们发现,改进后的设计有以下几点好处:

    1. 规范、简化了编码: 我们不用在每次get操作时候都要做强制类型转换了
    2. 良好的可读性:GenericArray<String> arr这一声明能清晰地看出GenericArray中存储的数据类型
    3. 安全性:使用了泛型机制后,编译器能在set操作中检测传入的参数是否为T类型, 同时检测get操作中返回值是否为T类型,如果不通过则编译报错

    泛型并非无所不能

    了解到了泛型的这些特性后, 也许你会迫不及待地想要在ObjArray类里大干一场。
    例如像下面这样, 用类型参数T去直接实例化一个对象, 或者是实例化一个泛型数组

    可惜的是 ......

    public class GenericArray<T>  {
      private T obj = new T (); // 编译报错
      private T [] arr = new T[3]; // 编译报错
      // ...
    }

     

    没错, 泛型并不是无所不能的, 相反, 它的作用机制受到种种条框的限制。

    这里先列举泛型机制的两个限制:

    1.不能实例化类型变量, 如T obj = new T ();

    2. 不能实例化泛型数组,如T [] arr = new T[3];

    【注意】这里不合法仅仅指实例化操作(new), 声明是允许的, 例如T [] arr

     

    我们现在来继续看看上面泛型设计中, GenericArray类的那部分代码:

    复制代码
    public class GenericArray<T>  {
      private Object [] arr;
      public GenericArray(int n) {
        this.arr = new Object[n];
      }
      public void set (int i, T o) {
        this.arr[i] = o;
      }
      public T get (int i) {
        return (T)this.arr[i];
      }
    }
    复制代码

     

     

    没错, 在ObjArray类内部我们仍然还是用到了强制转型。看到这里也许令人有那么一点点的小失望, 毕竟还是没有完全跳出
    初始的泛型设计的边界。 但是, 泛型的优点仍然是显而易见的, 只不过要知道的是:它并没有无所不能的魔法, 并受到诸多限制。

     

    泛型的编写规则

    1.泛型类和泛型方法的定义

    泛型类
    如前面所说,可以像下面一样定义一个泛型类
    类型变量T放在类名的后面

    复制代码
    public class Foo <T> {
      // 约定实例变量的类型
      private T data;
      // 约定返回值的类型
      public T getData () {
        return this.data;
      }
      // 约定传入参数的类型
      public void setData (T data) {
        this.data = data;
      }
    }
    复制代码

     

    泛型方法
    也可以定义一个泛型方法:

    泛型变量T放在修饰符(这里是public static)的后面, 返回类型的前面

    public class Foo {
      public static <T> T getSelf (T a) {
        return a;
      }
    }

     

    泛型方法可以定义在泛型类当中,也可以定义在一个普通类当中

    2.可以使用多个类型变量

    public class Foo<T, U> {
      private T a;
      private U b;
    }

     

    【注意】在Java库中,常使用E表示集合的元素类型, K和V分别表示关键字和值的类型, T(U,S)表示任意类型

    3.JavaSE7以后,在实例化一个泛型类对象时,构造函数中可以省略泛型类型

    ObjArray<Node> arr = new <Node>ObjArray();


    可简写成:

    ObjArray<Node> arr = new <>ObjArray();

     

    类型变量的限定

    当我们实例化泛型类的时候, 我们一般会传入一个可靠的类型值给类型变量T。 但有的时候,被定义的泛型类作为接收方,也需要对传入的类型变量T的值做一些限定和约束,例如要求它必须是某个超类的子类,或者必须实现了某个接口, 这个时候我们就要使用extends关键字了。如:

    超类SuperClass:

    public class SuperClass {
    }


    子类SubClass:

    public class SubClass extends SuperClass {
    }

     

    对T使用超类类型限定:要求父类必须为SuperClass

    public class Foo<T extends SuperClass> {
    }


    测试:

    复制代码
    public class Test {
      public static void main (String args[]) {
        Foo<SubClass> f = new Foo<SubClass>(); // 通过
        Foo<String> n = new Foo<String>(); // 报错
      }
    }
    复制代码

     

    extends使用的具体规则

    1. 对于要求实现接口, 或者继承自某个父类, 统一使用extends关键字 (没有使用implements关键字,为了追求简单)

    2. 限定类型之间用 "&" 分隔

    3. 如果限定类型既有超类也有接口,则:超类限定名必须放在前面,且至多只能有一个(接口可以有多个)


    这个书写规范和类的继承和接口的实现所遵循的规则是一致的(<1>不允许类多继承,但允许接口多继承<2>书写类的时候类的继承是写在接口实现前面的)

    // 传入的T必须是SuperClass的子类,且实现了Comparable接口
    public class Foo<T extends SuperClass&Comparable> {
    }

    【注意】: 上面的SuperClass和Comparable不能颠倒顺序

     

    泛型类的继承关系

    泛型类型的引入引发了一些关于泛型对象继承关系的有趣(?)问题。

    在Java中, 如果两个类是父类和子类的关系,那么子类的实例也都是父类的实例,这意味着:
    一个子类的实例可以赋给一个超类的变量:

    SubClass sub = new SubClass();
    SuperClass sup = sub;

     

    当引入了泛型以后, 有趣(?)的问题来了:

     

    我们通过两对父子类List/ArrayList, Employee/Manager来说明这个问题

    (我们已经知道List是ArrayList的父类(抽象类),这里假设Employee是Manager的父类)
    1. ArrayList<Employee> 和 ArrayList<Manager>之间有继承关系吗?(ArrayList<Manager>的实例能否赋给ArrayList<Employee>变量?)
    2. List<Employee> 和 ArrayList<Employee>之间有继承关系吗?(ArrayList<Employee>的实例能否赋给 List<Employee>变量?)
    3. ArrayList和ArrayList<Employee>之间有继承关系吗?(ArrayList<Employee>的实例能否赋给ArrayList变量?)

    答案如下:

    对1: 没有继承关系; 不能

    ArrayList<Manager> ae = new ArrayList<Manager>();
    ArrayList<Employee> am = ae; // 报错


    对2: 有继承关系; 可以

    ArrayList<Employee> al = new ArrayList<>();
    List<Employee> l = al; // 通过


    对3: 有继承关系; 可以

    ArrayList<Employee> ae = new ArrayList<>();
    ArrayList a = ae;

     

    下面用三幅图描述上述关系:

     


    描述下1,2的关系

    对上面三点做个总结:
    1. 类名相同,但类型变量T不同的两个泛型类没有什么联系,当然也没有继承关系(ArrayList<Manager>和ArrayList<Employee>)
    2. 类型变量T相同,同时本来就是父子关系的两个类, 作为泛型类依然保持继承关系 (ArrayList<Employee>和List<Employee>)
    3. 某个类的原始类型,和其对应的泛型类可以看作有“继承关系”(ArrayList和ArrayList<Employee>)

    引用一幅不太清晰的图

     

    通配符?

    泛型继承关系带来的问题 — 类型匹配的苦恼

    问题出现在上面所述规范中的第二点:ArrayList<Manager> 和 ArrayList<Employee>之间没有继承关系。
    这意味着,如果你像下面一样编写一个处理ArrayList<Employee>的方法

    public class Foo {
      public static void handleArr (ArrayList<Employee> ae) {
        // ...
      }
    }


    你将无法用它来处理ArrayList<Manager>:

    public static void main (String args[]) {
        ArrayList<Manager> am = new ArrayList<Manager>();
        Foo.handleArr(am); // 报错,类型不匹配
    }

     

     

     现在我们想要:“handleArr方法不仅仅能处理ArrayList<Employee>, 而且还能处理ArrayList<X> (这里X代表Employee和它子类的集合)”。于是这时候通配符?就出现了:ArrayList<? extends Employee>能够匹配ArrayList<Manager>, 因为ArrayList<? extends Employee>是 ArrayList的父类

    现在我们的例子变成了:

    复制代码
    public class Foo {
      public static void handleArr (ArrayList<? extends Employee> ae) {
        // ...
      }
    }
    public static void main (String args[]) {
        ArrayList<Manager> am = new ArrayList<Manager>();
        Foo.handleArr(am); // 可以运行啦!
      }
    复制代码

     

    通配符和super关键字

    ?统配不仅可以用于匹配子类型, 还能用于匹配父类型:

    <? super Manager>

     

    泛型的其他约束

    上面我们介绍了泛型的一些约束,例如不能直接实例化实例化类型变量和泛型数组,这里和其他约束一起做个总结:

    在定义泛型类时不能做的事:


    1. 不能实例化类型变量

    T obj = new T (); // 报错, 提示: Type parameter 'T' cannot be instantiated directly

     

    解决方案:
    如果实在要创建一个泛型对象的话, 可以使用反射:

    复制代码
    public class GenericObj<T> {
      private T obj;
      public GenericObj(Class<T> c){
          try {
            obj = c.newInstance(); // 利用反射创建实例
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
    }
    复制代码

     

    复制代码
    /**
     * @description: 测试代码
     */
    public class Test {
      public static void main (String args[]) {
        // 通过
        GenericObj<String> go = new GenericObj<> (String.class);
      }
    }
    复制代码


    因为Class类本身就是泛型, 而String.class是Class<T>的实例,


    2. 不能实例化泛型数组,如T [] arr = new T[3];

    private T [] arr = new T[3]; // 报错, 提示: Type parameter 'T' cannot be instantiated directly

     

    解决方法一:

    上文所提到的,创建Object类型的数组,然后获取时转型为T类型:

    复制代码
    public class GenericArray<T>  {
      private Object [] arr;
      public GenericArray(int n) {
        this.arr = new Object[n];
      }
      public void set (int i, T o) {
        this.arr[i] = o;
      }
      public T get (int i) {
        return (T)this.arr[i];
      }
    }
    复制代码

     

    解决方法二: 利用反射
    这里使用反射机制中的Array.newInstance方法创建泛型数组

    GenericArray.java

    复制代码
    public class GenericArray<T> {
      private T [] arr;
      public GenericArray(Class<T> type, int n) {
        arr = (T[])Array.newInstance(type, n); // 利用反射创建泛型类型的数组
      }
      public void set (int i, T o) {
        this.arr[i] = o;
      }
      public T get (int i) {
        return (T)this.arr[i];
      }
    }
    复制代码

     

    Test.java

    复制代码
    /**
     * @description: 测试代码
     */
    public class Test {
      public static void main (String args[]) {
      GenericArray<String> genericArr = new GenericArray<>(String.class, 5);
      genericArr.set(0, "penghuwan");
      System.out.println(genericArr.get(0)); // 输出 "penghuwan"
      }
    }
    复制代码

     

    3. 不能在泛型类的静态上下文中使用类型变量

    复制代码
    public class Foo<T> {
      private static T t;
      public static T get () { // 报错, 提示: 'Foo.this' can not be referenced from a static context
        return T;
      }
    }
    复制代码

     


    注意这里说的是泛型类的情况下。如果是在一个静态泛型方法中是可以使用类型变量的

    public class Foo {
      public static<T> T get (T t) { // 通过
        return t;
      }
    }


    (这里的泛型方法处在一个非泛型类中)

    4. 不能抛出或者捕获泛型类的实例

    不能抛出或者捕获泛型类的实例:

    // 报错 提示:Generic class may not extend java.lang.throwable
    public class Problem<T> extends Exception {
    }

     

    甚至扩展Throwable也是不合法的

    复制代码
    public class Foo {
      public static  <T extends Throwable> void doWork () {
        try {
          // 报错 提示: Cannot catch type parameters
        }catch (T t) {
        }
      }
    }
    复制代码

     

    但在异常规范中使用泛型变量是允许的

    复制代码
    // 能通过
    public class Foo {
      public static  <T extends Throwable> void doWork  (T t) throws T {
        try {
          // ...
        }catch (Throwable realCause) {
          throw  t;
        }
      }
    }
    复制代码

     

    在使用泛型类时不能做的事

    1. 不能使用基本类型的值作为类型变量的值

    Foo<int> node = new Foo<int> (); // 非法

     

    应该选用这些基本类型对应的包装类型

    Foo<Integer> node = new Foo<Integer> ();

     


    2. 不能创建泛型类的数组

    public static void main (String args[]) {
        Foo<Node> [] f =new Foo<Node> [6]; // 报错
    }

     

    解决方法:
    可以声明通配类型的数组, 然后做强制转换

    Foo<Node> [] f =(Foo<Node> [])new Foo<?> [6]; // 通过

     

     

    点赞(0)

    评论列表 共有 0 条评论

    暂无评论
    立即
    投稿
    发表
    评论
    返回
    顶部