Chapitre 6
Abstraction et utilisation des interfaces
1. Les classes Abstraites
Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle ne peut servir que
de classe de base pour une dérivation (héritage).
Le recours aux classes abstraites facilite largement la conception orientée objet. On peut placer dans
une classe abstraite toutes les fonctionnalités dont on souhaite disposer pour les classes descendantes
sous forme de méthodes abstraites dont on est alors sûr qu’elles existeront dans toute classe dérivée
mais dont on ne sait pas encore leur implémentation.
Dans une classe abstraite, on peut trouver classiquement des méthodes et des champs, dont héritera
toute classe dérivée et on peut trouver des méthodes dites « abstraites » qui fournissent uniquement la
signature (le Nom de méthode, les paramètres de la méthode et le type de retour).
Le mot clé abstract s'applique aux méthodes et aux classes.
Abstract indique que la classe ne pourra être instanciée telle quelle. De plus, toutes les méthodes de
cette classe abstract ne sont pas implémentées et devront être redéfinies par des méthodes complètes
dans ses sous classes.
Remarque
Une classe possédant une méthode abstraite est forcément une classe abstraite.
Une classe abstraite peut ne pas contenir de méthode abstraite.
Une méthode abstraite ne doit pas contenir de code source : juste la déclaration de la
méthode. Elle correspond à une méthode dont on veut forcer l'implémentation dans une sous
classe.
L'abstraction permet une validation du code : une sous classe sans le modificateur abstract et
sans définition explicite d'une ou des méthodes abstraites génère une erreur de compilation.
On ne peut utiliser le mot clés « abstract » avec les attributs
1.1. Syntaxe de déclaration des classes et des méthodes abstraites
public abstract class NomClasseAbstraite {
Publicité
…..
public abstract typederetour NomMethodeAbstraite(type param1, type param2,
…) ;
}
public class NomClasseFille extends NomClasseAbstraite {
public typederetour NomMethodeAbstraite(type param1, type param2,…) {
…….
// définir le code source de la méthode abstraite dans la classe descendante.
}
}
1.2. Exemple
public abstract class Etudiant {
…..
…..
public abstract double calculMoyenne() ; // méthode déclarée sans code source
…..
}
public class Etudiant1et2 extends Etudiant {
…..
…..
public double calculMoyenne() {
return((note1+note2)/2);
}
}
public class Etudiant3 extends Etudiant {
…..
…..
public double calculMoyenne() {
Publicité
return(( (note1*2)+notePFE) / 3);
}
}
2. Les interfaces
Les interfaces permettent de mettre en œuvre un mécanisme d’abstraction et permettent aussi de
mettre en œuvre le principe d'héritage multiple où une classe peut hériter en même temps de
plusieurs super classes.
Une interface est un ensemble de constantes et de déclarations de méthodes correspondant un peu à
une classe abstraite. Toutes les classes qui implémentent une interface possèdent les méthodes et les
constantes déclarées dans celle-ci. Plusieurs interfaces peuvent être implémentées dans une même
classe.
Les interfaces se déclarent avec le mot clé « interface » et sont intégrées aux autres classes avec le
mot clé « implements ». Une interface est implicitement déclarée avec le modificateur « abstract ».
Déclaration d'une interface :
[public] interface nomInterface [extends nomInterface1, nomInterface2 ... ] {
// insérer ici des méthodes ou des champs static
}
Implémentation d'une interface :
[Modificateurs] class nomClasse [extends superClasse]
[implements nomInterface1, nomInterface 2, ...] {
//insérer ici des méthodes et des champs
}
Exemple :
public interface InterfaceEtudiant {
public void AfficherEtudiant();
public void saisir();
public double calculmoyenne() ;
public void afficherMoyenne ();
Publicité
}
public class Etudiant implements InterfaceEtudiant {
………
// il faut donner le code de toutes les méthodes définies dans l’interface sinon une
erreur sera //affichée indiquant qu’il y a une méthode non encore implémentée.
}
Remarques Importantes concernant l’utilisation des interfaces
Une classe qui implémente une interface doit définir le code source de toutes les méthodes
définies dans l’interface. Une erreur sera affichée si le programmeur oublie d’implémenter
une des méthodes définies dans l’interface.
Si la classe qui implémente une interface est définie avec « Abstract », Le programmeur peut
ignorer certaines méthodes qui doivent être implémentées forcement dans les classes
descendantes qui héritent de la classe abstraite. Sinon une erreur sera affichée indiquant
qu’une méthode n’est pas encore implémentée.
Toutes les méthodes d'une interface sont abstraites : elles sont implicitement déclarées
comme telles même si le programmeur ne l’indique pas.
Les seuls attributs que l'on peut définir dans une interface sont des attributs de classe qui
doivent être constantes : elles sont donc implicitement déclarées avec le modificateur
« static » et « final » même si le programmeur utilise d'autres modificateurs.
Une interface peut être d'accès public ou package. Si elle est publique, toutes ses méthodes
sont implicitement publiques même si elles ne sont pas déclarées avec le modificateur public.
Si elle est d'accès package, il s'agit d'une interface d'implémentation pour les autres classes du
package et ses méthodes ont le même accès package : elles sont accessibles à toutes les classes
du packages.