Fork me on GitHub

java泛型详解(加一点语法糖)

首先请看如下代码:

public class Test{
    public static void main(String str[]) {
      Hashtable h =new Hashtable();
      h.put(1, "String类型");
      int a = (String) h.get(1);
      System.out.println(a);
    }
}
//执行javac Test.java
结果显示:不兼容的类型: String无法转换为int
//1.红色标出的String改为int 2.执行javac Test.java 3.执行 java Test Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer at genetictype.generictype.main(generic1.java:10)

 以上就是强制类型转换可能带来的典型错误,然而这个错误在编译期间无法知道,以至于在运行期间jvm检查后抛出类型转换异常。

 

再看下述代码:

  public class generictype {  
  public static void main(String str[]) {
Hashtable<Integer, String> h = new Hashtable<Integer, String>(); h.put(1, "String类型"); String a= h.get(1); System.out.println(a); } }
//执行结果
string类型

//需要提出的是1.上述由红色标出的String如果改为int,在编译的时候会报错
2.在h.get(1)前面不需要再进行强制类型转换。

综上看来泛型的作用为: 1.就是是在编译的时候检查类型的安全(解决java中强制类型转换可能导致的错误,而不需要jvm加载的时候再抛出一场)  2.提高代码的重用率

 

类型擦除:

类型擦除简单来说就是:编译器编译.java文件时,将类的泛型参数去掉,那么jvm加载字节码文件的时候对泛型不可见,这个过程就称为类型擦除。(后面会从字节码角度分析类型擦除)

与类型擦除有关的现象:

  • 泛型类没有Class的类类型。比如并不存在List<String>.class或是List<Integer>.class,而只有List.class。
  • 静态变量是被泛型类的所有实例所共享的。
public class Test
{
    public static void  main(String str[]){
     Test1<String> t = new Test1<String>();
     Test1<Date> tt = new Test1<Date>();
     System.out.println(t.a);
     System.out.println(tt.a);
    }
}
class Test1<T>{
    static int a = 1;
}
//结果
1
1
  • 泛型的类型参数错误不能通过异常处理,因为异常处理是jvm实现的,而jvm加载的字节码文件已经擦除了泛型特征,这也间接的说明了泛型的意义:在编译期间发现参数类型错误。

类型擦除的基本过程也比较简单:

    1.将类型参数用顶级父类替换,这类一般是Object,如果指定了类型参数的上界的话,则使用这个上界。

    2.去掉出现的类型声明,即去掉<>的内容。

例如:T get()方法声明就变成了Object get();List<String>就变成了List。接下来就可能需要生成一些桥接方法(bridge method)。这是由于擦除了类型之后的类可能缺少某些必须的方法。比如考虑下面的代码:

public class Test{public static void main(String str[]) {
Test3 t
=new Test3(); t.getT("11111"); } } interface Test2<T>{ public T getT(T t); } class Test3 implements Test2<String>{ public String getT(String t){ return t; } } //类型擦除后的代码(从java语言角度) public class Test{ public static void main(String str[]) { Test3 t = new Test3(); t.getT("11111"); } interface Test2 { public Object getT(Object t); } class Test3 implements Test2 { public String getT(String T){ return T } public Object getT(Object t) { return this.getT((String) t); }
//
如果没有这个方法,在类型擦除后Test3没有重写接口Test2的抽象方法,明显错误,因此编译器的巨大作用就是在这里帮忙生成了该方法
}

 

泛型的分类:泛型类,泛型接口,泛型方法,泛型异常

泛型类

public class Test{
    public static void main(String str[]) {
        Test1<Integer, String> t = new Test1<Integer, String>();
        t.put(1, "str1");
        t.put(2, "str2");
        System.out.println(t.get(1));
        System.out.println(t.get(2));
    }
}

class Test<T, V> {
    public Hashtable<T, V> h = new Hashtable<T, V>();

