Discussion :

[rastakouair]

Bonjour,
J'ai du mal à voir la différence entre :

- étendre une classe abstraite
et
- implémenter une interface

En effet dans les 2 cas on a un "contrat" car on doit réecrire toutes les méthodes...
De plus la classe abstraite et l'interface ne peuvent être instanciés.

La seule différence que je vois c'est que on peut implémenter plusieurs interface alors que l'on ne peux étendre qu'une seule classe abstraite...

Pouvez vous m'éclairer ?

Merci d'avance

[Uther]

Pas tout à fait pour une classe abstraite tu n'est obligé de réimplémenter que les méthodes abstraites, pas toutes comme dans le cas de l'interface.

Par contre comme tu le dit, on peut impléménter autant d'interface que l'on souhaite, alors qu'on ne peux hériter que d'une classe.

[adiGuba]

Salut,

En effet dans les 2 cas on a un "contrat" car on doit réecrire toutes les méthodes...

Dans le cas d'une classe abstraite tu ne dois recoder que les méthodes abstraites.

La classe abstraite peut ainsi proposer une implémentation par défaut ou forcer certaine implémentation (par exemple en utilisant des méthodes final qu'on ne pourra pas redéfinir). Mais cela peut être une "contrainte" pour les classe fille...


Bien souvent dans l'API standard (ou dans d'autres API Java) tu trouveras un principe à 3 niveaux, avec :

• Une interface qui défini le contrat général, tout en laissant l'implémentation totalement libre (exemple : java.util.List).
• Une ou plusieurs classes abstraites, qui implémentent l'interface et proposent une implémentation de certaines méthodes (exemple : AbstractList et AbstractSequentialList).
• Une ou plusieurs classes qui héritent des classes abstraites et proposent donc une implémentation concrètes (exemple ArrayList ou LinkedList).

Ainsi cela laisse les développeurs totalement libre :

• Ils peuvent utiliser une implémentation concrète.
• Ils peuvent se baser sur une classe abstraite pour coder une nouvelle implémentation sans avoir à coder les méthodes les plus basiques.
• Il peuvent implémenter directement l'interface et proposer une implémentation nettement plus spécifique en implémentant toutes les méthodes.

a++

[rastakouair]

Uther > Ok mais si on ne récrit pas toutes les méthodes d'une classe abstraites alors la classe héritée devient aussi une classe abstraite ce qui n'as pas trop d'intéret....

adiGuba > Merci c'est parfait, ton explication est on ne peut plus clair et me satisfait parfaitement !

[Duc Lebowski]

Uther > Ok mais si on ne récrit pas toutes les méthodes d'une classe abstraites alors la classe héritée devient aussi une classe abstraite ce qui n'as pas trop d'intéret....

Je ne vois pas trop le rapport :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
abstract class Animal {
    private int age;
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public int getAge() {
        return this.age;
    }
 
    public abstract int getNombreDePattes();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Chien extends Animal {
    public int getNombreDePattes() {
        return 4;
    }
}

Je n'ai pas réécrit toutes les méthodes de Animal, pourtant je peux t'assurer que mon Chien est bien réel !

[rastakouair]

Duc Lebowski > autant pour moi, j'ai mal lu son commentaire