实施可比 <T> 在通用超类中

Question

I have an abstract generic superclass which I extend to make concrete classes with IDs of a specific type:

public abstract class AbstractEntity<I> {
  ...
  private I id;
  private String name;
  ...
}

I create the concrete classes like this:

public class User extends AbstractEntity<Long> {...}

Now I want to make the concrete classes comparable to other instances of themselves (and no other type--this should be enforced at compile time). By default the compareTo method should just sort by name so I want to add it in the superclass to avoid repeating code. The only way I've come up with to do this is with this ugly construct:

public abstract class AbstractEntity<I,T> implements Comparable<AbstractEntity<I,T>> {
  ...
  private I id;
  private String name;
  ...
  @Override
  public int compareTo(AbstractEntity<I,T> o) {
    ...
  }
}

...

public class User extends AbstractEntity<Long,User> {...}

I think this is ugly because now in order to extend the superclass you need to repeat the concrete class name again as a type parameter for itself, which is odd and counterintuitive. Is there a more elegant way to accomplish the same thing that I'm missing?

Thanks!

Answer 1

What you're looking for is the "self type", but this can't be achieved in Java. The closest you can come is using a recursively bound type parameter that is supposedly the self type:

public abstract class AbstractEntity<I, E extends AbstractEntity<I, E>> implements Comparable<E> {
    ...
    private I id;
    private String name;
    ...
    public final String getName() {
        return name;
    }
    ...
    @Override
    public int compareTo(E otherEntity) {
        final String otherName = otherEntity.getName();
        ...
    }
}

public final class User extends AbstractEntity<Long, User> { }

I would recommend against this pattern though, as it's confusing and can easily be abused. For example:

public final class EvilUser extends AbstractEntity<Long, AnotherUser> { }

My advice: just stick to implementing Comparable on an individual-entity basis.

Answer 2

No. This is how you're supposed to do it. Putting the class itself in the parameter description is actually a normal thing to do in a situation like this one.

Answer 3

Is this what you are looking for

public abstract class AbstractEntity<I> implements
        Comparable<AbstractEntity<I>> {
    private I id;

    @Override
    public int compareTo(AbstractEntity<I> o) {

        if (o != null && !o.getClass().equals(getClass())) {
            throw new IllegalArgumentException("Unsupported instance type "
                    + o.getClass());
        }

        return 0;
    }

}

public class User extends AbstractEntity<Long> {
}

Answer 4

Now I want to make the concrete classes comparable to other instances of themselves (and no other type--this should be enforced at compile time).

Why? Generics is not there for you to make arbitrary restrictions. Generics is only for enforcing type safety (ie the elimination of casts; avoiding ClassCastException). Arbitrarily requiring it to not be comparable to other types serves no type-safety purpose, and thus cannot be done.

If the comparison does not depend on any subclass features, then AbstractEntity<I> is comparable to all AbstractEntity<I> , in which case it should be declared like this:

public abstract class AbstractEntity<I> implements Comparable<AbstractEntity<I>>

The problem here is that the concrete class would be comparable with any other concrete class with the same ID type at compile time

So what? The comparison is perfectly type-safe. If you don't want to compare one concrete class to another, then don't. If someone else wants to compare one concrete class to another, then great for them. Why does this matter to you?

ps The code you posted, public abstract class AbstractEntity<I,T> implements Comparable<AbstractEntity<I,T>> also does not enforce that one class only compares to itself, because there is no guarantee that a class must extend it with itself as the second parameter.