LES INTERFACES
Les interfaces seront utilisées dans les ateliers qui suivent (atelier Swing, atelier JDBC) donc nous allons définir le principe et le fonctionnement des interfaces dans ce cours.
Attention, ne pas confondre les interfaces que nous allons aborder avec ce qu’on appelle l’interface d’une classe à savoir l’ensemble des données et méthodes publiques de la classe.
Une interface est une classe particulière, en effet une interface peut contenir uniquement des méthodes sans corps (donc abstraites) et des constantes.
Une interface permet de décrire ce que saura faire toute classe qui l’implémentera.
Une interface est une sorte de classe abstraite mais elle ne peut avoir de données (autres que les constantes) et ne peut avoir de méthodes non abstraites.
Elle contient en fait une liste de constantes et/ou une liste de prototypes de méthodes (donc de comportements) qu’il faudra redéfinir dans la classe mettant en œuvre l’interface.
L’héritage multiple de classes est impossible en Java mais l’héritage multiple d’interfaces est possible.
Une classe peut hériter :
. d’un nombre illimité d’interfaces (héritage multiple d’interfaces) (avec le mot-clé implements), attention la classe (si elle n’est pas abstraite) devra redéfinir toutes les méthodes des interfaces qu'elle met en œuvre (c'est à dire dont elle hérite),
. d'au plus une classe normale (avec le mot clé extends).
Une interface peut hériter d’un nombre illimité d’interfaces (avec implements) mais pas de classes normales.
interface Veh_a_moteur
{
int PUISSFISCALE = 1; // Par défaut, c’est static et final
int PUISSREELLE = 2; // Par défaut, c’est static et final
public int rendPuissance(int i); // Par défaut, c’est abstract
public float rendConso(); // Par défaut, c’est abstract
}
interface Veh_flottant
{
public float rendTirantEau(); // Par défaut, c’est abstract
}
public class Bateau_a_moteur implements Veh_a_moteur, Veh_flottant
{
private int puissFiscale;
private int puissReelle;
private float conso;
private float tirantEau;
public Bateau_a_moteur (int pf, int pr, float c, float t)
{
puissFiscale = pf;
puissReelle = pr;
conso = c;
tirantEau = t;
}
public int rendPuissance(int i)
{
If (i==PUISSFISCALE)
return puissFiscale;
else
return puissReelle;
}
public float rendConso()
{
return conso;
}
public float rendTirantEau()
{
return tirantEau;
}
public void affich()
{
System.out.println ("Puissance fiscale : " + rendPuissance(1)); //On peut
// bien sûr utiliser directement la donnée
System.out.println ("Puissance réelle : " + rendPuissance(2));
System.out.println ("Consommation : " + conso);
System.out.println ("Tirant d'eau : " + tirantEau);
}
}
public class Test_Bateau_a_moteur
{
public static void main (String liste[])
{
Bateau_a_moteur b = new Bateau_a_moteur(7,50,30F,1.5F);
b.affich();
}
}
Complément sur les interfaces :
Si une classe ou une interface dérive de plusieurs interfaces qui définissent les mêmes prototypes de méthodes, alors Java considérera que le prototype existe en un seul exemplaire.
Si une classe ou une interface dérive de plusieurs interfaces qui définissent les mêmes constantes, alors la classe ou l’interface devra préfixer le nom de la constante du nom de l’interface dans laquelle elle est déclarée.