Section courante

A propos

Section administrative du site

Interfaces

Une interface est un contrat qui définit un ensemble de méthodes (et parfois de constantes) qu'une classe s'engage à implémenter.

Une interface décrit ce qu'un objet sait faire, sans expliquer comment il le fait.

Rôle fondamental des interfaces

Les interfaces permettent de :

Interface vs classe abstraite

Interface Classe abstraite
Aucun état (ou très limité) Peut avoir des attributs
Contrat pur Implémentation partielle
Héritage multiple possible Héritage simple

Comportement imposé Comportement partagé

Les deux sont complémentaires.

Structure d'une interface

Exemple générique :

  1. interface Payable {
  2.     void payer(double montant);
  3. }

Implémentation d'une interface

  1. class CarteBancaire implements Payable {
  2.     public void payer(double montant) {
  3.         System.out.println("Paiement par carte : " + montant);
  4.     }
  5. }

La classe doit implémenter toutes les méthodes.

Interfaces et polymorphisme

  1. Payable p = new CarteBancaire();
  2. p.payer(100);

Le comportement dépend de l'objet réel.

Interfaces multiples

Une classe peut implémenter plusieurs interfaces.

  1. class Smartphone implements Appelable, Connectable {}

Alternative puissante à l'héritage multiple.

Interfaces et découplage

  1. class ServicePaiement {
  2.     private Payable moyen;
  3.  
  4.     public ServicePaiement(Payable moyen) {
  5.         this.moyen = moyen;
  6.     }
  7. }

Le service dépend d'une abstraction, pas d'une implémentation.

Interfaces et SOLID

Interfaces et injection de dépendances

  1. public class Application {
  2.     public Application(Payable p) {}
  3. }

Les dépendances sont fournies de l'extérieur.

Méthodes par défaut (Java, C#)

  1. interface Logger {
  2.     default void log(String msg) {
  3.         System.out.println(msg);
  4.     }
  5. }

À utiliser avec parcimonie.

Constantes dans les interfaces

  1. interface Erreurs {
  2.     int CODE_OK = 0;
  3. }

Elles sont implicitement public static final.

Interfaces fonctionnelles

Une seule méthode abstraite.

  1. interface Calcul {
  2.     int appliquer(int a, int b);
  3. }

Base des lambdas (Java, C#).

Interfaces et tests unitaires

  1. class FakePaiement implements Payable {}

Remplacement facile pour tests.

Interfaces et design patterns

Pattern Rôle de l'interface
Strategy Comportement interchangeable
Factory Type abstrait retourné
Adapter Contrat cible
Observer Communication découplée
Decorator Extension dynamique

Interfaces en UML

Notation :

  1. <<interface>>
  2. + payer(montant : double) : void

Implémentation :

Interfaces selon les langages

Langage Particularités
Java Méthodes par défaut, privées
C# Implémentation explicite
PHP Pas d'attributs
Python Protocols / ABC
C++ Interfaces via classes abstraites
Free Pascal / Delphi interface natif

Exemple Free Pascal / Delphi

  1. Type
  2.  IPayable = Interface
  3.    Procedure Payer(Montant: Double);
  4.  End;
  5.  
  6.  TCarte = Class(TInterfacedObject, IPayable)
  7.     Procedure Payer(Montant: Double);
  8.  End;

Erreurs fréquentes

Bonnes pratiques

Exemple complet

  1. interface Notification {
  2.     void envoyer(String msg);
  3. }
  4.  
  5. class Email implements Notification {
  6.     public void envoyer(String msg) {
  7.         System.out.println("Courriel : " + msg);
  8.     }
  9. }
  10.  
  11. class Service {
  12.     private Notification notif;
  13.  
  14.     public Service(Notification notif) {
  15.         this.notif = notif;
  16.     }
  17. }

Interfaces et architecture

Les interfaces :

Conclusion

Les interfaces sont la clef de la flexibilité en POO.

Elles permettent de construire des systèmes ouverts, testables et maintenables.

Une bonne interface est un contrat clair, stable et minimal.



Dernière mise à jour : Jeudi, le 1er janvier 2026