interface

Le mot-clé PHP interface

Une interface est un contrat : elle liste les méthodes qu'une classe doit fournir, sans préciser comment elles fonctionnent. Toute classe qui implements l'interface s'engage à définir chaque méthode qu'elle déclare. Cela vous permet de programmer contre une capacité ("tout ce qui peut être journalisé", "tout ce qui peut être sérialisé") plutôt que contre une classe concrète.

Les interfaces ne peuvent pas être instanciées directement — il n'y a pas d'implémentation à exécuter. Elles existent pour que des classes sans lien entre elles puissent être traitées de manière interchangeable, à condition de partager les mêmes signatures de méthodes.

Cette page explique comment déclarer une interface, en implémenter une ou plusieurs, partager des constantes, étendre des interfaces et vérifier les types à l'exécution avec instanceof. Si vous débutez avec les objets en PHP, commencez par les classes et objets PHP et ce qu'est la POO.

Syntaxe

Voici la syntaxe de base pour déclarer une interface :

interface MyInterface {
  public function someMethod();
}

Ceci déclare une interface MyInterface avec une seule méthode someMethod(). Règles essentielles :

• Les corps de méthodes sont omis — une interface ne déclare que des signatures, chacune terminée par un point-virgule.
• Toutes les méthodes sont implicitement publiques ; vous pouvez écrire public pour plus de clarté, mais aucune autre visibilité n'est autorisée (private/protected sont interdits).
• Une classe adopte une interface avec le mot-clé implements et doit définir chaque méthode, sinon PHP génère une erreur fatale.

Exemples

Voici quelques exemples pratiques d'utilisation du mot-clé interface. La première classe implémente une interface ; la seconde en implémente deux à la fois (séparées par des virgules) :

<?php

// Example 1
interface MyInterface {
  public function someMethod();
}
class MyClass implements MyInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
}

$obj = new MyClass();
$obj->someMethod();

// Output: This is from someMethod.

// Example 2
interface MyOtherInterface {
  public function someOtherMethod();
}
class MyOtherClass implements MyInterface, MyOtherInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
  public function someOtherMethod() {
    echo "This is from someOtherMethod." . PHP_EOL;
  }
}

$obj2 = new MyOtherClass();
$obj2->someMethod();
$obj2->someOtherMethod();

// Output:
// This is from someMethod.
// This is from someOtherMethod.

Dans ces exemples, nous définissons des interfaces et les utilisons dans nos classes PHP pour nous assurer que nos classes implémentent les méthodes requises.

Constantes d'interface

Une interface peut déclarer des constantes que chaque classe implémentant l'interface hérite. Elles sont toujours publiques et ne peuvent pas être redéfinies, ce qui les rend utiles pour des valeurs partagées et fixes :

<?php

interface HttpStatus {
  const OK = 200;
  const NOT_FOUND = 404;
}

class Response implements HttpStatus {
  public function describe(): string {
    return "Status " . self::OK;
  }
}

echo (new Response())->describe() . PHP_EOL;
echo HttpStatus::NOT_FOUND . PHP_EOL;

// Output:
// Status 200
// 404

Pour les constantes qui peuvent être redéfinies, utilisez plutôt les constantes de classe à l'intérieur d'une classe.

Étendre les interfaces

Contrairement aux classes, une interface peut extend plusieurs autres interfaces. L'interface combinée exige alors toutes les méthodes de chaque interface parente :

<?php

interface Readable {
  public function read(): string;
}

interface Writable {
  public function write(string $data): void;
}

// A single interface that demands both capabilities
interface ReadWrite extends Readable, Writable {}

class File implements ReadWrite {
  private string $buffer = "";
  public function read(): string { return $this->buffer; }
  public function write(string $data): void { $this->buffer = $data; }
}

$f = new File();
$f->write("hello");
echo $f->read() . PHP_EOL;

// Output: hello

C'est ainsi que PHP simule l'héritage multiple — consultez l'héritage PHP pour l'héritage de classe simple avec extends.

Indices de type et instanceof

Étant donné que toute classe implémentant l'interface la satisfait, vous pouvez typer l'interface dans les signatures de fonctions et accepter n'importe quel objet correspondant. Utilisez instanceof pour vérifier à l'exécution :

<?php

interface Shape {
  public function area(): float;
}

class Circle implements Shape {
  public function __construct(private float $r) {}
  public function area(): float { return 3.14159 * $this->r ** 2; }
}

function printArea(Shape $shape): void {
  echo round($shape->area(), 2) . PHP_EOL;
}

$c = new Circle(2);
printArea($c);
var_dump($c instanceof Shape);

// Output:
// 12.57
// bool(true)

Interface vs. classe abstraite

Les deux définissent un contrat, mais elles résolvent des problèmes différents :

• Une interface ne déclare que des signatures de méthodes et une classe peut en implémenter plusieurs. Utilisez-la pour décrire une capacité partagée par des classes sans lien entre elles.
• Une classe abstraite peut fournir des méthodes et des propriétés concrètes ainsi que des méthodes abstraites, mais une classe ne peut en étendre qu'une seule. Utilisez-la pour partager une implémentation entre des classes liées.

Lorsque vous avez besoin de partager du code entre des classes sans héritage, tournez-vous vers les traits.

Avantages

L'utilisation du mot-clé "interface" présente plusieurs avantages, notamment :

• Découplage et flexibilité : les interfaces vous permettent d'échanger des implémentations sans modifier le code dépendant, rendant votre système plus adaptable.
• Tests facilités : elles permettent le bouchonnage et les doublures de test, ce qui simplifie les tests unitaires et le débogage.
• Simulation de l'héritage multiple : étant donné que PHP ne supporte pas l'héritage multiple de classes, une classe peut implémenter plusieurs interfaces pour hériter de contrats de comportement provenant de plusieurs sources.

Conclusion

Le mot-clé interface vous permet de définir un contrat de méthodes requises que n'importe quelle classe peut implémenter, quelle que soit sa place dans la hiérarchie des classes. Combinées aux indices de type et à instanceof, les interfaces rendent le code plus flexible, testable et découplé. Utilisez une interface lorsque vous souhaitez décrire une capacité ; utilisez une classe abstraite lorsque vous avez également besoin de partager une implémentation.

Pratique