下面是使用模板的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; } }必须查看所有的代码，并确定他是否”足够复杂“到必须使用泛型的程度.