    public void put(T t, V v) {
        h.put(t, v);
    }

    public V get(T t) {
        return h.get(t);
    }
}
//执行结果
str1
str2

多态方法(泛型方法):在函数名前定义泛型参数,可以在传入参数列表,返回值类型,方法体里面引用

public class Test{
public <T> String getString(T obj){
    return obj.toString();
}
    public static void main(String str[]) {
        Test =new Test ();//不需要类的泛型
        System.out.println(g.getString(1));
        System.out.println(g.getString('a'));
        System.out.println(g.getString("a"));
    }
}
//执行结果
1
a
a

泛型异常(兼具泛型接口)

public class Test{
    public static void main(String str[]) {
    TestException t =new TestException();
    try {
        t.excute(2);
    } catch (IOException e) {
        e.printStackTrace();
    }
    }
}
//extends说明该泛型参数继承于Exception
interface TestExceptionInterface<T extends Exception>
{
    public void excute(int i) throws T;
}
class TestException implements TestExceptionInterface<IOException>{
    @Override
    public void excute(int i) throws IOException {
    if(i<10){
        throw new IOException();
    }
    }
}
//意义:1.针对不同的可能出现的异常类型,定义自己的实现类。
2.定义多个实现类的时候,不用一个一个手动throws异常,提高了代码重用率

从字节码角度看泛型

*语法糖

至于什么是语法糖,可以从属于语法糖的那些java特性来探索,有泛型,自动装箱,自动拆箱,for each循环,对于这些java特性应该都不陌生,他们的共有特点是:提供一种新的语法但是对语言的功能没有影响,开发变的更加简便,降低出错的可能性。

 

*解语法糖

语法糖使开发变得简便但是没有改变语言功能,也就是说这是面向编程人员的一种小把戏,在编译阶段仍会还原出本该有的模样,而这个过程就是解语法糖,举几个例子:

***泛型

1.java代码

import java.util.*;
public class Test{
    public void test(){
    HashMap<String,String> map = new HashMap<String,String>();
    map.put("1","1");
    String str = map.get(1);
}
}

2.javac编译+javap反编译后的部分指令码

 public void test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: new           #2                  // class java/util/HashMap
         3: dup
         4: invokespecial #3                  // Method java/util/HashMap."<init>":()V
         7: astore_1
         8: aload_1
         9: ldc           #4                  // String 1
        11: ldc           #4                  // String 1
        13: invokevirtual #5                  // Method java/util/HashMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
        16: pop
        17: aload_1
        18: iconst_1
        19: invokestatic  #6                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        22: invokevirtual #7                  // Method java/util/HashMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
        25: checkcast     #8                  // class java/lang/String
        28: astore_2
        29: return
      LineNumberTable:
        line 4: 0
        line 5: 8
        line 6: 17
        line 7: 29
}

3.将步骤2的指令码等价为java语言

import java.util.*;
public class Test{
    public void test(){
    HashMap map = new HashMap();
    map.put("1","1");
    String str = (String)map.get(1);
}
}

总结:泛型的实质过程就是这,之所以编译程序可以帮你检查类型转换错误,是因为你使用了泛型这个语法糖,然后他通过解语法糖在一定位置加上强制转换,并且会执行checkCast指令(参照步骤2)

扩展:如果在类的元数据(类,方法,字段的声明信息)中出现了泛型参数,在字节码中有一个称为signature的属性来记载它,也就是说泛型擦出只对code属性有效,这也可以解释为什么可以通过反射来获取泛型参数

 

***自动装箱

1.java代码

public class Test{
    public static void main(String[] args) {
        Integer i = 1;
    }
}

2.javac编译+javap反编译后的部分指令码

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=2, args_size=1
         0: iconst_1
         1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
         4: astore_1
         5: return
      LineNumberTable:
        line 3: 0
        line 4: 5
}

3.将步骤2的指令码等价为java语言

