泛型使用总结

泛型使用总结

一、泛型的引入

• 泛型这个概念的出现，根本目的是解决在“通用方法”中使用“通用类型”的问题。
• 泛型的本质是参数类型化，也就是将数据类型也指定为一个参数。

1.1、使用Object

​ 如果需要一个存储不同的对象的列表类，必须要应对所有类型的对象，不使用泛型的话，最好的解决办法就是使用Object类型（因为天地万物继承自Object）。

public class GenericDemo {

    private static final Logger LOGGER = LogManager.getLogger(GenericDemo.class);

    private GenericDemo(int n) {
        this.arr = new Object[n];
    }

    private Object[] arr;

    public void set(int i, Object o) {
        this.arr[i] = o;
    }

    public Object get(int i) {
        return this.arr[i];
    }

    public static void main(String[] args) {
        GenericDemo arr = new GenericDemo(3);
        arr.set(0, "泛型");
        // 必须强制类型转换
        String n = (String) arr.get(0);
        LOGGER.info(n);
    }

}

​ 这种做法的缺点是必须做强制类型转换（cast），这种转换要求开发者对实际参数类型可以预知。

​ 而编译器无法对强制类型转换错误进行提示，这种错误必须在运行时才显现出来，属于安全隐患。

1.2、使用泛型

​ 如果使用泛型的话，好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，可以提高代码的重用率。

​ 以下使用泛型来重写：

public class GenericDemo<T> {

    private static final Logger LOGGER = LogManager.getLogger(GenericDemo.class);

    private GenericDemo(int n) {
        this.arr = new Object[n];
    }

    private Object[] arr;

    public void set(int i, T o) {
        this.arr[i] = o;
    }

    @SuppressWarnings("unchecked")
    public T get(int i) {
        return (T) this.arr[i];
    }

    public static void main(String[] args) {
        GenericDemo<String> arr = new GenericDemo<>(3);
        arr.set(0, "泛型");
        String n = arr.get(0);
        LOGGER.info(n);
    }

}

在get方法内部仍然存在强制类类型转换，实际上HashMap、ArrayList内部也同样存在强制类型转换。但是泛型把问题封装了起来，对于使用者来说完全不用关心强制类型转换引发的问题。

1.3、小结

​ 在需要编写可以应用于多种类型的代码时，可以使用泛型编写出更“泛化”的代码，这些代码对于它们能够作用的类型具有更少的限制。

在上例中，泛型起到的作用（好处）：

1. 规范、简化代码: 不用在每次get操作时候都要做强制类型转换
2. 良好的可读性：GenericDemo arr 声明能明确 GenericDemo 中存储的数据类型
3. 安全性（类型安全）：使用了泛型机制后，编译器能在set操作中检测传入的参数是否为T类型，同时检测get操作中返回值是否为T类型，将错误在编译阶段解决掉

泛型对于java做出的做大贡献，就是对于容器类的改进。我们现在常用的容器类，Map、List甚至包括Collection、Iterable这些容器最基础的接口都使用了泛型。

同时注意，泛型只是一个超级好用的语法糖，并不是万能的，只是解决使用 Object 类型时笨拙、安全性差的问题。

二、泛型基础知识

• 泛型分为泛型类、泛型接口和泛型方法

2.1、泛型类

例子中的GenericDemo就是一个泛型类，将表示类型参数的符号放在类名后面，即可在全类中使用该类型：

public class GenericDemo<T>

2.2、 泛型接口

public interface GenericInterface<T>{};

2.3、 泛型方法

可以对一个方法单独进行泛型处理：

