Discutez en sur les forums

Dans Java, les interfaces sont un type particulier de classes, qui permettent à une autre classe d'hériter un comportement auquel elle n'aurait pas accès autrement. Elles définissent des ensembles de méthodes implémentées par les classes du programme.

En standard, Java dispose d'un très grand nombre d'interfaces prêtes à l'usage, réparties dans les différents packages du langage : java.io donne accès à DataInput, ObjectInput et Serializable, par exemple, tandis que java.awt.event donne ItemListener, KeyListener ou encore MouseListener.

Il faut savoir que la hiérarchisation Objet de Java fait qu'une classe ne peut hériter que d'une seule classe, et non plusieurs. Les interfaces sont donc un moyen de se construire un environnement réutilisable pour toutes les classes: il remplace la notion d'héritage multiple, utilisée par d'autres langages Objet, par une syntaxe plus élégante et facile à apprendre/comprendre, et moins ambiguë un programme aux ramifications multiples.

Surtout, les interfaces servent à créer des comportements génériques: si plusieurs classes doivent obéir à un comportement particulier, on créé une interface décrivant ce comportement, on est la fait implémenter par les classes qui en ont besoin. Ces classes devront ainsi obéir strictement aux méthodes de l'interface (nombre, type et ordre des paramètres, type des exceptions), sans quoi la compilation ne se fera pas.

Les interfaces sont très similaires aux classes (une interface par fichier .class...), à la différence que les interfaces ne peuvent être instanciées : elles sont implémentées dans la classe via le mot-clé implements.

Exemple d'implémentation
public interface Animal
  {
  // tous les animaux doivent implémenter les méthodes suivantes
  void manger(String nourriture);
  void seDeplacer();
  void respirer();
  }

public interface Parler
  {
  // une interface plus spécifique
  void parle(int phrase);
  }

public interface Aboyer
  {
  void aboie();
  }

public class Homme implements Animal, Parler
  {
  //implémentations de l'interface Animal
  public void manger(String nourriture)
    {
    System.out.println("Miam, " +nourriture+ "!");
    }
  public void seDeplacer()
    {
    System.out.println("déplacement de l'homme");
    }
  public void respirer()
    {
    System.out.println("respiration de l'homme");
    }

  //implémentations de l'interface Parler
  public void parle(int phrase)
    {
    System.out.println(phrase);
    }
  }

public class Chien implements Animal, Aboyer
  {
  //implémentations de l'interface Animal
  public void manger(String patee)
    {
    System.out.println("Miam, " +patee+ "!");
    }
  public void seDeplacer()
    {
    System.out.println("déplacement du chien");
    }
  public void respirer()
    {
    System.out.println("respiration du chien");
    }

  //implémentations de l'interface Aboyer
  public void aboie()
    {
    System.out.println("Ouaf!");
    }
  }

Par ailleurs, l'un des avantages des interfaces est de dissimuler une implémentation pour la classe qui appelle l'interface, ce qui permet de modifier l'implémentation sans devoir changer la classe appelante. Cela permet d'établir clairement les types d'interactions autorisées entre les objets, et de préparer l'intégration avant d'écrire le reste du code : si une interface doit accepter un type précis de donnée, les classes qui l'implémentent devront s'y plier.

Grâce aux interfaces, le code devient donc plus flexible tout en étant plus strict, et le programme suit constamment le schéma de conception défini au début du projet.