EJP said:
In fact I
don't understand how you think that this difference isn't both
conceptual and fundamental. The 'similarity' is so superficial as to be
merely syntactical, as I said originally, or to amount to no more than a
way of doing some kind of type-generic programming, as I said later and
was castigated for, probably rightly.
I wasn't following the thread too closely, so I didn't noticed your
being catigated, nor what you were castigated for. I actually think you
aren't going far enough. Saying that Java generics are a way of doing
type-generic programming is incorrect. Inheritance and polymorphism as
a singly-rooted inheritance hierarchy are a way of doing generic
programming. Generics are a way of adding type system awareness to
type-generic programming.
In STL algorithms, for example, comparison is done with an overloaded
'<' operator or with a functor, both using templates. In Java, the same
thing is done with ordinary objects that implement interfaces
(Comparable or Comparator) and provide code that is called via
polymorphic dispatch. Java generics do not change that fact at all.
What they do is provide an expressive enough type system that the
compiler can remain aware of types while it evaluates generic
programming operations.
Therefore, a comparison between templates and generics is somewhat
poorly founded, not just because they work differently, but also because
they solve different problems. C++ templates provide a very broad
mechanism for solving a variety of problems. Java's generics are more
precisely aimed at a specific problem -- merely expressing the typing
relation -- and therefore look considerably different aside from the
angle-brackets.
