What's the general consensus regarding Generics in Java?

Question

Just curious what folks think about how it's implemented in Java and whether you're in favor of it or not (not that it will make any difference).
I haven't been using it yet because I am still working on 1.4.x, but I've been familiarizing myself as best as I can with how to use them.
I realize they fill an important need, but I am not convinced they were/are worth the rather steep price paid for readability.
Curious to get others opinions on this. Regards,
~Bill
Message was edited by:
abillconsl

Answer 1

So "new MyWrapper(aString)" is untyped, we need to
use "new MyWrapper<String>(aString)" whichviolates
the principle of Dont-repeat-yourself.I don't think so... what if I wanted to create
something like this?
new MyWrapper<Number>(new Integer(4))That's still possible. My problem is that it works exactly as I'd like it to work as long as I call a method, but not when I instanciate a new object. Let's assume for a second that MyWrapper has a static generic method createWrapper() that just calls the constructor:
public class MyWrapper<T> {
     private T foo;
     public MyWrapper(T foo) {
          this.foo = foo;
     public T getFoo() {
          return foo;
     public static <WT,VT extends WT> MyWrapper<WT> createWrapper(VT foo) {
          return new MyWrapper<WT>(foo);
}Here WT is the generic type of the returned wrapper (WrapperType) and VT is the type of the value(ValueType).
Now we see a strange discrepancy on how the object instanciation ("call of a constructor", so to speak) works and how calling another Method works:
MyWrapper<Integer> i1 = new MyWrapper(Integer.valueOf(1)); //unsafe, not infered
MyWrapper<Integer> i2 = MyWrapper.createWrapper(Integer.valueOf(1)); //ok, everything fine
MyWrapper<Number> n1 = new MyWrapper(Integer.valueOf(1)); //unsafe, not infered
MyWrapper<Number> n2 = MyWrapper.createWrapper(Integer.valueOf(1)); //ok, everything fineIf you compile this code (or simply paste it in any modern IDE) you'll see that you'll get warning in the two lines calling the constructor. While the lines calling createWrapper() seem ok. So somehow the compiler can infer the type information when calling a method but can't do that when calling a constructor. That's what's troubling me.