java泛型详解(加一点语法糖)
2017-03-20 21:11
344 查看
首先请看如下代码:
以上就是强制类型转换可能带来的典型错误,然而这个错误在编译期间无法知道,以至于在运行期间jvm检查后抛出类型转换异常。
再看下述代码:
综上看来泛型的作用为: 1.就是是在编译的时候检查类型的安全(解决java中强制类型转换可能导致的错误,而不需要jvm加载的时候再抛出一场) 2.提高代码的重用率
与类型擦除有关的现象:
泛型类没有Class的类类型。比如并不存在List<String>.class或是List<Integer>.class,而只有List.class。
静态变量是被泛型类的所有实例所共享的。
泛型的类型参数错误不能通过异常处理,因为异常处理是jvm实现的,而jvm加载的字节码文件已经擦除了泛型特征,这也间接的说明了泛型的意义:在编译期间发现参数类型错误。
类型擦除的基本过程也比较简单:
1.将类型参数用顶级父类替换,这类一般是Object,如果指定了类型参数的上界的话,则使用这个上界。
2.去掉出现的类型声明,即去掉<>的内容。
例如:T get()方法声明就变成了Object get();List<String>就变成了List。接下来就可能需要生成一些桥接方法(bridge method)。这是由于擦除了类型之后的类可能缺少某些必须的方法。比如考虑下面的代码:
泛型的分类:泛型类,泛型接口,泛型方法,泛型异常
泛型类
多态方法(泛型方法):在函数名前定义泛型参数,可以在传入参数列表,返回值类型,方法体里面引用
泛型异常(兼具泛型接口)
从字节码角度看泛型
*语法糖
至于什么是语法糖,可以从属于语法糖的那些java特性来探索,有泛型,自动装箱,自动拆箱,for each循环,对于这些java特性应该都不陌生,他们的共有特点是:提供一种新的语法但是对语言的功能没有影响,开发变的更加简便,降低出错的可能性。
*解语法糖
语法糖使开发变得简便但是没有改变语言功能,也就是说这是面向编程人员的一种小把戏,在编译阶段仍会还原出本该有的模样,而这个过程就是解语法糖,举几个例子:
***泛型
1.java代码
2.javac编译+javap反编译后的部分指令码
3.将步骤2的指令码等价为java语言
总结:泛型的实质过程就是这,之所以编译程序可以帮你检查类型转换错误,是因为你使用了泛型这个语法糖,然后他通过解语法糖在一定位置加上强制转换,并且会执行checkCast指令(参照步骤2)
扩展:如果在类的元数据(类,方法,字段的声明信息)中出现了泛型参数,在字节码中有一个称为signature的属性来记载它,也就是说泛型擦出只对code属性有效,这也可以解释为什么可以通过反射来获取泛型参数
***自动装箱
1.java代码
2.javac编译+javap反编译后的部分指令码
3.将步骤2的指令码等价为java语言
4.举例
分析如下:
总结:很简单,从java语言层面可以实现基本类型为包装类型赋值了,自动拆箱省略
*** for each遍历
1.java代码
2.javac编译+javap反编译后的部分指令码
3.将步骤2的指令码等价为java语言
总结:很简单,明白了要想使用for each循环,该类必须实现了Iterator接口
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接口