Discussion :

[oliv37]

On utilise un classe abstraite plutôt qu'une interface dans le cas où on veut factoriser du code, ainsi les classes filles auront accès a du code commun sans avoir à le réécrire à chaque fois !
Mais dans quel cas privilégie-t-on l'utilisation d'une interface plutôt qu'une classe abstraite ?

[kolodz]

Bonjour,

Supposons que tu veux faire un service de... génération de phrase.

Ton service va s'engager à mettre à disposition une méthode permettant la génération :

Code :

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

1
2
3
4
interface IStringGenerator{
 
public String generate();
}

Quelque soit le fonctionnement de ton service tu devra respecter cette interface de communication.

L'interface est destiné à définir le processus de communication entre le service et le client. (Si tu me donne de l'argent, je te donne un repas.)
C'est son unique rôle.

L'héritage permet une cohérence entre les classes et la factorisation et le polymorphisme...

Cordialement,
Patrick Kolodziejczyk.

[rg77140]

Bonjour,

On utilise plutôt une classe abstraite quand on veut créer un "template", ce qui revient en partie à dire ce que tu avançais, que c'est pour factoriser du code. Mais pas seulement, c'est aussi factoriser un comportement commun.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public abstract class ModificationAbstract{
 
     public void effectuerModification(Modification modification){
          boolean correcte = verifierModification(modification)
          if(correcte){
               try{
                    executerModification(modification);
               } catch (Exception e){
                    log.error("Erreur à l'exécution de la modification : " + modification, e);
               }
          }
     }
 
     public abstract boolean verifierModification(Modification modification);
 
     public abstract void executerModification(Modification modification) throws Exception;
}

Ainsi chaque classe qui hérite de ModificationAbstract n'a pas à redéfinir la logique d’enchaînement des appels des méthodes (if, try, catch, log). Elle implémente juste le la vérification, et l'exécution de la Modifcation. Elle bouche les trous de ton template en quelque sorte. Jette un œil au "template method pattern" : http://en.wikipedia.org/wiki/Template_method_pattern
L’inconvénient d'une classe abstraite est qu'en Java tu ne peux hériter que d'une classe, donc la classe qui hérite de ta classe abstraite ne pourra pas hériter d'une autre classe.

Une interface sert plus à définir un service que doit fournir un objet. Exemple l'interface List, Collection, Map, ...Chaque classe qui implémente une interface doit remplir un "contrat" en implémentant chacune des méthodes de l'interface. Tu as l'avantages en Java de pouvoir implémenter plusieurs interfaces.

Romain.

[oliv37]

L'héritage permet une cohérence entre les classes et la factorisation et le polymorphisme...

L'implémentation permet également le polymorphisme non ? C'est ce qui se passe pour les List, Map etc...

[kolodz]

Oui, en effet.