Java泛型编程与多态、重载的同与不同-阿里云开发者社区

开发者社区> 开发与运维> 正文
登录阅读全文

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

简介: 从字节码看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

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

总结

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

当然,泛型、重载、多态更有其它设计模式的意义,在此不作讨论。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章