Programmation Java/Interfaces

Un livre de Wikilivres.
Aller à : navigation, rechercher


Présentation[modifier | modifier le wikitexte]

  • 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[modifier | modifier le wikitexte]

//Définition de l'interface
 
package cours;
 
public interface Vehicule {
 
	void rouler();
 
	void freiner();
 
}

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 cours;
 
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;
	}
 
	//Methodes
 
	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 cours;
 
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;
	}
 
	//Methodes
 
	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émentation 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[modifier | modifier le wikitexte]

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.