Java泛型编程与多态、重载的同与不同

泛型编程

泛型编程在某些语言中也称之为模板编程，比如C++，所以在泛型编程中见到的那个T也就是Template的首字母。
来看一个泛型编程的简单样例。

public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("Test template");
    System.out.println(foo(sb).toString());
}

public static <T> T foo(T t) {
// bla bla bla
return t;
}

泛型编程与多态

在面向对象的编程中还有一个概念叫多态，利用这种概念，我们可以将泛型编程中的T替换成所有对象的基类Object，这在某种程度上同样能够达到泛型编程所达到的效果，如下方代码所示。

public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("Test template");
    System.out.println(foo(sb).toString());
    System.out.println(foo2(sb).toString());
}

public static <T> T foo(T t) {
// bla bla bla
return t;
}

public static Object foo2(Object o) {
// bla bla bla
return o;
}

那么这两种方法有什么区别吗？

我们来看看字节码的区别。

public class template.Template {
public template.Template();
    Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
    Code:
0: new           #2 // class java/lang/StringBuilder
3: dup
4: ldc           #3 // String Test template
6: invokespecial #4 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
9: astore_1
10: getstatic     #5 // Field java/lang/System.out:Ljava/io/PrintStream;
13: aload_1
14: invokestatic  #6 // Method foo:(Ljava/lang/Object;)Ljava/lang/Object;
17: checkcast     #2 // class java/lang/StringBuilder
20: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
23: invokevirtual #8 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
26: getstatic     #5 // Field java/lang/System.out:Ljava/io/PrintStream;
29: aload_1
30: invokestatic  #9 // Method foo2:(Ljava/lang/Object;)Ljava/lang/Object;
33: invokevirtual #10 // Method java/lang/Object.toString:()Ljava/lang/String;
36: invokevirtual #8 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
39: return

public static <T> T foo(T);
    Code:
0: aload_0
1: areturn

public static java.lang.Object foo2(java.lang.Object);
    Code:
0: aload_0
1: areturn
}

foo方法调用时的字节码

14: invokestatic #6 // Method foo:(Ljava/lang/Object;)Ljava/lang/Object;
17: checkcast #2 // class java/lang/StringBuilder
20: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

foo2方法调用时的字节码

30: invokestatic #9 // Method foo2:(Ljava/lang/Object;)Ljava/lang/Object;
33: invokevirtual #10 // Method java/lang/Object.toString:()Ljava/lang/String;

不难发现，main函数调用使用了泛型编程的foo方法时，其字节码已不再是T，而是替换为实际的StringBuilder类；反观foo2方法使用的还是Object，那它将是在运行时作类型转换。
结论：泛型编程是编译期替换；多态则是运行期作类型转换。

泛型编程与重载

什么是重载

不废话，形如下方代码即重载。

public static int add(int a, int b) {
return a + b; 
}

public static double add(double a, double b) {
return a + b;
}

重载的特点：两个及以上方法名相同；参数个数不同，参数顺序不同、类型不同，以上任一种及以上都可以构成重载。仅返回值不同不可构成重载。

测试的完整代码如下：

public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("Test template");
    System.out.println(foo(sb).toString());
    System.out.println(foo2(sb).toString());
int a = 1;
int b = 2;
    System.out.println(add(a, b));

double x = 1.1;
double y = 1.2;
    System.out.println(add(x, y));
}

public static <T> T foo(T t) {
// bla bla bla
return t;
}

public static Object foo2(Object o) {
// bla bla bla
return o;
}

public static int add(int a, int b) {
return a + b; 
}

public static double add(double a, double b) {
return a + b;
}

接下来看看重载部分的字节码：

48: invokestatic #11 // Method add:(II)I

71: invokestatic #17 // Method add:(DD)D

总结：看来字节码已经做了相应的转换，重载和泛型编程相似，都是在编译期就做了替换，而不是在运行时，因此重载也是类型安全的，但是重载需要为每一种不同的参数类型重新编写代码，代码复用度不高。

总结

泛型编程和重载是在编译期作了类型替换，多态则是在运行期作类型替换。
泛型编程和多态代码复用度高，重载代码复用度低。

秒客网