Les interfaces en PHP

Pour déclarer une interface, vous devez procéder comme avec une classe, sauf qu'il faut utiliser le mot réservé interface à la place de class.

Si vous voulez respecter les PSRs, vous devez inclure le sufixe Interface dans le nom de l'interface.

Vous pouvez déclarer uniquement des constantes et des signatures de méthodes publiques dans l'interface. Ceci comprend éventuellement des signatures de méthodes magiques comme le constructeur.

Ci-dessous, je déclare l'interface DataInterface. Je déclare une constante et une méthode publique.

<?php interface DataInterface { const PACKSIZE=512; public function getData(): array; }

Pour utiliser une interface, vous devez passer par une classe qui va implémenter l'interface. Pour implémenter l'interface, la classe doit reprendre l'intégralité des signatures et les implémenter.

Ci-dessous, je déclare que la classe DataFile implémente l'interface DataInterface et je code le corps de la signature getData.

<?php class DataFile implements DataInterface { public function getData(): array { echo "getData<br>"; return []; } }

La classe doit respecter la signature. Ca veut dire qu'elle doit respecter :

• La visibilité.
• La liste des paramètres (obligatoires ou optionnels) avec leur type. Le nom d'un paramètre peut être différent (pas conseillé du tout).
• S'il y a une valeur par défaut dans l'interface, alors la classe doit en avoir une. Elle peut être différente.
• Le type de la valeur de retour.

Le fait qu'une classe implémente une interface ne l'empêche pas de pouvoir étendre une classe mère. La classe héritera donc des implémentations qui se trouvent dans la classe mère et des spécifications qui se trouvent dans l'interface.

Attention, on ne peut pas pour autant parler d'héritage multiple, car l'héritage multiple consiste à hériter de plusieurs classes.

Ci-dessous, je déclare une classe CommunDataFile. Puis je déclare que DataFile étend CommunDataFile et implémente DataInterface.

<?php interface DataInterface { public function getData(): array; } class CommunDataFile { public function printData() { echo "printData<br>"; } } class DataFile extends CommunDatafile implements DataInterface { public function getData(): array { echo "getData<br>"; return []; } }

Une classe peut aussi implémenter plusieurs interfaces.

Ci-dessous, je déclare l'interface ConfInterface. Ensuite, je déclare que la classe DataFile implémente deux interfaces, soit DataInterface et ConfInterface.

<?php interface DataInterface { public function getData(): array; } interface ConfInterface { public function getConf(): array; } class DataFile implements DataInterface, ConfInterface { public function getData(): array { echo "getData<br>"; return []; } public function getConf(): array { echo "getConf<br>"; return []; } }

Vous pouvez, en PHP, déclarer qu'une interface étend une ou plusieurs autres interfaces. Un héritage multiple est donc possible au niveau des interfaces ( seulement au niveau des interfaces ).

<?php interface DataInterface { public function getData(): array; } interface ConfInterface { public function getConf(): array; } interface SuperInterface extends DataInterface, ConfInterface{ } class DataFile implements SuperInterface { public function getData(): array { echo "getData<br>"; return []; } public function getConf(): array { echo "getConf<br>"; return []; } }

Regardez ce que l'on peut faire avec cette possibilité 😀. Ci-dessous, j'ai déclaré une interface DataInterface. Elle est implémentée de manière différente par deux classes DataFile et DataBase. DataFile va chercher les données sur fichier. DataBase va chercher les données en database.

Ensuite, je crée une classe PoserQuestion qui a besoin qu'on lui injecte une interface. Je le spécifie dans le constructeur de PoserQuestion en mettant un argument de type DataInterface. Je peux, grâce aux interfaces, injecter (* dynamiquement si besoin) soit l'implémentation DataFile soit l'implémentation DataBase de DataInterface 😉.

<?php interface DataInterface { public function getData(): array; } class DataFile implements DataInterface { public function getData(): array { echo "Je lis les données sur un fichier<br>"; return []; } } class DataBase implements DataInterface { public function getData(): array { echo "Je lis les données en database<br>"; return []; } } class PoserQuestion { private $dataInterface; function make() { $this->dataInterface->getData(); } // Je construirai l'objet avec l'implémentation que l'on m'injectera function __construct(DataInterface $dataInterface) { $this->dataInterface = $dataInterface; } } // Ici je peux instancier dynamiquement soit une classe soit l'autre // J'ai mis les deux pour le test. $df = new DataFile; $db = new DataBase; // C'est ici que je choisis entre fichier et database // J'injecte soit $df soit $db $poserQuestion = new PoserQuestion($df); $poserQuestion->make();