La notion d'interface
Programmation objet
Cours n°12
Définition :
L'interface d'un objet est la partie visible de celui-ci par l'utilisateur.
C'est l'ensemble des méthodes que l'utilisateur peut appeler.
L'ensemble des méthodes publiques d'une classe représente donc son interface.
Seule la partie interface d'un objet a besoin d'être connue de l'utilisateur.
Il s'agit souvent de la seule partie documentée d'un objet.
Plusieurs objets peuvent avoir la même interface, s'ils agissent de la même manière.
Prenons par exemple un programme lisant des fichiers multimédia.
Son interface pourrait ressembler à ceci : - Play()
- Pause() - Resume() - Stop()
- FastForward() - FastRewind() - Next()
etc...
Et ce quel que soit le média réellement utilisé : CD audio, fichier MP3, DVD vidéo, etc...
Il est évident que plusieurs objets seront créés pour ce programme .
Ces objets devant pouvoir être utilisés de la même manière, ils utiliseront la même interface.
Chaque objet implémente l'interface MEDIA.
Certains langages objet possèdent cette notion d'interface : une interface n'est pas une classe « normale » pour eux.
Pour le C++, la notion n'existe pas : une interface est en fait une classe abstraite ne possédant que des méthodes virtuelles pures publiques.
Implémenter une interface en C++ revient à hériter en mode public d'une classe abstraite.
Dans d'autres langages OO, la notion d'interface existe et est distincte de la notion de classe.
En C#, par exemple : public interface Imedia {
void f();
void g();
Pour implémenter une interface : }
public class C1 : Imedia {
void f() { ... } void g() {... } }
Exemple de déclaration de MEDIA class iMEDIA
{
public:
virtual void Play()=0;
virtual void Resume()=0;
virtual void Pause()=0;
// etc...
}; Une classe implémentant cette interface devra redéfinir toutes les méthodes de celle-ci (sinon elle restrera abstraite).
class DVD:public iMEDIA{};
class MP3:public iMEDIA{};
En C++ : En C# :
public interface iMEDIA {
void Play();
void Resume();
void Pause();
}
class DVD : iMEDIA {}
class MP3 : iMEDIA {}
Utilisation des interfaces pour augmenter la portabilité
Il arrive fréquemment qu'on souhaite un objet portable, utilisable sur plusieurs plate-formes (ou applications) sans modifications profondes.
Or si cet objet doit utiliser des fonctions, des classes d'une bibliothèque, il risque de perdre cette portabilité, cette indépendance par rapport
à la bibliothèque.
De plus, si vous changez de version et/ou de bibliothèque, votre objet devient inutilisable.
Pour minimiser ces problèmes, on définit souvent une interface entre la bibliothèque et l'objet.
Exemple : utilisation de fonctions de dessin
Typiquement, l'affichage graphique est fortement lié à la plate-forme et/ou au framework utilisé pour le développement.
Exemple : la VCL de C++ Builder avec les objets TCanvas, etc...
L'idéal, si l'on a besoin d'utiliser des fonctions d'affichage, est de définir une interface d'affichage, possédant les méthodes dont on a besoin,
et d'implémenter autant de fois que nécessaire cette interface sur des systèmes différents. A chaque portage, seule une nouvelle classe,
implémentant l'interface, sera créée.
Programme Objet
« dessinateur »
VCL
CLX
OpenGL INTERFACE
Partie portable Modifs mineures
Partie spécifique
class iAffichage {
public:
virtual void Rectangle(int, int, int, int)=0;
virtual void Ellipse(int, int, int, int)=0;
virtual void DessineTexte(int,int,string)=0;
// etc...
};
Nous définissions ici une interface pour pouvoir dessiner.
Dans nos objets et/ou programme, nous dessinerons via un pointeur ou une référence vers un iAffichage, sans nous soucier de son type réel grâce au polymorphisme dynamique.
Si nous souhaitons utiliser la classe TCanvas de la VCL, par ex : class DessineVCL : public iAffichage
{
private:
TCanvas *Canvas;
public:
DessineVCL(TCanvas *C):Canvas(C){}
void Rectangle(int,int,int,int);
void Ellipse(int,int,int,int);
void DessineTexte(int,int,string);
//.... etc....
};
Département Informatique Département Informatique
Dans notre objet et/ou programme, pour dessiner, un pointeur sur iAffichage sera utilisé :
iAffichage *pa_affiche;
// ... allocation et initialisation de l'objet pa_affiche->Rectangle(10,20,30,40);
Si l'objet « qui dessine » utilise en paramètre un pointeur sur iAffichage, il n'a aucun lien direct avec la VCL et donc reste portable.
Il suffira de l'appeler en lui transmettant une instance de DessineVCL, et par polymorphisme les bonnes fonctions seront utilisées.
un pointeur intelligent à la place du « vrai » pointeur
Imaginons maintenant un portage du même programme utilisant une autre bibliothèque que la VCL.
Il suffit d'écrire une classe implémentant l'interface iAffichage
class AfficheAutreBiblio : public iAffichage {
public:
void Rectangle(int,int,int,int);
void Ellipse(int,int,int,int);
//--- etc...
};
RESUME
Une interface est la partie publique d'un objet.
En C++ une interface est une classe ne contenant que des méthodes virtuelles pures.
Implémenter une interface revient à hériter en mode public de la classe.
Ce système permet, entre autres, de garantir l'indépendance des différents objets entre eux...
Une classe peut implémenter plusieurs interfaces (et même hériter en outre d'une autre classe).
En C# (ou en Java) une interface est un type spécifique.
Implémenter une interface est différent de l'héritage.
Prochain cours :
Exemples de conception objet
A la semaine prochaine !
