Chapitre 5 classes abstraites et interfaces

CHAPITRE 5
CLASSES ABSTRAITES ET
INTERFACES

1. Idée de base des classes abstraites
Lorsque nous représentons une classe comme un type, nous partons de l’hypothèse que
des objets de ce type seront instanciés. Ce n’est pas toujours vrai.
Une classe concrète est une classe qu’on instancie pour obtenir des objets.
Par opposition à la classe concrète, une classe abstraite ne peut pas être instanciée.
Les classes abstraites sont utilisés en héritage pour permettre d’avoir de superclasses
appropriées dont d’autres classes peuvent hériter l’interface et l’implantation.
La super classe Employé est définie comme classe abstraite. L’objectif sera d’obliger les
classes filles de redéfinir la méthode abstraite calculSalaire(). Cette méthode ne sera pas
implémentée dans la classe Employé mais elle le sera dans les classes filles concrètes.
Ainsi, le mécanisme des classes abstraites permet de définir des comportements (méthodes)
qui devront être implémentés dans les classes filles, mais sans implémenter ces
comportements.
2. Définir des classes abstraites
Une classe devient abstraite à l’aide du mot clé abstract.
Syntaxe:
public abstract class <Nom_Classe> { … }
Une méthode abstraite est une méthode dont on donne l’entête mais sans donner son
implémentation (son corps), suivie d’un point-virgule.
Une méthode abstraite est aussi déclarée avec le mot clé abstract.
Exemple :
public abstract class Employe {
public abstract void calculSalaire() ; }

Si on déclare une méthode abstraite dans une classe alors celle-ci doit être abstraite.
Une classe abstraite contient obligatoirement au moins une (ou plusieurs) méthode
abstraite, mais peut contenir aussi d’autres méthodes implémentées.
Une méthode abstraite peut être soit public soit protected mais pas private.
Exemple :
public abstract class Employe { //classe abstraite
protected float salaire;
protected String nom;
public Employe (String n){
nom = n;
}
public void afficher(){
System.out.println("nom = "+ nom + "salaire =" + salaire);
}
protected abstract void calculSalaire(); //méthode abstraite
}
Une classe héritant d’une classe abstraite, doit donner une implémentation à toutes les
méthodes abstraites de sa superclasse (redéfinition) sinon elle doit être déclarée
abstraite (l’abstraction continue).
Exemple :
public class Permanent extends Employe{
public Permanent (String a){
super (a);
}
//redéfinition de la méthode abstraite, sinon Permanent doit être déclarée abstraite
public void calculSalaire(){
super.salaire = Clavier.lireFloat();
}
}
Remarques :
On ne peut pas utiliser new pour instancier une classe abstraite, néanmoins, on peut
déclarer des variables qui font référence à des classes abstraites.
On ne peut pas combiner les modificateurs : abstract et final.
Employe p = new Employe ("ali"); //Erreur car classe abstraite
Permanent p = new Permanent ("ali");
Employe e = p ; //e et p désignent le même objet
e.calculSalaire();// appel de calculSalaire() de Permanent
p.afficher();// appel de afficher() de Employe

3. Les interfaces
Une interface est une forme particulière de classe.
Une interface remplace habituellement une classe abstraite qui ne fournit aucune
implantation à hériter, c’est-à-dire aucune variable d’instance, ni d’implantation par défaut
d’une méthode.
Pour définir une interface, on utilise le mot clé interface.
Syntaxe:
public interface <Nom_Interface> { … }
Une interface correspond à un type comportant uniquement des méthodes abstraites et des
constantes statiques (on n’a pas à préciser les modificateurs : abstract, final et static).
Comme les classes abstraites public, une interface correspond habituellement à un type
public. Elle repose ainsi dans son propre fichier (nom_interface.java).
Exemple :
public interface Employe {
public final static float salaire = 1000;
public abstract void calculSalaire();
public abstract void afficher();
}
Remarques :
Les constantes statiques et les méthodes abstraites d’une interface, ne peuvent pas
être private ou protected.
Les interfaces ne sont pas instanciables.
4. Implémentation des interfaces
Une classe peut implémenter une ou plusieurs interfaces. C’est-à-dire avoir les mêmes
caractéristiques définies au niveau de ces interfaces.
Réciproquement, une interface peut être implémentée par plusieurs classes.
L’implémentation d’une interface par une classe veut dire redéfinir les méthodes abstraites
de l’interface au niveau de la classe concrète.
Pour qu’une classe implémente une interface il faut utiliser le mot clé implements.
Syntaxe:
public class <Nom_Classe> implements <Interface1>, <Interface2>, ...
{ … }