public <T> T genericMethod(T v){
//或者
public <U,V> U genericMethod(V v){

• 第二行中 U、V 分别代表方法的返回类型和参数类型，因为有两种，所以使用 <U,V> 进行说明
• 对于泛型类，如果需要使用多种参数的话，可以写成： public class GenericDemo<U,V>
• 泛型方法可以定义在泛型类当中，也可以定义在一个普通类当中

2.4 、 泛型符号的使用习惯

• 常使用E表示集合的元素类型， K和V分别表示关键字和值的类型， T（以及U，S等）表示任意类型

2.5、类型变量的限定

• 有时候，需要对泛型的类型进行一定的限制，比如它必须是某个父类的子类，或者必须实现了某个接口。

2.5.1、extends

1. 对于要求实现接口， 或者继承自某个父类， 统一使用extends关键字 （不使用implements关键字）
2. 限定类型之间用 “&” 分隔
3. 如果限定类型既有超类也有接口，则：父类限定名必须放在前面，且至多只能有一个（接口可以有多个）。这个书写规范和类的继承和接口的实的规则是一致的（不允许类多继承，但允许接口多继承 ； 书写类的时候类的继承是写在接口实现前面的）

使用例（T必须是SuperClass的子类，且实现了Comparable接口）：

public class Foo<T extends SuperClass&Comparable> {}

2.5.2、 super

要求 T 必须是某类型的父类（或者是父类的父类）

2.5.3、 限定类型的好处

一个好处是：限定类型以后，我们可以确定泛型类型必然具有父类中的共通方法。就好像我们可以放心地对所有类型使用 .toSring() 方法，因为这是 Object 类中的方法。

这样就可以对 T类型 使用其父类中存在的方法，只是需要使用反射来实现。

三、类型参数与无界通配符<?>

3-1、区别使用

首先要区分开两种不同的场景：

• 声明一个泛型类或泛型方法。这种情况下要使用类型参数“”
• 使用泛型类或泛型方法。这种情况下要使用无界通配符“<?>”。具体解释，就是对已经存在的泛型，我们不想给她一个具体的类型做为类型参数，我们可以给她一个不确定的类型作为参数，（前提是这个泛型必须已经定义）

<?>的作用是保证能在容器类里面放入各种不同类型的元素（顺便说，?的英文是wildcard：通配符）。通配符?是不能用来声明泛型的。以下声明直接报错：

public class GenericDemo<?>  // 报错

<?>的使用例：用<?>声明List容器的变量类型，然后用一个实例对象给它赋值。

List<?> list = new ArrayList<String>();

public static void showObj(List<?> list) {
    for (Object object : list) {
        System.out.println(object);
    }
}

小结

List<T> aa = new ArrayList<T>();  // 正确
List<?> aa = new ArrayList<T>();  // 正确
List<?> aa = new ArrayList<?>();  // 报错，ArrayList里面必须是一种确定类型
List<Object> aa = new ArrayList<Object>();  // 正确
List<?> aa = new ArrayList<Object>();  // 正确

四、泛型的使用限制以及部分变通方法

4.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();
      }
    }
}

public class Test {
  public static void main (String args[]) {
    GenericObj<String> go = new GenericObj<> (String.class);
  }
}

4.2、不能实例化泛型数组

如T [] arr = new T[3];// 报错， 提示： Type parameter 'T' cannot be instantiated directly

不过只是单纯声明的话是允许的，例如 T [] arr

解决方法一：创建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方法创建泛型数组

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];
  }
}

public class Test {
  public static void main (String args[]) {
  GenericArray<String> genericArr = new GenericArray<>(String.class, 5);
  genericArr.set(0, "abcdefg");
  System.out.println(genericArr.get(0)); 
  }
}

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

Foo<Node> [] f =(Foo<Node> [])new Foo<?> [3]; 

4.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;
  }
}

原因在于静态变量，不需要创建对象即可调用；而对于泛型类，对象不创建的话无法确定泛型是哪种类型。二者的要求矛盾所以编译禁止通过。

在非泛型类的静态泛型方法中是可以使用类型变量的。

4.4、不能使用基本类型的值作为类型变量的值

Foo<int> node = new Foo<int> (); // 报错  必须使用封装类型