Abstraction de classes
Surcharge
Les classes et les objets
PHP Manual

## Interfaces

Les interfaces objet permettent de créer du code qui spécifie quelles méthodes une classe doit implémenter.

Les interfaces sont définies en utilisant le mot-clé interface, de la même façon qu'une classe standard mais sans aucun contenu de méthode.

Toutes les méthodes déclarées dans une interface doivent être publiques.

### implements

Pour implémenter une interface, l'opérateur implements est utilisé. Toutes les méthodes de l'interface doivent être implémentées dans une classe ; si ce n'est pas le cas, une erreur fatale sera émise. Les classes peuvent implémenter plus d'une interface en séparant chaque interface par une virgule.

> Note: Une classe ne peut implémenter deux interfaces qui partagent des noms de fonctions, puisque cela causerait une ambiguïté.

> Note: Les interfaces peuvent être étendues comme des classes en utilisant l'opérateur extends.

> Note: La classe implémentant l'interface doit utiliser la même méthode de signature que celle définie dans l'interface. Si vous ne le faîtes pas, une erreur fatale sera émise.

### Les constantes

Les interfaces peuvent contenir des constantes. Les constantes d'interfaces fonctionnent exactement comme les constantes de classe à l'exception qu'elles ne peuvent pas être écrasées par des classes ou des interfaces qui en héritent.

### Exemples

Exemple #1 Exemple d'interface

`<?php
// Declaration de l'interface 'iTemplate'
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// Implémentation de l'interface
// Ceci va fonctionner
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}
// Ceci ne fonctionnera pas
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
}
?>`

Exemple #2 Les interfaces extensibles

`<?php
interface a
{
public function foo();
}
interface b extends a
{
public function baz(Baz $baz);
}
// Ceci fonctionnera
class c implements b
{
public function foo()
{
}
public function baz(Baz $baz)
{
}
}
// Ceci ne fonctionnera pas et soulèvera une erreur fatale
class d implements b
{
public function foo()
{
}
public function baz(Foo $foo)
{
}
}
?>`

Exemple #3 L'héritage de plusieurs interfaces

`<?php
interface a
{
public function foo();
}
interface b
{
public function bar();
}
interface c extends a, b
{
public function baz();
}
class d implements c
{
public function foo()
{
}
public function bar()
{
}
public function baz()
{
}
}
?>`

Exemple #4 Les interfaces avec des constantes

`<?php
interface a
{
const b = 'Constante de l\'interface';
}
// Affiche: Constante de l'interface
echo a::b;
// Ceci ne fonctionnera pas de toutes façons vu qu'il n'est pas autorisé
// d'écraser des constantes.
class b implements a
{
const b = 'Constante de classe';
}
?>`

Une interface, avec le typage, fournit une bonne façon de vous assurer qu'un objet particulier contient des méthodes particulières. Repportez-vous à l'opérateur instanceof et au typage.

Abstraction de classes
Surcharge
Les classes et les objets
PHP Manual