Mixing self conscious parametrized types with inheritance
Hi,
inspired by our recent discussions of generics I set out to get a clear
picture of how to properly use Comparable<T> - especially when
inheritance comes into play.
1. Only classes whose methods that use the type parameter may not be
overridden with type specific functionality (either because all methods
or the class is final, or the type need not change when sub classes
override those) can do away with the type parameter.
2. All others need to repeat the type parameter (in case of self
reference with a bound).
class BaseC<SC extends BaseC<?>> implements Comparable<SC> {
@Override
public int compareTo(SC o) {
return getKey() - o.getKey();
}
}
class SubC<SC extends SubC<?>> extends BaseC<SC> {
@Override
public int compareTo(SC o) {
final int cmp = getK() % 3 - o.getK() % 3;
return cmp == 0 ? getK() - o.getK() : cmp;
}
}
final class FinalC extends SubC<FinalC> {
@Override
public int compareTo(FinalC o) {
final int cmp = getX() % 2 - o.getX() % 2;
return cmp == 0 ? getPos() - o.getPos() : cmp;
}
}
Full code is here https://gist.github.com/868085
Kind regards
robert
--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/