Une interface est un modèle d'implémentation, permettant de mettre en relation des entités sans rapports.

Une interface, définissant un protocole de comportement, est un élément que des objets sans liens utilisent pour interagir entre eux.

La déclaration d'une interface s'effectue par l'intermédiaire de l'instruction interface.

interface NomInterface {
  //...
}

De plus, PHP ne permettant pas l'héritage multiple, l'utilisation des interfaces permet de palier à cette carence dans la mesure où une classe peut désormais implémenter plusieurs interfaces.

L'instruction implements permet d'indiquer que la classe fournit une implémentation pour une ou plusieurs interfaces. Ce mot clé doit toujours être placé après la clause d'extension introduite par extends.

class NomClasse implements NomInterface, ..., NomInterfaceN {
   //...
}

Les interfaces possèdent en général dans leur bloc d'instructions, des déclarations de méthodes sans corps ainsi que des déclarations de variables.

// Déclaration d'une méthode
modificateur_acces function nomMethode();
// Déclaration d'une variable
const nomVariable = valeurConstante;

Toutes les méthodes contenues dans une interface sont implicitement déclarées publiques et abstraites.

Les méthodes ne peuvent être déclarées avec le modificateur static.

Toutes les variables, en fait des constantes, contenues dans une interface doivent être déclarées avec le modificateur const. Elles doivent avoir une valeur constante d'affectation.

Toutes les classes implémentant une interface doivent possèder les méthodes déclarées dans cette dernière en y ajoutant un bloc d'instructions.

interface ValidationEnvoi {
  const PRIX_TIMBRE = 0.46;
  public function Poste(float timbre, String adr_exp);
  public function PossedeUnTimbre();
  public function PossedeUneAdressedExpedition();
  public function Envoi();
}
class Lettre implements ValidationEnvoi {
  $nb_timbre
  $adr_exp = null;
  $valide_timbre = false;
  $valide_adresse = false;

  public function Poste($timbre, $adr_exp) {
    $this->nb_timbre = timbre;
    $this->adr_exp = adr_exp;
  }

  public function PossedeUnTimbre() {
    if ($this->nb_timbre > 0)
      return $this->valide_timbre = true;
    else
      return $this->valide_timbre = false;
  }

  public function PossedeUneAdressedExpedition() {
    if (is_null($this->adr_exp))
      return $this->valide_adresse = true;
    else
      return $this->valide_adresse = false;
  }

  public function Envoi() {
    if ($this->valide_timbre && $this->valide_adresse)
      return true;
    else
      return false;
  }
  public function PrixTimbres() {
    return $this->nb_timbre * self::PRIX_TIMBRE;
  }
}
$adresse = "Mlle Julie LAMYrn"
               . "10 Allée d'Artoisrn"
               . "93330 Neuilly Sur Marne";
$affranchissement = 1;

$envoiLettre = new Lettre();

$envoiLettre->Poste(affranchissement, adresse);

echo "Adresse d'expedition : " .
    ($envoiLettre->PossedeUneAdressedExpedition() ? "Oui" : "Non");

echo "Affranchissement : " .
    ($envoiLettre->PossedeUnTimbre() ? "Oui" : "Non");

echo "Procedure d'envoi validee : " .
    ($envoiLettre->Envoi() ? "Oui" : "Non");

Les interfaces ne peuvent implémenter d'autres interfaces. Par contre, elles peuvent hériter de plusieurs autres interfaces.

public interface NomInterface 
              extends AutreInterface, ..., AutreInterface {
  //...
}

Le bloc d'instructions des interfaces contient essentiellement des déclarations de constantes et de méthodes abstraites.

Les interfaces constituent une catégorie particulière des classes abstraites.