L'avantage de mot cle abstract

Bonjour.

J'étais dans les nuages !

1. Dans la classe abstract, les méthodes qui ne sont pas communes entre toutes ses classes enfant, ne prennent pas de corps.
2. Les méthodes communes entre elles ne prennent pas le mot clè abstract à la tête et dans ce cas, leurs fonctions à réaliser sont explicitement déclarées.

Dans le cas de trois classes que vous m'avez montré, les méthodes "doubleValue(),intValue() ...etc" sont identiques. Et les autres sont vides dans la classe abstract "Comparable".

Merci !

1. Dans la classe abstract, les méthodes qui ne sont pas communes entre toutes ses classes enfant, ne prennent pas de corps.
2. Les méthodes communes entre elles ne prennent pas le mot clè abstract à la tête et dans ce cas, leurs fonctions à réaliser sont explicitement déclarées.

Dis comme ça, on a l'air de penser que les méthodes abstraites ne sont pas obligatoires et que la classe concrète pourrait ne pas définir ces méthodes : c'est faux !
Toutes les méthodes (sauf private), y compris les méthodes abstraites, seront disponibles par toutes les classes filles. Les "méthodes communes" c'est donc toutes les méthodes .

Ce qui est abstract, c'est ce qui est spécifique à l'implémentation de la classe concrète, c'est à dire les choses que l'on ne sait pas faire dans la classe abstraite puisque cela va dépendre des spécificités de la classe fille.

Par exemple, la classe abstraite Number peut définir les méthodes byteValue() et shortValue(), en se basant sur la méthode abstraite intValue() :

// class abstract Number

    public abstract int intValue();

    public byte byteValue() {
        return (byte) intValue();
    }

    public short shortValue() {
        return (short) intValue();
    }

Ainsi, la classe Integer a juste à définir la méthode intValue() pour que ces trois méthodes soient utilisables, les deux dernières se déduisant de la première.
NB. En réalité la classe Integer redéfinit quand même ces méthodes pour des questions de performance.

les méthodes "doubleValue(),intValue() ...etc" sont identiques.
Les méthodes doubleValue() et intValue() ne sont certainement pas identiques, si elles l'étaient ça ne serviraient à rien d'avoir deux méthodes au lieu d'une seule...
Par contre doubleValue() et intValue() sont abstraites dans Number parce que leur implémentation va dépendre de classe fille.

La classe Integer extends Number les définira comme ceci :

private final int value,

    public int intValue() {
        return value;
    }

    public double doubleValue() {
        return (double) value;
    }

La classe Double extends Number comme ceci :

private final double value;

    public int intValue() {
        return (int) value;
    }

    public double doubleValue() {
        return value;
    }

Et pour d'autres classes héritant de Number on pourrait avoir beaucoup plus de code pour définir ces deux méthodes, c'est le cas de BigInteger où la méthode doubleValue() fait une quarantaine de lignes.

Et les autres sont vides dans la classe abstract "Comparable".
Je n'ai pas compris ce que tu voulais dire par "les autres sont vides", mais je tiens à rappeler que Comparable<T> n'est pas une classe, mais une interface !
Elle définit une méthode int compareTo(T o), que la classe Integer est également obligée d'implémenter pour respecter son contrat :

    public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }

    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }