【从零单排】关于泛型Generic的一些思考

相信很多同学都多多少少听过Generic-泛型这个概念。下面就结合实际的例子对泛型进行讲解和剖析。

为什么要用泛型

泛，有多的意思。型，即为类型。结合起来，就是可以用泛型来指代“多种类型”，从而可以复用函数或类。

举例：写一个echo函数用来输出List种某两个位置的值。

当List里面装的是String，就是这样：

public static void echo_string(List<String> a, int i, int j) {
	String tmp_i = a.get(i);
	String tmp_j = a.get(j);
	System.out.println(tmp_i);
	System.out.println(tmp_j);
}

当List里面装的是Integer，就是这样：

public static void echo_integer(List<Integer> a, int i, int j) {
	int tmp_i = a.get(i);
	int tmp_j = a.get(j);
	System.out.println(tmp_i);
	System.out.println(tmp_j);
}

每次根据List里面值的不同类型，写一个对应的函数，不免有点重复劳动。能不能用一个函数实现呢？这就需要用到泛型。如下：

public static <T> void echo_generic(List<T> a, int i, int j) {
	T tmp_i = a.get(i);
	T tmp_j = a.get(j);
	System.out.println(tmp_i);
	System.out.println(tmp_j);
}

什么地方用泛型

主要有两个地方：

• 创建 - 函数
• 创建 - 类(Class)

函数的例子上面已经举过了，不再赘述。下面就讲讲类。

class SomeList<T>{
    private T param;

    SomeList(T param) {
        this.param = param;
        System.out.println("constructor for SomeList");
    }

    public T getParam() {
        return param;
    }
    public void setParam(T param) {
        this.param = param;
    }
}

SomeList<String> sl1 = new SomeList<>("123");
System.out.println(sl1.getParam());

SomeList<Integer> sl2 = new SomeList<>(123);
System.out.println(sl2.getParam());

在这个例子中，我们定义了一个SomeList类，它可以是String类型的，也可以是Integer类型的，取决于初始化时的传参类型。

泛型的符号

在实际使用过程中，我们常常看到<T>，或者是<K,V>这样的符号，被IDE高亮显示为不同的颜色。如下：

public static <T> List<T> swap(List<T> a, int i, int j) {
	T tmp_i = a.get(i);
	T tmp_j = a.get(j);
	a.set(i, tmp_j);
	a.set(j, tmp_i);
	return a;
}

public static <K,V> V getValue(K key, Map map) {
	return (V) map.get(key);
}

我不禁要问：<T>,<K,V>是Java的保留字符吗？经过一些尝试之后，得出结论：不是的。这里用（几乎）任何的字母都可以。方括号之内可以是一个或多个字符，用来告诉编译器这个是我自定义的type。

比如，上述的代码，可以把T，K，V替换成其它的字母，改写如下：

public static <M> List<M> swap2(List<M> a, int i, int j) {
	M tmp_i = a.get(i);
	M tmp_j = a.get(j);
	a.set(i, tmp_j);
	a.set(j, tmp_i);
	return a;
}

public static <X,Y> Y getValue2(X key, Map map) {
	return (Y) map.get(key);
}

甚至，我们可以定义大于2个的type，比如<X,Y,Z>：

public static <X,Y,Z> Z getValue3(X key, Y key2, Map map1, Map map2) {
	return (Z) (map1.get(key).toString() + map2.get(key2).toString());
}

通配符 Wildcards

关于Wildcards怎么用我思考了很久，结合实际经验，我觉得单独使用Wildcards的情景很少，一般都是使用Bounded Wildcards。

Wildcards

单独使用Wildcards的情景，用Generic也可以实现。如下：

void printCollection1(Collection<?> c) {
      for (Object e : c) {
            System.out.println(e);
      }
}

<T> void printCollection2(Collection<T> c) {
      for (Object e : c) {
            System.out.println(e);
      }
}

唯一的区别就是，用Wildcards的话，理论上传入参数Collection可以是多种不同的类型。但是其实Collection在赋值的时候，是没办法装不同类型的值的。

Collection<?> c = new ArrayList<>();
c.add(1);
// 编译时会报错 add(capture<?>) cannot be applied to (int)

所以个人感觉一般编程不太需要单独用到Wildcards，大多数情况可以用Generic覆盖。

Bounded Wildcards

而Bounded Wildcards，是有确实的用途的，可以给传入参数限制类型。

这里分了两种extends和super：

• （上限） The extends Wildcard Boundary: List<? extends A> means a List of objects that are instances of the class A, or subclasses of A
• （下限） The super Wildcard Boundary: List<? super A> means that the list is typed to either the A class, or a superclass of A.

分析extends，举例来说，之前我们定义了一个echo_generic方法，这个方法里面的传入参数可以是任意类型的List。现在，我们想要写一个类似的函数，但是List的类型只能是Number（Integer，Double等等都算）。如下：

public static void echo_number(List<? extends Number> a, int i, int j) {
	Object tmp_i = a.get(i);
	Object tmp_j = a.get(j);
	System.out.println(tmp_i);
	System.out.println(tmp_j);
}

具体使用的时候，我们可以发现，确实只能传入Number或其subclass类型的List，否则编译时就会报错。

// integer
List<Integer> list_integer = new ArrayList<>();
list_integer.add(1);
list_integer.add(2);
echo_number(list_integer, 0, 1);

// double
List<Double> list_double = new ArrayList<>();
list_double.add(1.1);
list_double.add(2.2);
echo_number(list_integer, 0, 1);

// string - compile error
List<String> list_string = new ArrayList<>();
list_string.add("1");
list_string.add("2");
echo_number(list_string, 0, 1);

编译时的泛型

问：一个ArrayList<String> collection1和一个ArrayList<Integer> collection2，它们的class是一样的吗？如下：

ArrayList<String> collection1 = new ArrayList<String>();
collection1.add("123");

ArrayList<Integer> collection2 = new ArrayList<Integer>();
collection2.add(456);

System.out.println(collection1.getClass() == collection2.getClass());

答案是：是一样的。原因很简单，我们只创建了一个类class ArrayList<T>，collection1和collection2的class都是这个。泛型的作用在于，在编译的时候，会限定集合中的值的类型。collection1中的值只能是String类型的，collection2中的值只能是Integer类型的。

由此，想到一个黑科技，在runtime时，可以往一个ArrayList<String>里面塞Integer吗（即跳过编译过程时的泛型检查）？

答案是：可以的。

try {
	collection1.getClass().getMethod("add", Object.class).invoke(collection1, 789);
} catch (Exception e) {
	e.printStackTrace();
}
System.out.println(String.valueOf(collection1.get(1)));
// 789

但是，这样做，首先是污染了collection1这个object；其次是往往需要在取出值的时候特别注意，正确转换数据类型，否则容易报错。所以并不是一个推荐的常规操作。

链接

• https://docs.oracle.com/javase/tutorial/extra/generics/wildcards.html
• https://www.cnblogs.com/ssh-html/p/10780398.html