java泛型与c++泛型比较

下面是使用模板的C++示例，你将注意到用于参数化类型的语法十分相似，因为Java是受C++启发：

#include<iostream>using namespace std;template<class T> class Manipulator{T obj;public:  Manipulator(T x){obj=x;}  void manipulate(){obj.f();}};class HasF{public:  void f(){cout<<"Hasf::f()"<<endl;}};int main(){HasF hf;Manipulator<HasF> manipulator(hf);manipulator.manipulator();}/*output:HasF:f()///:

Manipulator类存储了一个类型T的对象，有意思的地方是manipulate（）方法，它在obj上调用方法f()。他怎么知道f()方法是为类型参数T而存在的呢？当你实例化这个模板时，c++编译器将进行检查，因为在Manipulator<HasF>被实例化的这一刻，他看到HasF拥有一个方法f()。

如果情况并非如此，他就会得到一个编译器错误，这样类型安全就得到了保障。

用c++编写这样的代码很简单，因为当模板被实例化时，模板代码知道其模板参数的类型。Java泛型就不同了。下面是HasF的Java版本：

public class HasF {public void f(){System.out.println("HasF:f()");}}public class Manipulator<T> {private T obj;public Manipulator(T x){obj=x;}//Eror :cannot find symbol:method f():public void manipulate(){//obj.f();}public static void main(String[] args) {HasF hf=new HasF();Manipulator<HasF> manipulator=new Manipulator<HasF>(hf);manipulator.manipulate();}}

由于有了擦除，Java编译器无法将manipulate()必须能够在obj上调用f()这一需求映射到HasF拥有f()这一事实上。为了调用f(),我们需要协助泛型类，给定泛型类的边界，以此告知编译器只能接受遵循这个边界的类型。这里重用了extends关键字。由于有了边界，下面的代码就可以编译了：

public class Manipulator2<T extends HasF> {private T obj;public Manipulator2(T x){obj=x;}public void manipulate(){obj.f();}}

边界<T extends HasF>声明必须具有类型HasF或者是从HasF导出的类型。如果情况确实如此，那么就可以安全的在obj上调用f()了。

我们说泛型类型参数将擦除到它的第一个边界（他可能有很多边界），我们还提到了类型参数的擦除。编译器实际上会把类型参数替换为它的擦除，就像上面的示例一样。T擦除到了HasF,就好像在类的声明中用HasF替换T一样。

你可能已经正确的观察到，在Manipulation2.java中，泛型没有贡献任何好处。只需很容易地自己去执行擦除，就可以创建出没有泛型的类：

public class Manipulator3 {private HasF obj;public Manipulator3(HasF x){obj=x;}public void manipulate(){obj.f();}}

这提出了很重要的一点：只有当你希望使用的类型参数比某个具体类型（以及他的所有子类型）更加”泛化“时--也就说，当你希望代码能够跨多个类工作时，使用泛型才能有所帮助。因此，类型参数和他们在有用的泛型代码中的应用，通常比简单的类替换要更复杂，但是，不能因此而认为<T extends HasF>形式的任何东西都是有缺陷的。例如，如果某个类有个返回T的方法，那么泛型就有所帮助，因为他们之后将返回确切的类型：

public class ReturnGenericType<T extends HasF> {private T obj;public ReturnGenericType(T x){obj=x;}public T get(){return obj;}}

必须查看所有的代码，并确定他是否”足够复杂“到必须使用泛型的程度.