Présentation

• Liste de méthodes dont on donne seulement la signature
• Représente un "contrat", ce qu'on attend d'un objet
• Peut être implémentée par une ou plusieurs classes qui doivent donner une implémentation pour chacune des méthodes annoncées (et éventuellement d'autres).
• Une classe peut implémenter plusieurs interfaces (permettant un héritage multiple, en les séparant par des virgules après le mot implements).
• Toutes les méthodes d'une interface sont implicitement abstraites.
• Une interface n'a pas de constructeurs
• Une interface ne peut avoir de champs sauf si ceux-ci sont statiques.
• Une interface peut être étendue par une ou plusieurs autre(s) interface(s).

En fait, une interface est une classe abstraite dont toutes les méthodes sont abstraites et dont tous les attributs sont constants (des constantes, voir le mot-clé final).

Exemple

Définition de l'interface ;

package org.wikibooks.fr;

public interface Vehicule
{
	public void rouler();
	public void freiner();
}

La présence du modificateur public est implicite et n'est donc pas obligatoire. Cependant, sa présence permet de montrer que ces méthodes seront publiques.

On a défini ici ce qu'on attend d'un objet de type véhicule.

On peut maintenant donner une ou plusieurs implémentations de cette interface grâce à l'utilisation du mot clef implements :

package org.wikibooks.fr;

public class Velo implements Vehicule
{
	// Champs
	private String marque;
	private int rayonRoue;

	// Constructeurs
	public Velo(String marque, int rayonRoue)
	{
		this.marque = marque;
		this.rayonRoue = rayonRoue;
	}

	// Méthodes

	public void rouler()
	{
		// Coder ici la manière dont le vélo roule
	}

	public void freiner()
	{
		// Coder ici la manière dont le vélo freine
	}

	// ... Autres méthodes propres à Velo
}

package org.wikibooks.fr;

public class Auto implements Vehicule
{
	//Champs

	private String marque;
	private int poids;

	// Constructeurs

	public Auto(String marque, int poids)
	{
		this.marque = marque;
		this.poids = poids;
	}

	// Méthodes

	public void rouler()
    {
		//Coder ici la manière dont l'auto roule
	}

	public void freiner()
    {
		// Coder ici la manière dont l'auto freine
	}

    // ... Autres méthodes propres à Auto.
}

Dans cet exemple, nous avons donné deux implémentations de Vehicule.

Conséquences :

• Ces 2 objets peuvent être vus comme des véhicules, c'est ce qu'on appelle le polymorphisme.
• Partout où on attend un objet de type Vehicule, on peut mettre un de ces deux objets.
• Par ce biais, on introduit une couche d'abstraction dans notre programmation ce qui la rend beaucoup plus flexible.

Discussion

Si, par exemple, nous avions une classe Personne possédant une méthode conduire(Vehicule v), on peut alors écrire :

Personne p = new Personne();
p.conduire(new Velo()); //comme la méthode attend un Vehicule en argument, on peut passer tout objet implémentant cette interface.
p.conduire(new Auto()); //idem

On peut "instancier" un Vehicule par le biais de ses implémentations :

Vehicule v = new Auto();
Vehicule t = new Velo();

Dans ce cas v et t sont vus comme des Vehicule et, par conséquent, on ne peut appeler sur ces objets que les méthodes définies dans l'interface Vehicule.