Abstraction et utilisation des interfaces
Abstraction et utilisation des interfaces
Programming, Math · course
Voir tous les documents en programmationTous les cours en programmation
Fiche de révisionFiche de cours
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document traite de l'abstraction en programmation orientée objet, en se concentrant sur les classes abstraites et les interfaces. Il s'adresse aux étudiants en informatique ou en génie logiciel souhaitant comprendre ces concepts fondamentaux pour concevoir des applications modulaires et évolutives.
Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert uniquement de base pour d'autres classes qui en héritent. Ce mécanisme facilite la conception orientée objet en permettant de définir des fonctionnalités communes sous forme de méthodes abstraites, dont l'implémentation sera assurée dans les classes dérivées.
Dans une classe abstraite, on trouve :
Le mot-clé abstract est utilisé pour déclarer une classe ou une méthode abstraite. Une classe possédant au moins une méthode abstraite doit elle-même être déclarée abstraite.
Remarques importantes :
abstract ne peut pas être utilisé avec des attributs.public abstract class NomClasseAbstraite {
...
public abstract typederetour NomMethodeAbstraite(type param1, type param2, ...);
}
public class NomClasseFille extends NomClasseAbstraite {
public typederetour NomMethodeAbstraite(type param1, type param2, ...) {
// implémentation de la méthode abstraite
}
}
public abstract class Etudiant {
...
public abstract double calculMoyenne(); // méthode abstraite sans code
...
}
public class Etudiant1et2 extends Etudiant {
...
public double calculMoyenne() {
return (note1 + note2) / 2;
}
}
public class Etudiant3 extends Etudiant {
...
public double calculMoyenne() {
return ((note1 * 2) + notePFE) / 3;
}
}
Les interfaces permettent d'appliquer un mécanisme d'abstraction similaire aux classes abstraites, tout en autorisant l'héritage multiple. Une interface est un ensemble de constantes et de déclarations de méthodes, sans implémentation. Toute classe qui implémente une interface doit fournir le code de toutes les méthodes déclarées dans cette interface.
Une interface est déclarée avec le mot-clé interface et est implicitement abstraite. Une classe intègre une interface avec le mot-clé implements. Une classe peut implémenter plusieurs interfaces.
[public] interface nomInterface [extends nomInterface1, nomInterface2, ...] {
// méthodes et constantes statiques
}
[Modificateurs] class nomClasse [extends superClasse]
[implements nomInterface1, nomInterface2, ...] {
// méthodes et champs
}
public interface InterfaceEtudiant {
public void AfficherEtudiant();
public void saisir();
public double calculmoyenne();
public void afficherMoyenne();
}
public class Etudiant implements InterfaceEtudiant {
...
// implémentation de toutes les méthodes de l'interface
}
abstract n'est pas utilisé.static et final implicites).