Un raccourci pour définir les quatre coins de la frontière
Dans ce cours nous allons voir :Présentation des interfaces,Création d’une interface,Implémentation d'une interface,Implémentation de plusieurs interfaces,Analogie avec les classes abstraites,Les constantes d'interfaces et Héritage des interfaces
Dans ce cours nous allons voir :
Présentation des interfaces
Création d’une interface
Implémentation d'une interface
Implémentation de plusieurs interfaces
Analogie avec les classes abstraites
Les constantes d'interfaces
Héritage des interfaces
PHP5 permet de gérer les interfaces.
Les interfaces permettent de créer un modèle que les classes qui l'implémentent doivent respecter.
Son rôle donc est de décrire un comportement à notre objet.
Si vous voulez on peut comparer une interface à une prise électrique, elle définit un
standard de "connexion" sans se soucier de quels types d'appareils vont venir s'y connecter
(un téléviseur,machine à laver ou pc ….).
Les interfaces sont très pratiques lorsque plusieurs personnes développent un même projet,
ou lorsqu'on développe un site modulaire.
Techniquement, une interface est une classe entièrement abstraite spéciale, spéciale parce
qu’elle ne fonctionne pas toute seule, elle est toujours implémentée par une autre classe.
Pour bien comprendre ce concept, supposons que vous avez plusieurs classes avec plusieurs
méthodes chacune, et que vous avez par exemple 3 méthodes commune à toutes vos classes
alors vous pouvez si vous le voulez mètre ces 3 méthodes dans une interface que vous
implémente dans vos classe.
Une interface regroupe des méthodes qu'une classe doit implémenter. Ce procédé
permet d'appeler les méthodes d'une classe sans se soucier de leur existence.
Les méthodes déclarées dans une interface ne peuvent être de type private étant donné que
l'on y définit les méthodes que l'on pourra appeler lors de l'instanciation.
Les interfaces permettent également de définir des constantes, il suffit de les y déclarer
à l'aide du mot clé "const"
Une des caractéristiques principales des interfaces est d'obliger les classes qui les
implémentent à créer toutes leurs méthodes. Si ce n'est pas le cas, une erreur sera générée
et c'est là toute la puissance d'une interface car elle nous assure que la classe contient
bien les méthodes qu'elle doit implémenter.
Pour créer une interface on procède de la même manière que lorsqu'on crée une classe. Sauf
qu’à la place d'utiliser le mot clé "class", on utilise le mot clé
"interface".
Exemple 1 :
Exemple : Copier le code
<?php interface IMonInterface { public function Fonc1($name); public function Fonc2($firstName); } ?>
Exemple : Copier le code
< ?php interface IMonInterfaceStatic { static function staticFonc1($name); static function staticFonc2($firstName); } ?>
Une interface étant toute seule, elle est un peu inutile. Il va donc falloir implémenter
l'interface à notre classe
L'implémentation se fait de la même manière que l'héritage, sauf que l'on utilise le mot
clé "implements" au lieu du mot clé extends.
Une classe peut implémenter plusieurs interfaces.
Dans l’exemple ci-dessous, j'ai simplement déclaré une classe "MaClasse" qui implémente
l'interface "IMonInterface".
Ensuite il va falloir créer toutes les méthodes présentes dans l'interface "IMonInterface"
;
Exemple :
Exemple : Copier le code
<?php require_once 'IMonInterface.php'; class MaClasse implements IMonInterface { public function Fonc1($name); { echo $name; } public function fonc2($firstName) { echo $firstName; } } ?>
Si une classe implémente une interface mais n'en redéfinit pas toutes les méthodes, une
erreur sera générée !
Une interface vous oblige à écrire toutes ses méthodes, mais vous pouvez en rajouter autant
que vous voulez.
Pour implémente plusieurs interfaces dans une classe, il faut les séparer par une virgule (
, ).
Dans l’exemple ci-dessous MaClasse implémente deux interfaces ; il faut donc créer toutes
les méthodes contenues dans l'interface "monInterface" ainsi que toutes les méthodes
présentes dans l'interface "monInterfaceStatic".
Exemple :
Exemple : Copier le code
<?php require_once 'IMonInterface.php'; require_once 'IMonInterfaceStatic.php'; class MaClassMultiInterfaces implements IMonInterface, IMonInterfaceStatic { public function Fonc1($name) { echo $name; } public function Fonc2($firstName) { echo $firstName; } static function staticFonc1($name) { echo $name; } static function staticFonc2($firstName) { echo $firstName; } } ?>
Lors de l'implémentation de plusieurs interfaces, il faut faire attention de ne pas créer les mêmes noms de méthodes dans plusieurs interfaces !
Note :
· Une interface ne peut pas lister de méthodes privé abstraites ou finales ;
· Une interface ne peut pas avoir le même nom qu'une classe, et vice-versa
· Vous pouvez très bien implémenter plus d'une interface par classe, à condition
que celles-ci n'aient aucune méthode portant le même nom
Une classe abstraite est une classe qui ne peut pas être
instanciée. Elle est généralement utilisée pour être héritée.
On peut donc utiliser une classe abstraite comme une interface en créant simplement des
méthodes vides.
Il y a cependant quelques inconvénients à utiliser des classes abstraites plutôt qu'une
interface. Par exemple une classe ne peut hériter que d'une seule classe, alors qu’elle
peut implémenter plusieurs interfaces.
Cependant les classes abstraites sont parfois utilisées communément avec les interfaces.
Lorsque il y a beaucoup de méthodes déclarées dans une interface on peut créer une classe
abstraite qui implémente les méthodes de cette interface. Ainsi il suffit d'implémenter
l'interface puis hériter de la classe abstraite associée. Ensuite on surcharge uniquement
les méthodes dont on a besoin.
Les constantes d'interfaces fonctionnent exactement de la même façon que les constantes de classes. Elles ne peuvent être écrasées par des classes qui implémentent
l'interface.
Comme pour les classes, une interface peut hériter d’une autre interface grâce à
l'opérateur extends. Vous ne pouvez réécrire ni une méthode ni une constante qui a déjà été
listée dans l'interface parente.
Exemple :
Exemple : Copier le code
<?php interface iA { public function test1(); } interface iB extends iA { public function test1 ($param1, $param2); // Erreur fatale : impossible de réécrire cette méthode } interface iC extends iA { public function test2(); } class MaClasse implements iC { // On doit écrire les méthodes de iC et aussi de iA public function test1() { } public function test2() { } } ?>
Contrairement aux classes, les interfaces peuvent hériter de plusieurs interfaces à la
fois. Il suffit de séparer leur nom par une virgule.
Exemple :
Exemple : Copier le code
<?php interface iA { public function test1(); } interface iB { public function test2(); } interface iC extends iA, iB { public function test3(); } ?>