Java编程思想学习(十一) 泛型
1.概要
generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods.
泛型能在定义类,接口和方法时将类型(类和接口)作为参数。和方法声明时的形式参数很类似,都是为了在不同的输入时重用相同的代码。不同的是形式参数输入的是值而泛型是类型。
2.为什么使用泛型
1.编译时更加强的(Stronger)类型检测
java编译器对泛型代码进行强类型检测,一旦检测到代码违反类型安全就发出类型错误。
修复编译错误要比运行错误容易,因为运行错误很难找到问题所在。
2.不用类型转换
//没有使用泛型
List list = new ArrayList();
list.add("without generics");
//需要强制类型转换
String s1 = (String) list.get(0);
//使用泛型
List<String> list2 = new ArrayList<String>();
list2.add("generics");
String s2 = list2.get(0);//不需要转换
3.使程序员能实现适用更加普遍的算法
通过使用泛型,使程序员能实现普遍的算法,算法将是能使用于不同类型的,能自定义的,类型安全的,易读的。
如只写一个排序方法,就能够对整形数组、字符串数组甚至支持排序的任何类型的数组进行排序。
3.具体使用
1.泛型(generic type)
A generic type is a generic class or interface that is parameterized over types.
泛型是一种通用的类或接口,通过类型参数化的。
泛型类以下面的格式定义:
class name<T1, T2, ..., Tn> { /* ... */ }
通过Box类的非泛型版和泛型版来学习一下:
非泛型:
//non-generic class
public class Box {
private Object object;
public Object getObject() {
return object;
}
public void setObject(Object object) {
this.object = object;
}
}
泛型:
//generic class
public class Box<T> {
//T表示Type
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
类型参数命名规范按约定的习俗,类型参数的名字都是由一个大写字母构成。
E - Element 元素(used extensively by the Java Collections Framework)
K - Key 键
N - Number 数值
T - Type 类型
V - Value 值
S,U,V etc. - 2nd, 3rd, 4th types 第二种,第三种,第四种类型
调用和实例化泛型类
为了获得泛型类的引用,必须执行泛型类的调用,使用具体的值来代替T,如Integer。
//获得引用
Box<Integer> integerBox;
//实例化
integerBox = new Box<Integer>();
泛型类的调用类似于普通的方法调用,只是泛型类传递的是类型参数(type argument)而方法调用传递的是参数(argument)。
多类型参数
泛型类可能有多种类型的参数。如下所示:
public interface Pair<K,V>{
public K getKey();
public V getValue();
}
public class OrderedPair<K,V> implements Pair<K,V>{
private K key;
private V value;
public OrderedPair(K key,V value){
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
}
//实例化
Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String> p2 = new OrderedPair<String, String>("hello", "world");
//Java SE7开始出现的新语法
OrderedPair<String, Integer> p1 = new OrderedPair<>("Even", 8);
OrderedPair<String, String> p2 = new OrderedPair<>("hello", "world");
//参数化的类型
OrderedPair<String, Box<Integer>> p = new OrderedPair<>("primes", new Box<Integer>(...));
4.类型擦除
(1)什么事类型擦除?
类型擦除指的是通过类型参数合并,将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码,并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息,并且再必要的时候添加类型检查和类型转换的方法。
类型擦除可以简单的理解为将泛型java代码转换为普通java代码,只不过编译器更直接点,将泛型java代码直接转换成普通java字节码。
类型擦除的主要过程如下:
1.将所有的泛型参数用其最左边界(最顶级的父类型)类型替换。
2.移除所有的类型参数。
如:
1 interface Comparable <A> { 2 public int compareTo( A that); 3 } 4 final class NumericValue implements Comparable <NumericValue> { 5 priva te byte value; 6 public NumericValue (byte value) { this.value = value; } 7 public byte getValue() { return value; } 8 public int compareTo( NumericValue t hat) { return this.value - that.value; } 9 } 10 ----------------- 11 class Collections { 12 public static <A extends Comparable<A>>A max(Collection <A> xs) { 13 Iterator <A> xi = xs.iterator(); 14 A w = xi.next(); 15 while (xi.hasNext()) { 16 A x = xi.next(); 17 if (w.compareTo(x) < 0) w = x; 18 } 19 return w; 20 } 21 } 22 final class Test { 23 public static void main (String[ ] args) { 24 LinkedList <NumericValue> numberList = new LinkedList <NumericValue> (); 25 numberList .add(new NumericValue((byte)0)); 26 numberList .add(new NumericValue((byte)1)); 27 NumericValue y = Collections.max( numberList ); 28 } 29 }<span style="color: #333333; font-family: Arial; font-size: 14px;"> 30 </span>
经过类型擦除后的类型为
interface Comparable
1 public int compareTo( Object that); 2 } 3 final class NumericValue implements Comparable { 4 priva te byte value; 5 public NumericValue (byte value) { this.value = value; } 6 public byte getValue() { return value; } 7 public int compareTo( NumericValue t hat) { return this.value - that.value; } 8 public int compareTo(Object that) { return this.compareTo((NumericValue)that); } 9 } 10 ------------- 11 class Collections { 12 public static Comparable max(Collection xs) { 13 Iterator xi = xs.iterator(); 14 Comparable w = (Comparable) xi.next(); 15 while (xi.hasNext()) { 16 Comparable x = (Comparable) xi.next(); 17 if (w.compareTo(x) < 0) w = x; 18 } 19 return w; 20 } 21 } 22 final class Test { 23 public static void main (String[ ] args) { 24 LinkedList numberList = new LinkedList(); 25 numberList .add(new NumericValue((byte)0)); , 26 numberList .add(new NumericValue((byte)1)); 27 NumericValue y = (NumericValue) Collections.max( numberList ); 28 } 29 }<span style="color: #333333; font-family: Arial; font-size: 14px;"> 30 </span>
第一个泛型类Comparable <A>擦除后 A被替换为最左边界Object。Comparable<NumericValue>的类型参数NumericValue被擦除掉,但是这直 接导致NumericValue没有实现接口Comparable的compareTo(Object that)方法,于是编译器充当好人,添加了一个桥接方法。
第二个示例中限定了类型参数的边界<A extends Comparable<A>>A,A必须为Comparable<A>的子类,按照类型擦除的过程,先讲所有的类型参数 ti换为最左边界Comparable<A>,然后去掉参数类型A,得到最终的擦除后结果。
5.类型擦除带来问题
正是由于类型擦除的隐蔽存在,直接导致了众多的泛型问题。
Q1.用同一泛型类的实例区分方法签名?——NO!
import java.util.*;
1 public class Erasure{ 2 3 public void test(List<String> ls){ 4 System.out.println("Sting"); 5 } 6 public void test(List<Integer> li){ 7 System.out.println("Integer"); 8 } 9 }<span style="color: #333333; font-family: Arial; font-size: 14px;"> 10 </span>
编译该类,
参数类型明明不一样啊,一个List<String>,一个是List<Integer>,但是,偷偷的说,type erasure之后,它就都是List了⋯⋯
Q2. 同时catch同一个泛型异常类的多个实例?——NO!
同理,如果定义了一个泛型一场类GenericException<T>,千万别同时catch GenericException<Integer>和GenericException<String>,因为他们是一样一样滴⋯⋯
Q3.泛型类的静态变量是共享的?——Yes!
猜猜这段代码的输出是什么?
1 import java.util.*; 2 3 public class StaticTest{ 4 public static void main(String[] args){ 5 GT<Integer> gti = new GT<Integer>(); 6 gti.var=1; 7 GT<String> gts = new GT<String>(); 8 gts.var=2; 9 System.out.println(gti.var); 10 } 11 } 12 class GT<T>{ 13 public static int var=0; 14 public void nothing(T x){} 15 }<span style="color: #333333; font-family: Arial; font-size: 14px;"> 16 </span>
答案是——2!由于经过类型擦除,所有的泛型类实例都关联到同一份字节码上,泛型类的所有静态变量是共享的。
小结:1.虚拟机中没有泛型,只有普通类和普通方法
2.所有泛型类的类型参数在编译时都会被擦除
3.创建泛型对象时请指明类型,让编译器尽早的做参数检查(Effective Java,第23条:请不要在新代码中使用原生态类型)
4.不要忽略编译器的警告信息,那意味着潜在的ClassCastException等着你。