No, that's not what I meant, but yes, that is a limitation. (Just not one I hit.) The big one is not being able to allocate objects of that type. For example, in C++, I can say:

  template <class T>
  T* allocate() {
    return new T();
  }

That's not possible in Java because of type erasure. When you try something like that, you get an error message like:

  Erasure.java:12: error: unexpected type
              return new T();
                       ^
    required: class
    found:    type parameter T
    where T is a type-variable:
      T extends Object declared in class Foo

Again, this is because of type erasure: Foo<T> is really Foo<Object>, where Java just does a cast for you to T in all of the right places. It does not actually know the type. For me, that lead to all sort of contortions because a class Foo<T> could not allocate objects of type T internally. I needed to create factory methods in other places which Foo would call. In the instance I'm thinking of, those factory methods ended up living in derived classes.

C++ templates have its issues, but it allows parametric polymorphism. In Java, I could not write such code, which was what I was used to. Because of type erasure, I was forced more towards subtype polymorphism, even though I was implementing generic classes.