public class Test{
    public static void main(String[] args) {
        Integer i = Integer.valueOf(1);
    }
}

4.举例

public class Test{
  public static void main(String [] args) {
    int a=257;
    Integer b=257;
    Integer c=257;
    Integer b2=57;
    Integer c2=57;
    System.out.println(a==b);  //true
    System.out.println(b.equals(a));  //true
    System.out.println(b==c);      //false 
    System.out.println(b2==c2);     //true
  }
}

分析如下:

>javac Test.java
>javap -verbose Test
(一部分输出)
 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=6, args_size=1
         0: sipush        257                  //a入栈
         3: istore_1                             //a存入本地变量表
         4: sipush        257                 //b入栈
         7: invokestatic  #2                 //调用Integer.valueOf(b)方法,返回引用
        10: astore_2                          //将引用存入本地变量表                //c,b2,c2的分析省略
        11: sipush        257                
        14: invokestatic  #2                 
        17: astore_3
        18: bipush        57
        20: invokestatic  #2              
        23: astore        4
        25: bipush        57
        27: invokestatic  #2                
        30: astore        5
        32: getstatic     #3                  //获得PrintStream对象
        35: iload_1                             //将本地变量表中的a变量入栈
        36: aload_2                            //将本地变量表中指向b的引用入栈
        37: invokevirtual #4                //调用Integer.intValue(b),引用出栈,b的数值入栈
        40: if_icmpne     47                //将栈顶两基本类型进行比较
        43: iconst_1
        44: goto          48
        47: iconst_0
        48: invokevirtual #5                  
        51: getstatic     #3                  
        54: aload_2                              //和上述aload_2相同
        55: iload_1                               //和上述iload_1相同
        56: invokestatic  #2                  //调用Integer.valueOf(a),a出栈将其引用入栈
        59: invokevirtual #6                  // 调用equals方法
        62: invokevirtual #5                 
        65: getstatic     #3                 
 //接下来指令不再分析,因为对于b,c,b2,c2都是引用变量,它们的比较不再涉及装箱和拆箱,之和Integer.valueOf的内部实现有关
        68: aload_2                             
        69: aload_3
        70: if_acmpne     77
        73: iconst_1
        74: goto          78
        77: iconst_0
        78: invokevirtual #5                 
        81: getstatic     #3                
        84: aload         4
        86: aload         5
        88: if_acmpne     95
        91: iconst_1
        92: goto          96
        95: iconst_0
        96: invokevirtual #5                
        99: return

总结:很简单,从java语言层面可以实现基本类型为包装类型赋值了,自动拆箱省略

 

*** for each遍历

1.java代码

import java.util.*;
public class Test{
    public void test(){
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    for(int i: list );
}
}

2.javac编译+javap反编译后的部分指令码

 public void test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #2                  // class java/util/ArrayList
         3: dup
         4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
         7: astore_1
         8: aload_1
         9: iconst_1
        10: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        13: invokevirtual #5                  // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
        16: pop
        17: aload_1
        18: iconst_2
        19: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        22: invokevirtual #5                  // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
        25: pop
        26: aload_1
        27: invokevirtual #6                  // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
        30: astore_2
        31: aload_2
        32: invokeinterface #7,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z
        37: ifeq          56
        40: aload_2
        41: invokeinterface #8,  1            // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
        46: checkcast     #9                  // class java/lang/Integer
        49: invokevirtual #10                 // Method java/lang/Integer.intValue:()I
        52: istore_3
        53: goto          31
        56: return

3.将步骤2的指令码等价为java语言

import java.util.*;
public class Test{
    public void test(){
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    for(Iterator i = list.iterator();i.hasNext(););
}
}

总结:很简单,明白了要想使用for each循环,该类必须实现了Iterator接口

posted on 2017-03-20 21:11 unbelievableme 阅读(...) 评论(...) 编辑 收藏

导航

公告