Eliminating type parameters used only for superclass information?

Question

I have a class called BaseObject. I have another class called Reference. A
BaseObject has one canonical Reference that can be gotten and set. A Reference
is capable of pointing at a BaseObject subclass of a particular type and can
return the Class of that BaseObject subclass.
I'd like to genericize these classes so that if you create a reference and
assign it to an object, their types should line up. That is, a Reference that
points to a Banana should not be able to be assigned as a canonical reference to
a Cherry.
My goal is to express these type constraints once somewhere. I cannot seem to
achieve my goal.
Pass one, which looks OK at the outset:
  public class BaseObject<T extends BaseObject> {
    public Reference<T> getReference() {
    public void setReference(final Reference<T> reference) {
  public class Reference<T extends BaseObject> {
    public Class<T> getObjectType() {
  }But that would mean that every subclass of BaseObject<T> would need to be
declared with a type parameter as well to permit further subclassing, right?
Like so:
  public class Fruit<T extends Fruit> extends BaseObject<T> {
    // Note: T is not used in this class except to "pass it up" to BaseObject
  public class Banana<T extends Banana> extends Fruit<T> {
    // Note: T is not used in this class except to "pass it up" to Fruit
    // Callers will have to say: new Banana<Banana>();
  }That seems WEIRD to me. Is there any way to...to...hide the genericization of
the fundamental classes--BaseObject and Reference--without forcing the type
parameters to be propagated all the way down the subclass stack?
In other words, assuming a hierarchy of Object<--Fruit<--Banana, is there any
way to have Fruit and Banana not mention type parameters at all?
Thanks,
Laird

Answer 1

I'm up a creek here, aren't I?I think so. It's been a while since I complained
about the lack of 'self-types' in Java. 'Self-type'
actually means something different in other languages
(Scala for example) so just be aware of that.AH! Yes! That's exactly what I'm talking about. OK, knowing that I'm screwed helps a lot, actually. It lets me know where I can and cannot apply generics to solve problems.
I would envision:
class BaseObject<self>
// OR
class BaseObject<T extends self>The idea would be that self is what ever the
'current' class is. So if you used the first one,
the type of the class that extended BaseObject would
be assumed to be the parameteric type. The second
one would require that the parameter (if present at
time of variable of declaration is instantiation) be
at least as specific as the current extenstion of
BaseObject.Yes, exactly. This would be wildly helpful. Oh well.
Back to 1.4 syntax.
Cheers,
Laird