C++泛型 && Java泛型实现机制
C++泛型
C++泛型跟虚函数的运行时多态机制不同,泛型支持的静态多态,当类型信息可得的时候,利用编译期多态能够获得最大的效率和灵活性。当具体的类型信息不可得,就必须诉诸运行期多态了,即虚函数支持的动态多态。
对于C++泛型,每个实际类型都已被指明的泛型都会有独立的编码产生,也就是说list<int>
和list<string>
生成的是不同的代码,编译程序会在此时确保类型安全性。由于知道对象确切的类型,所以编译器进行代码生成的时候就不用运用RTTI,这使得泛型效率跟手动编码一样高。
显然这样的做法增加了代码空间,相比运行时多态,是以空间换时间。
Java泛型
当编译器对带有泛型的 Java 代码进行编译时,它会去执行类型检查和类型推断,然后生成普通的不带泛型的字节码,这种字节码可以被一般的 Java 虚拟机接收并执行,这种技术被称为擦除(erasure)。
可见,编译器可以在对源程序(带有泛型的 Java 代码)进行编译时使用泛型类型信息保证类型安全,同时在生成的字节码当中,将这些类型信息清除掉。
如在代码中定义的List<object>
和List<String>
等类型,在编译后都会编程List。JVM看到的只是List,而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方,但是仍然无法避免在运行时刻出现类型转换异常的情况。
擦除的原则:
1)所有参数化容器类都被擦除成非参数化的(raw type);如List<E>、List<List<E>
>都被擦除成List;
2)所有参数化数组都被擦除成非参数化的数组;如List<E>[]
,被擦除成List[]
;
3)Raw type的容器类,被擦除成其自身,如List 被擦除成List;
4)原生类型(int,String还有wrapper类)都擦除成他们的自身;
5)参数类型E,被擦除成Object;
6)所有约束参数如<? Extends E>、<X extends E>
都被擦除成E;
7)如果有多个约束,擦除成第一个,如<T extends Object & E>
,则擦除成Object;
来看个例子:
public class Pair<T> {
public Pair(T first,T second) {
this.first = first;
this.second = second;
}
public T getFirst() { return first; }
public T getSecond() { return second; }
public void setFirst(T first) { this.first = first; }
public void setSecond(T second) { this.second = second; }
private T first;
private T second;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
擦除后变为:
public class Pair {
public Pair(Object first,Object second) {
this.first = first;
this.second = second;
}
public Object getFirst() { return first; }
public Object getSecond() { return second; }
public void setFirst(Object first) { this.first = first; }
public void setSecond(Object second) { this.second = second; }
private Object first;
private Object second;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
public class QMI<T extends List> {
public Interval(T value) {
this.value = value;
}
private T value;
}
- 1
- 2
- 3
- 4
- 5
- 6
擦除后:
public class QMI {
public Interval(List value) {
this.value = value;
}
Private List value;
}
- 1
- 2
- 3
- 4
- 5
- 6
那么,进行类型擦除后,在调用时怎么知道其真实类型,放心吧,编译器帮我们做好了一切,以后上面的Pair为例:
原代码为:
Pair<String> pair = new Pair<>("", "");
pair.setFirst("QMI");
pair.setSecond("Kang");
String first = pair.getFirst();
String second = pair.getSecond();
- 1
- 2
- 3
- 4
- 5
反编译后为:
Pair pair = new Pair("", "");
pair.setFirst("QMI");
pair.setSecond("Kang");
String first = (String)pair.getFirst();
String second = (String)pair.getSecond();
- 1
- 2
- 3
- 4
- 5
可以看到,编译器帮我们做了自动类型转换。
对于泛型,我们可以利用Java单根继承特性实现类似效果,但是因为此时编译器并不做类型检查,这种检查是在运行时进行的,推迟了发现程序中错误的时间。
而利用泛型机制,编译器承担了全部的类型检查工作,确保类型的安全性。以List<Object>
和List<String>
为例来具体分析:
public void test() {
List<String> list= new ArrayList<String>();
List.add(123); //编译错误
}
- 1
- 2
- 3
- 4
这里,声明为List的集合中却被添加了一个Integer类型的对象。这显然是违反类型安全的原则的,在某个时候肯定会抛出ClassCastException。因此,编译器禁止这样的行为。编译器会尽可能的检查可能存在的类型安全问题。对于确定是违反相关原则的地方,会给出编译错误。当编译器无法判断类型的使用是否正确的时候,会给出警告信息。此种机制有利于尽早地发现并改正错误。
让我再来看一个问题:
public class QmiV<T> {
private T value;
public T getValue() {
return this.value;
}
public void setValue(T value) {
this.value = value;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
擦除后:
public class QmiV<Object> {
private Object value;
public Object getValue() {
return this.value;
}
public void setValue(Object value) {
this.value = value;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
//子类
public class QmiVD extends QmiV<Person> {
@Override
public Person getValue() {
return super.getValue();
}
@Override
public void setValue(Person value) {
super.setValue(value);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
擦除后:
public class QmiVD extends QmiV<Person> {
public QmiVD() {
}
public String getValue() {
return (Person)super.getValue();
}
public void setValue(Person value) {
super.setValue(value);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
可以看到,对于setValue方法,父类的类型是Object,而子类的类型是Person,参数类型不一样,所以这里实现的不是重写,而是重载。
实际中,是利用桥方法解决这个问题的。
桥方法就是生成一个中间层,其参数类型都是Object,也就是说,子类中真正覆盖父类两个方法的就是两个我们看不到的桥方法。桥方法的内部再去调用我们自己重写的那两个方法。
总结:
C++泛型和Java泛型非常类似,但是有着本质不同。
首先,Java 语言中的泛型不能接受基本类型作为类型参数――它只能接受引用类型。这意味着可以定义 List<Integer>
,但是不可以定义 List<int>
。
其次,在 C++ 模板中,编译器使用提供的类型参数来生成不同代码。而 Java 中的泛型,编译器仅仅对这些类型参数进行擦除和替换。类型 ArrayList<Integer>
和 ArrayList<String>
的对象共享相同的类,并且只存在一个 ArrayList 类。
参考:
https://zh.wikipedia.org/zh-cn/%E6%B3%9B%E5%9E%8B
http://www.ibm.com/developerworks/cn/java/j-jtp01255.html
http://www.infoq.com/cn/articles/cf-java-generics