Programmation Orientée Objet
Chapitre 4: Héritage et Interface
Dr. Mouna Chebbah
Dr. Mouna Chebbah
L2BC
ESEN
Semestre 1, 2020
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
1/37
Principe (1/3)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Définition d’une hiérarchie de types:
§ T: un super-type. C’est un type qui a un ou plusieurs
sous-types.
§ ST: un sous-type de T.
§ Un super type T peut avoir plusieurs sous-type {ST1, . . . ,
STn}.
§ Un sous-type ST ne peut avoir qu’un seul super-type T.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
2/37
Principe (2/3)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
3/37
Principe (3/3)
D’une façon générale:
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Toute instance d’un sous-type ST possède des propriétés, des
variables et des méthodes, définies par un super-type T de ST.
§ Toute opération definie par T (utilisant ces variables) est
applicable aux instances de ST. Il n’est pas nécéssaire de la
définir lorsqu’on définit ST.
§ Les méthodes définies par T sont applicables aux instances de
T et de ST. Elles sont polymorphes. ST est un type
polymorphique.
§ Toutes les propriétées de ST définies au niveau de T, sont
dites héritées par ST.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
4/37
Héritage
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
La relation “est sous classe de” induit un héritage.
Une sous-classe hérite tous les membres non-privés de sa
super-classe.
L’héritage facilite la réutilisation du code et la gestion de son
évolution en factorisant les propriétés et des opérations partagées
par différents objets.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
5/37
Exemple
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
6/37
Exemple
public class Forme {
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
private float dim1, dim2; //Longueur et largeur d’une forme
protected float x;
Forme(){ }//Constructeur de la classe Forme
float superficie(){ //calcule la supérficie d’une forme
. . . }
. . .
}
public class Carre extends Forme {
. . .
}
La classe carré hérite l’attribut x et aussi les attributs dim1 et
dim2.Les attributs dim1 et dim2 sont privés, ils ne peuvent pas
être directement manipulé dans la classe carré. La classe carré
hérite également la méthode superficie.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
7/37
Héritage des définitions structurelles
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Une instance d’une classe possède autant de champs qu’il y a
d’attributs dans sa classe et sa super-classe.
Exemple:
public class Forme {
private float dim1, dim2;
protected float x;
. . .
}
public class Carre extends Forme {
private String couleur;
. . .
}
Une instance de la classe carré aura comme champs les valeurs des
attributs x, dim1, dim2 et couleur.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
8/37
Constructeur et héritage
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Le constrcuteur de la sous-classe ST initialise les attributs
hérités a travers l’appel du constructeur de la classe mere T.
§ Le constructeur d’une sous-classe ST appelle le constructeur
de la classe mère T avec l’instruction super(...).
Exemple:
public class Forme {
private float dim1, dim2;
protected float x;
Forme(float
lar){
dim1=long;
dim2=lar;}
. . . }
long,
float
public class Carre extends Forme
{
private String couleur;
Carre(float cote, String c){
super(cote,cote);
couleur=c;}
. . . }
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
9/37
Héritage de méthodes
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Toute méthode définie sur une super-classe T est applicable
aux instances des sous-classes de ST.
Exemple:
public class Forme {
private float dim1, dim2;
public class Carre extends Forme {
Forme(float long, float
private String couleur;
lar){
dim1=long;
dim1=lar;
}
Carre(float cote, String c){
super(cote,cote);
couleur=c;}
float superficie(){
return (dim1ˆ dim2)}
}
. . .
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
Publicité
10/37
Exemple
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public static void main(String[] args) {
Carre car=new Carre(5,”Rouge” );
System.out.println(“La superficie du carré est de
”+car.superficie()); }
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
11/37
Appel de méthodes hérités
dans une sous-classe
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Les attributs hérités qui sont déclarés “public” et “protected”
peuvent être utilisés directement dans une classe descendante.
§ Les attributs déclarés privés, ne sont pas accéssible
directement dans les classes descendantes. Il faut, donc,
utiliser les getters et setters de ces attributs hérités.
§ L’appel d’une méthode héritée se fait par l’instruction:
Super.Nomdelamethode (param1, param2, . . . ),
sachant que la méthode Nomdelamethode (param1, param2,
. . . ) est définie dans la classe mère.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
12/37
Exemple (1/2)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Forme {
private float dim1, dim2;
Forme(float long, float lar){
dim1=long;
dim2=lar;
}
float superficie(){
return (dim1ˆ dim2)}
float getdim1(){
return (dim1)}
float getdim2(){
return (dim2)}
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
13/37
Exemple (2/2)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Carre extends Forme {
private String couleur;
Carre(float cote, String c){
super(cote, cote);
couleur=c;}
void afficherD(){//Affiche les données d’un carré//
System.out.println(“Le carré mesure “+super.getdim1()+”” de
couleur “+ couleur+ “et de superficie “+ super.superficie()) }
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
14/37
La classe Object
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Object est la classe racine. Toutes les classes héritent de la
classe Object.
§ Dans la classe Object sont définies les méthodes applicables à
tous les objects. Par exemple:
§ la méthode equals qui test d’égalité logique de deux objets,
§ la méthode toString fabriquant une chaˆıne de caractère
représentative du receveur.
Exemple:
new Point(3, 4). equals ( new Point(3, 4));
´ ą true
new Point(1, 2). toString();
´ ą“1@2”
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
15/37
Redéfinition de variables
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Les sous classes peuvent redéfinir les variables: il suffit de les
re-déclarer sous le même nom avec un type différent
Exemple:
public class Forme {
protected float dim1;
protected float dim2;
protected float x;
. . .
}
public class Carre extends Forme {
private int x;
. . .
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
16/37
Redéfinition de méthodes
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
La redéfinition consiste à redéfinir (reprendre), dans une classe
descendante, une méthode définie la classe mère. Généralement, la
méthode redéfinie est une extension de la méthode décrite dans la
classe mère.
§ Les sous-classes peuvent redéfinir les méthodes héritées: il
suffit de les réecrire avec le même nom, même type de retour
et le même nombre d’arguments ayant les mêmes types.
§ Un constructeur d’une sous-classe ST qui hérite de T peut
étendre le constructeur de T:
§ le constructeur de ST appelle le constructeur de T avec
l’instruction super(...).
§ le conctructeur de ST peut contenir d’autres instructions à
part l’appel du constructeur de T.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
17/37
Exemple
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Forme {
protected float dim1, dim2;
public class Carre extends Forme {
Forme(float long, float
super(c,c);}
Carre(float c){
lar){
dim1=long;
dim2=lar;}
float superficie(){
return (dim1ˆ dim2)}
. . .
}
float superficie(){
float s=super.superficie();
System.out.println(“La superficie
du carré est ”+s);
return (s);}
. . .
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
18/37
Surcharge de méthodes
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Les sous-classes peuvent surcharger les méthodes héritées.
Exemple
public class Forme {
private float dim1, dim2;
public class Carre extends Forme
{
private float c;
Forme(float long, float
lar){
dim1=long;
dim2=lar;}
Publicité
Carre(float x){
super(c,c);
c=x;}
float superficie(){
return (dim1ˆ dim2)}
. . .
}
double superficie(){
return (cˆ c);}
. . .
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
19/37
Exercice (1/4)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Ecrire une classe Personne qui permet de gérer un individu, cette
classe dispose des attributs suivant: nom, prénom et âge. De plus,
elle a 4 méthodes :
1. Un constructeur de la classe Personne.
2. Une méthode void afficherInfos() qui affiche les informations
d’une Personne.
3. Une méthode int getAge() qui retourne la valeur de l’attribut
age.
4. Une méthode void setAge(...) qui modifie la valeur de
l’attribut age.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
20/37
Exercice (2/4)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Ecrire une classe Enseignant, sous la classe Personne, cette classe
dispose des attributs suivants: spécialité, grade et salaire. De plus,
elle a 2 méthodes:
1. Un constructeur de la classe Enseignant appelant le
constructeur de la classe mère par super, puis initialisant ses
champs propres.
2. Une méthode void afficherInfo() qui redéfinit la méthode
afficherInfo() de sa classe mère et qui affiche les informations
d’un Enseignant.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
21/37
Exercice (3/4)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Ecrire une classe Etudiant, sous la classe Personne, cette classe
dispose des attributs suivant : numéro étudiant, spécialité, nombre
de matieres, les notes des quatre matieres étudiées au cours de
l’année et leurs coefficients et l’année en cours (une variable de
classe). De plus, elle a 4 méthodes:
1. Un constructeur de la classe Entudiant appelant le
constructeur de la classe mère par super, puis initialisant ses
champs propres.
2. Une méthode void ajouterCours(...) qui permet d’ajouter une
matière, son coefficient et la note correspondante.
3. Une méthode void afficherCours() qui permet d’afficher une
matière, son coefficient et la note correspondante.
4. Une méthode Double moyenneE() qui permet de calculer la
moyenne d’un étudiant pendant l’année en cours.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
22/37
Exercice (4/4)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Ecrire une classe Test qui contient la fonction main() et qui
permet de tester votre programme:
/ Test de la classe Enseignant */
1. Créer une instance de la classe Enseignant.
2. Afficher les informations de cet enseignant.
3. Modifier le salaire de cet enseignant.
4. Modifier l’âge de cet enseignant.
5. Afficher les informations de l’enseignant avec les mises à jour.
/ Test de la classe Etudiant ** /
6. Créer une instance de la classe Etudiant.
7. Afficher les informations de cet étudiant.
8. Ajouter les 4 matières étudiées au cours de l’année, ainsi que les
coefficients et les notes.
9. Afficher les notes de l’étudiant déjà crée.
10. Calculer moyenne de l’étudiant et afficher s’il a réussi l’année
ou pas.
23/37
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
Définition
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Une classe abstraite est une classe incomplète. Elle regroupe
un ensemble d’attributs et de méthodes mais certaines de ses
méthodes ne contiennent pas d’instructions, elles devront être
définies dans une classe héritant de cette classe abstraite.
§ Une classe abstraite est une classe qui ne permet pas
d’instancier des objets, elle ne peut servir que de classe de
base pour une dérivation.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
24/37
Méthode abstraite
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Une méthode abstraite est une méthode non implémentée
§ Uniquement la signature de la méthode abstraite est fournie
(le Nom, les paramètres et le type de retour de la méthode)
Exemple
public abstract class Forme{
private float dim1, dim2;
public Forme(float L, float l){
dim1 = L;
dim1 = l;
}
public abstract float Superficie();
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
25/37
Méthode abstraite
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Une méthode abstraite doit être obligatoirement déclarée
‘’public”, ce qui est logique puisque sa vocation est d’être
redéfinie dans une classe dérivée
§ Dès qu’une classe contient une ou plusieurs méthodes
abstraites, elle est abstraite
§ Les noms d’arguments muets doivent figurer dans la définition
d’une méthode abstraite.
Exemple:
public abstract void methode(int); //Erreur : nom argument fictif
est obligatoire
public abstract void methode(int x); int x est un argument muet
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
26/37
Méthode abstraite
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Une classe dérivée d’une classe abstraite n’est pas obligée de
redéfinir toutes les méthodes abstraites
§ Elle peut ne redéfinir aucune, mais elle reste abstraite tant
qu’il y a encore des méthodes abstraites non implémentées
§ Une classe dérivée d’une classe non abstraite peut être
déclarée abstraite
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
27/37
Exemple: redéfinition des méthodes
abstraites
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Cercle extends Forme{
public Cercle(float rayon) {
super(rayon,2*rayon);}
public float superficie () {
return (rayonrayon3.14); }
}
public class Forme{
Publicité
float dim1, dim2;
public Forme(float d1,float d2) {
dim1=d1;
dim2=d2;}
public static float superficie();}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
28/37
Classe abstraite
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
§ Une classe abstraite peut contenir des méthodes non
abstraites et des déclarations d’attributs.
§ Une classe abstraite est incomplète: elle est donc non
instanciable et doit être héritée =ą on ne peut pas utiliser les
constructeurs d’une classe abstraite et donc on ne peut pas
créer d’objet de cette classe.
§ Une classe est automatiquement abstraite si une de ses
méthodes est abstraite.
§ Une classe qui hérite d’une classe abstraite ne devient
concrète que si elle implémente toutes les méthodes abstraites
de la classe dont elle hérite.
§ Une classe abstraite peut être dérivée en une sous-classe:
§ Abstraite si une ou plusieurs méthodes ne sont pas
implémentées par la classe fille,
§ Non abstraite si toutes les méthodes abstraites sont
implémentées dans la classe fille.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
29/37
Intérêt
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Le recours aux classes abstraites facilite la conception orientée
objet. On peut placer dans une classe abstraite toutes les
fonctionnalités dont on souhaite disposer pour les classes
descendantes :
§ Soit sous la forme d’une implémentation complète de
méthodes (non abstraites) et de champs (privés ou non)
lorsqu’ils sont communs à tous les descendants,
§ Soit sous forme d’interface de méthodes abstraites dont on est
alors sûr qu’elles existeront dans toute classe dérivée
instanciable.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
30/37
Définition
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
Interface: une collection de déclaration de méthodes abstraites et
de variables de classes.
§ Une interface est un type, au même titre qu’une classe, mais
abstrait et qui donc ne peut être instancié (par appel à new
plus constructeur).
§ Une interface décrit un ensemble de signatures de méthodes,
sans implémentation, qui doivent être implémentées dans
toutes les classes qui implémentent l’interface.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
31/37
Utilité
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
L’utilité du concept d’interface réside dans le regroupement de
plusieurs classes, tel que chacune implémente un ensemble
commun de méthodes, sous un même type. Une interface:
§ contient des signatures de méthodes;
§ ne peut pas contenir de variables: les variables déclarées dans
une interfaces sont toutes statiques et finales.;
§ peut hériter d’une autre interface (avec le mot-clé extends);
§ Les classes implémentant une interface doivent définir toutes
les méthodes de l’interface ou doivent être déclarées
abstraites.
§ une classe (abstraite ou non) peut implémenter plusieurs
interfaces. La liste des interfaces implémentées doit alors
figurer après le mot-clé implements placé dans la déclaration
de classe, en séparant chaque interface par une virgule.
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
32/37
Exemple (1/5)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
La classe Forme peut être une interface décrivant les méthodes qui
doivent être implémentées par les classes Rectangle et Cercle, ainsi
que par la classe Carre (même si celle-ci peut profiter de son
héritage de Rectangle). L’interface Forme s’écrit alors de la
manière suivante:
public interface Forme {
public double surface();
public void affiche();
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
33/37
Exemple (2/5)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Cercle implements Forme {
float rayon;
Cercle(float x){
rayon=x;}
double surface(){
return (3.14rayonrayon);}
public void affiche(){
System.out.println(“le cercle est de rayon ”+rayon+” et de
surface ”+surface());}
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
34/37
Exemple (3/5)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Rectangle implements Forme {
float Long, lar;
Ractangle(float x; float y){
Long=x;
lar=y;}
public double surface(){
return Longˆlar;}
public void affiche(){
System.out.println(“le rectangle est de dimension
”+Long+”/”+lar+” et de surface ”+surface());} }
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
35/37
Exemple (4/5)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class Carre extends Rectangle implements Forme {
Carre(float x){
super(x,x);}
public void affiche(){
System.out.println(“le carre qui mesure ”+Long+” est de
surface ”+surface());}
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
36/37
Exemple (5/5)
Héritage
Redéfinition
Surcharge
Classe Abstraite
Interface
public class TestForme {
public static void main(String[] args) {
Carre c=new Carre(5);
Rectangle r=new Rectangle(4,3);
Cercle cer=new Cercle(5);
c.affiche();
r.affiche();
cer.affiche();
}
}
Chapitre 4 - Héritage, M. Chebbah
Semestre 1, 2020
37/37