Re: Mixing self conscious parametrized types with inheritance
On Mar 15, 7:21 pm, Lew <l...@lewscanon.com> wrote:
On Mar 15, 9:54 am, SoulSpirit <soulspi...@gmail.com> wrote:
On Tuesday, March 15, 2011 2:16:13 PM UTC+1, Robert Klemme wrote:
[...]
Why do you insist that only Comparable<ConcreteType> is
valid and not Comparable<TypyParameter>?
Because if the type implements 'compareTo()' for some other type, it's
making an incorrect type assertion. It's saying, in your case, that
'BaseC' implements comparison for 'SC', not for itself.
It is implementing compareTo() for SC extends BaseSC<?> so it *is*
implementing compareTo() for itself. SubC implements compareTo() for
SC extends SubC<?> so it is also implementing compareTo() for itself
etc. Even if another subclass X of BaseC or SubC would choose to not
provide its own implementation of compareTo() the version inherited
from its super class is definitively valid for the sub class as well
since it is completely legal to base a default ordering only on super
class members.
I agree with you, Robert.
Just look at the standard java Enum class. It is declared as:
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable
That's different. You aren't implementing 'compareTo()' for 'Enum'
itself. 'Enum' has no implementation of 'compareTo()', so there's no
method with which the subtypes can conflict, unlike Robert's example.
/**
* This is the common base class of all Java language enumeration
types.
*
* @author Josh Bloch
* @author Neal Gafter
* @version %I%, %G%
* @since 1.5
*/
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable {
....
/**
* Compares this enum with the specified object for order.
Returns a
* negative integer, zero, or a positive integer as this object is
less
* than, equal to, or greater than the specified object.
*
* Enum constants are only comparable to other enum constants of
the
* same enum type. The natural order implemented by this
* method is the order in which the constants are declared.
*/
public final int compareTo(E o) {
Enum other = (Enum)o;
Enum self = this;
if (self.getClass() != other.getClass() && // optimization
self.getDeclaringClass() != other.getDeclaringClass())
throw new ClassCastException();
return self.ordinal - other.ordinal;
}
....
JDK 1.6.0_24
Robert is trying to implement the *base type* compareTo() in terms of
subtypes, that's the problem. 'Enum' doesn't make that mistake.
Apples and oranges.
I do not implement the base type's compareTo() in terms of
subclasses. I implement it in terms of a type wildcard bound by its
own type (<SC extends BaseC<?>>) so the type is at least BaseC and can
perfectly work with BaseC members.
Actually when looking at Enum.compareTo() (which I had not done before
providing my example) I cannot really detect what Enum does
differently: it implements compareTo() for a type of which is only
known that it is a subclass of Enum - so it accesses only Enum
members. And if it wasn't for the final at compareTo() any Enum could
implement its own default ordering.
The only thing that I find odd is that I could not find a way to
declare "class BaseC<SC extends BaseC<SC>> implements Comparable<SC>"
like Enum does which would allow me to instantiate the type so I had
to use "class BaseC<SC extends BaseC<?>> implements Comparable<SC>".
But since we do not instantiate enums explicitly anyway this is not an
issue.
Kind regards
robert