Thanks for your answer.
I can't disagree with your point of view, but we know real-world
applications are always an exception to every principle :)
In the simplified example i've omitted the purpose of my... dilemma.

The purpose is to give someone other a clear class to extends that
already do all work but specialized jobs, giving less space as
possible to the implementor.
In short, my superclass is always able to compare an Animal with
another one if they are of different type, but fine comparision is
needed when the two Animal(s) are of the same type. The real
superclass is much like this:

public abstract class Animal<T extends Animal> implements
Comparable<T>{
    abstract int compareToInternal( T other );

    public final int compareTo( T other ){
        if( getClass() == other.getClass() )
            return compareToInternal( other );
        else
            ... Animal knows what to do here ...
    }
}

And I'd like to force subclasses to implement this compareToInternal()
method that compares only instances of the same type (Dogs with Dogs
and Cats with Cats).

An implementation like this...

public class Dog extends Animal<Cat>{
    int compareToInternal( Cat other ){
        return 0;
    }
}

... should be seen as an error by the compiler.

Bye