Exemple :
public class Permanent implements Employe{
public String nom;
public float salaire;
public Permanent(String a){
nom = a ;
}
// Redéfinition de la méthode calculSalaire()
float primeMensuelle = Clavier.lireFloat();
// accès à la constante salaire de l’interface par le nom de l’interface
salaire = Employe.salaire + primeMensuelle;
}
// Redéfinition de la méthode afficher()
System.out.println("nom = "+ nom + "salaire =" + salaire);
}
}
Remarque :
Le concept d’interface est proposé en langage Java pour résoudre le problème de
l’héritage multiple.
class Classe_C extends Classe_A, Classe_B { ... }
// Erreur (héritage multiple interdit pour les classes en Java)
class Classe_C implements Interface_A, Interface_B { ... }
// Héritage multiple à travers les inetrfaces

5. Interfaces et héritage
Lors de la définition d’une classe, il est possible de combiner l’héritage avec
l’implémentation d’interfaces.
Il faut commencer par spécifier la classe mère par un extends, puis spécifier la liste des
interfaces par un implements.
Syntaxe:
public class <Nom_Classe> extends <Classe_Base> implements <Interface1>,
<Interface2>, ... { … }
Exemple :
public class Personne {
String nom, prenom;
public Personne (String a, String b){
nom = a;
prenom =b;
}
}
public class Permanent extends Personne implements Employe {
public float salaire;
public Permanent(String a, String b){
super(a,b) ; //Appel du constructeur de la classe mère Personne
}
//Les méthodes afficher() et calculSalaire() de Employe doivent être redéfinie ici
...
}
...
}
}
Une interface peut hériter d’une ou de plusieurs autres interfaces. L’héritage multiple est
autorisé pour les interfaces. Il s’agit d’une extension de propriétés sous forme de
méthodes abstraites et de constantes statiques.
Syntaxe:
public interface <Interface1> extends <Interface2>, <Interface3>, ... { … }

Exemple :
interface MonInterfaceB {
void f();
}
interface MonInterface1 extends MonInterfaceB {
void f1();
}
interface MonInterface2 extends MonInterfaceB{
void f2();
}
interface MonInterface extends MonInterface1, MonInterface2 {
void fd();
}
Les classes implémentant MonInterface doivent implémenter f(), f1(), f2(), et fd().
Remarques :
Une interface peut servir à définir des constantes :
interface Mois{
final int JANVIER = 1, FERVRIER = 2, … DECEMBRE = 12 ;
}
Il est possible de déclarer des références de types interfaces afin de désigner des objets
qui implémentent l’interface en question.
Employe e = new Permanent ("Ali", "Ben Salah");
L’opérateur instanceOf peut être utilisé pour savoir si un objet implémente une
interface donnée.

6. Exercices
Exercice 1 :
1. Ecrire la classe Figure, contenant l’attribut privé nom de la figure et les méthodes
suivantes :
- un constructeur avec argument
- getNom()
- setNom(String)
- une méthode abstraite float calculAire ()
- une méthode abstraite void afficher ()
2. Ecrire la classe Rectangle, contenant les attributs longueur et largeur. Elle dispose des
méthodes suivantes :
- un constructeur par défaut
- un constructeur avec deux arguments
- une méthode calculAire ()
- une méthode afficher ()
3. Ecrire une classe TestFigure qui permet d’instancier un rectangle, de l’afficher et de
calculer son aire.
4. Les instructions suivantes sont-elles correctes et pourquoi ?
a. Figure f = new Figure ("figure");
b. Figure f = new Rectangle ("rectangle");
c. Figure fig = new Rectangle(10,5);
d. Rectangle r = new Rectangle(10,5); fig =r;
5. Ajouter la méthode void affichage () à Figure pour qu’elle affiche la liste des attributs
ainsi que l’aire d’une figure.
Exercice 2 :
1. Ecrire une interface Homme possédant une seule méthode : void indentite() dont le rôle
est d’afficher les informations concernant un homme.
2. Ecrire une classe Personne implémentant cette interface et possédant deux attributs privés
nom et prenom de type String et un constructeur avec argument.
3. Ecrire une classe Client héritant de la classe Personne et implémentant l’interface
Homme avec un attribut privé supplémentaire nommé numero de type entier et un
constructeur avec argument en conséquence.
4. Ecrire une classe Peuple contenant deux attributs privés : un tableau d’Hommes nommé
pays de capacité 100 et un entier nbHommes représentant le nombre d’hommes dans pays.
Cette classe contient aussi deux méthodes :
void naissance (Homme h) : permet d’ajouter un homme dans pays
void explorer () : affiche l’identité de chaque homme dans pays.
5. Dans la méthode void main, tester les méthodes naissance () et explorer () après avoir
placé dans pays des personnes et des clients

Exercice 3 :
Les deux classes C1 et C11 sont abstraites.
Indiquer pour chacun des cas suivants si les instructions sont acceptées par le compilateur ou
non :
1. C1 x = new C1();
2. C1 y = new C11();
3. C1 z = new C111();
4. C1 t = new C12();
5. z = t ;

Chapitre 5 classes abstraites et interfaces

Contenu connexe

Tendances (20)

Similaire à Chapitre 5 classes abstraites et interfaces (20)

Plus de Amir Souissi (19)

Dernier (20)

Chapitre 5 classes abstraites et interfaces