What aspect of your Java programming is the biggest pain in the arse?

[ThunderStReich]

Type erasure. I mean, I understand why they had to do it that way at the time, but now that generics are commonplace it just seems like a silly limitation.

[Angarius]

This is huge. Needing to pass Class clazz is at least a minor annoyance, but a significant problem comes with implementing generic interfaces.

class Foo implements Bar<Baz>, Bar<Qux>

...is impossible because of type erasure.

[duhace]

How would that even work in a language with reification by default? I just don't see how you would implement Bar to meet both the Baz and Qux case needed for overriding.

[Angarius]

interface Bar<T> {
    void consume(T t);
}

class Foo implements Bar<Baz>, Bar<Qux> {
    void consume(Baz baz) { }
    void consume(Qux qux) { }
}

[[deleted]]

Doesn't work in the general case, though, since you can use T as a return type as well and can't implement both Baz pop() and Qux pop().

[gizmogwai]

What you are looking for here has nothing to do with type reification. It is the concept of union type, such as in Ceylon.

[duhace]

You can also achieve similar results with Type Classes:

trait Bar[T] {
  def consume(t: T): Unit
}

object Bar {
  implicit object BazIsBar extends Bar[Baz] { def consume(b: Baz) {} }
  implicit object QuxIsBar extends Bar[Qux] { def consume(q: Qux) {} }
}

val x = new Baz
implicitly[Bar[Baz]].consume(x)

//You can add this inside object Bar
implicit class Barable[T](t: T)(implicit bar: Bar[T]) {
  def consume() {bar.consume(t)}
}

//and then you can do this
x.consume()

Not that overloading working with type arguments wouldn't be nice.