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.
1
Qu’est-ce qu’une interface ?
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.
2
Exemple
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.