Héritage

 Introduction
 Supposons qu’on veut modéliser les voitures et les motos
en Java → La solution est d’écrire deux classes : une pour
les voitures et une deuxième pour les motos
 Mais, on se rend vite compte que les voitures et les motos
se partagent des propriétés (vitesse, marque, nb_places,
nb_roues…) et des comportements (accélérer, freiner…),
tout en ayant leurs propres spécificités (les voitures
nécessitent un permis de conduire, les voitures peuvent
marcher en arrière…)
 Afin d’éviter de mentionner les propriétés et les
comportements partagés dans les deux classes, la solution
consiste à regrouper tout ce qui est partagé dans une seule
classe à créer (Classe véhicule par exemple)
Mohamed Aymen CHARRADA 23/10/2023
2
  Introduction
 Ainsi, les classes « voiture » et « moto » héritent, chacune,
de la classe « véhicule », les propriétés et les
comportements partagés
 Par la suite, chaque classe rajoute de sa part la définition de
ses propres spécificités
Ce type de relations s’appelle l’héritage
(c’est l’une des notions fondamentales de
la POO)

3 Mohamed Aymen CHARRADA 23/10/2023

  Héritage
 Une classe « B » qui hérite d’une classe « A » : « B »
hérite tous les attributs et les méthodes de la classe « A »
 Dans ce cas :
Classe B Classe A
Sous-classe Super-classe
Dérivée De base
Fille Mère

 L’héritage permet d’implémenter une relation de type

« est un » (une voiture est un véhicule)
 Une classe ne peut avoir qu’une seule classe mère ; il n’y a
pas d’héritage multiple en Java
 Une classe peut avoir plusieurs classes filles
4 Mohamed Aymen CHARRADA 23/10/2023
  Héritage
 Syntaxe de l’héritage :
class Nom_classe_fille extends Nom_classe_mere {
...
}
 On utilise le mot clé « extends » pour indiquer qu'une
classe hérite d'une autre
 En l'absence de ce mot associé à une classe, le compilateur
considère la classe « Object » comme classe mère directe
→ « Object » est la classe supérieure (par héritage
direct ou successif) de toutes les classes en java
 L'héritage permet de définir une hiérarchie de classes.
Chaque nouvelle classe créée intègrera cette hiérarchie
5 Mohamed Aymen CHARRADA 23/10/2023
  Héritage // Classe dérivée
class Enseignant extends Personne
 Exemple {
// Classe de base double salaire;
class Personne { int nb_seances;
String nom; public double charge ( ) { … }
String prenom;
…
int age;
} Personne Object
Public void affiche ( ) { … }
nom
… prenom
}
affiche()
// Classe dérivée
class Etudiant extends Personne {
String groupe;
Etudiant Enseignant
double [ ] notes; Les classes
public double moyenne ( ) { … }
groupe « Etudiant » et salaire
notes « Enseignant » Nb_seances
… moyenne() héritent elles charge()
} de la classe
6 Mohamed Aymen CHARRADA « Object »? 23/10/2023
  Héritage
 Le concept d’héritage permet à la classe fille de :
 Hériter les attributs et les méthodes de la classe de base
 Ajouter ses propres définitions des attributs et des méthodes
 Redéfinir (voir la suite du cours) et surcharger les méthodes
héritées
 En java, il est obligatoire, dans un constructeur d'une
classe fille, de faire appel (explicitement ou
implicitement) à un constructeur de la classe mère
 L’appel implicite d’un constructeur de la classe mère se
fait automatiquement par le compilateur
 L’appel explicite d’un constructeur de la classe mère se
fait à travers le mot clé « super »
7 Mohamed Aymen CHARRADA 23/10/2023
  Mot clé « super »
 Le mot clé « super » peut être utilisé pour :
 appeler un constructeur de la classe mère dans le constructeur de
la classe fille. Cet appel doit être la 1ère instruction dans le
constructeur de la classe fille.
super (liste des arguments effectifs du constructeur
de la classe mère)
 Accéder, dans la classe fille, à une méthode héritée de la classe
mère (optionnel)
super.nom_méthode(liste des arg. effectifs)
 Accéder, dans la classe fille, à un attribut hérité de la classe mère
(optionnel)
super.nom_attribut

8 Mohamed Aymen CHARRADA 23/10/2023

  Mot clé « super »
Constructeur Méthode Attribut

class A { class A {
… … class A {
public A (int a, float b) { public void f (int a) { public int x;
… … …
} } }
} }

class B extends A {
class B extends A { class B extends A {
…
… …
public void f (int a, int b)
public B (int x,float y,int z) public void f ( ) {
{
{ …
…
super(x,y); int a = super.x;
super.f(a);
… …
…
} }
}
} }
ère
1 instruction du }
constructeur appelant Ici, l’utilisation du mot clé
9 Mohamed Aymen CHARRADA « super » est optionnelle 23/10/2023
  L’accès aux propriétés héritées
 Les attributs et méthodes définies avec le modificateur
d'accès « public » restent publiques à travers l'héritage
 Les attributs et méthodes définies avec le modificateur
« private » sont bien héritées mais elles ne sont pas
accessibles directement dans la classe fille
 Une classe fille peut accéder aux attributs ou aux méthodes
de sa classe mère qui sont déclarés « protected ». Un
attribut déclaré « protected » est accessible dans le
paquetage et dans les classes dérivées de sa classe

10 Mohamed Aymen CHARRADA 23/10/2023

  L’accès aux propriétés héritées
 Les modificateurs d’accès (indices de visibilité)
 Le tableau suivant donne la liste des autorisations d’accès pour
chaque modificateur
public protected Néant private
Dans la même classe oui oui oui oui
Dans une classe de même package oui oui oui non
Dans une classe fille d’un autre
oui oui non non
package
Dans une classe quelconque d’un
oui non non non
autre package

11 Mohamed Aymen CHARRADA 23/10/2023

  Exemple 1
 La classe fille et la classe mère sont dans le même
package
class B extends A {

public float c;
class A {
void modifier (int a, int b, float c)
private int x; {
protected int y; x = a;
public double r; y = b;
this.c = c;
void affiche ( ) { }
System.out.println(x + ", "+ y); void affiche_B ( ) {
} affiche ( );
} // ou super.affiche ( );
System.out.println (r +","+ c);
}
Mohamed Aymen CHARRADA } 23/10/2023
12
  Exemple 2
 La classe fille et la classe mère ne sont pas dans le
même package
class B extends A {

public float c;

class A { void modifier (int a, int b, float c)

{
private int x; x = a;
protected int y; y = b;
public double r; this.c = c;
}
void affiche ( ) {
void affiche_B ( ) {
System.out.println(x + “, “+ y);
affiche ( );
}
// ou super.affiche ( );
}
System.out.println (r +”,”+ c);
}
Mohamed Aymen CHARRADA } 23/10/2023
13
  Construction et initialisation des objets dérivés
 Si un constructeur d’une classe fille appelle
explicitement un constructeur d’une classe mère, cet
appel doit obligatoirement être de la première
instruction du constructeur appelant
 Dans le cas général, une classe mère et une classe fille
possèdent chacune au moins un constructeur
 Toutefois, il existe des cas particuliers qui sont :
 cas1 : La classe mère ne définit aucun constructeur
Dans ce cas, si la classe fille veut définir son propre constructeur,
elle peut optionnellement appeler, dans la 1ère instruction de son
constructeur, le constructeur par défaut (qui sera ajouté par le
compilateur) de la classe mère en utilisant l’instruction « super ( )
»
14 Mohamed Aymen CHARRADA 23/10/2023
  Exemple (cas 1)
class A {
// pas de constructeur
}

class B extends A {
public B(…) {
//appel de constructeur par défaut de A (optionnel)
super() ;
}
………
}
Appel du constructeur de « B » qui, à son
B b = new B(…); tour, appelle le constructeur par défaut
Mohamed Aymen CHARRADA
de « A »
15 23/10/2023
  Construction et initialisation des objets dérivés
 Cas2 : La classe fille ne définit aucun constructeur
ou elle définit un constructeur sans arguments
Dans ce cas, le constructeur par défaut/sans arguments de
la classe fille doit appeler :
 Le constructeur par défaut de la classe mère si elle ne possède
aucun constructeur,
 Le constructeur sans arguments de la classe mère si elle possède au
moins un,
 Dans le cas où il n’ y a pas un constructeur sans arguments et il y a
d’autres constructeurs avec arguments dans la classe mère, le
compilateur génère une erreur

16 Mohamed Aymen CHARRADA 23/10/2023

  Exemple (cas 2)
class A {
public A() {…} //constructeur1
public A ( int n) {…} //constructeur2
}

class B extends A {
//pas de constructeur
}
Appel du constructeur par défaut de « B »
B b = new B(); qui, à son tour, appelle le constructeur1
de « A »

17 Mohamed Aymen CHARRADA 23/10/2023

  Exemple (cas 2)
class A {
public A ( int n) {…} //constructeur1
}

class B extends A {
// pas de constructeur
}
On obtient une erreur de compilation car
« A » ne dispose pas d’un constructeur
B b = new B(); sans arguments et « B » utilise un
constructeur par défaut

18 Mohamed Aymen CHARRADA 23/10/2023

  Exemple (cas 1 et 2)
class A {
//pas de constructeurs
}

class B extends A {
//pas de constructeurs
}
Appel de constructeur par défaut de « B »
B b = new B (); qui appelle le constructeur par défaut de
«A »

19 Mohamed Aymen CHARRADA 23/10/2023

  Activité
 Dites si le code suivant est correcte ou non :
class A {
public int x;
public A(int x) {this.x=x;}
}
class B extends A {
public B(int i) {x=x+i;}
}
 Si le code est erroné, proposez une solution pour le
corriger

20 Mohamed Aymen CHARRADA 23/10/2023

  Activité
 Pour les classes A et B définies comme suit:
class A {
public int x;
public A( ) {x=5;}
}
class B extends A {
public B( ) {x++;}
public B(int i) {this(); x=x+i; }
public B(String s) {super(); x--; }
}
 Qu’affichera le code suivant?
B b1=new B(); B b2 =new B(2003);
B b3= new B("Bonjour");
System.out.println(b1.x+" et "+b2.x+" et encore "+b3.x);
21 Mohamed Aymen CHARRADA 23/10/2023
  Dérivations successives
 Une même classe peut être héritée par plusieurs classes
différentes et l’héritage peut s’étendre sur plusieurs
niveaux
Animal

Carnivore Herbivore

Lion Chien Cheval

 Ainsi, la classe « Chien » est une classe fille directe de la

classe « Carnivore » et une classe fille indirecte de la
classe « Animal »

22 Mohamed Aymen CHARRADA 23/10/2023

  Redéfinition et surcharge de membres
 Une classe fille peut surcharger une méthode d’une classe
mère
 La ou les nouvelles méthodes ne seront utilisables que par la
classe fille ou ses descendantes, mais pas par ses ascendantes
 Redéfinition d’une méthode : consiste à conserver la
déclaration (la signature ou l’entête) de la méthode (type et
nombre de paramètres, la valeur de retour et le nom) et
fournir une nouvelle implémentation (un nouveau corp)
 Une classe fille peut redéfinir une méthode héritée d’une
classe mère. Cette nouvelle implémentation masque alors
complètement celle de la super-classe

23 Mohamed Aymen CHARRADA 23/10/2023

  Redéfinition et surcharge de membres
 Si la signature de la méthode change, ce n'est plus une
redéfinition mais une surcharge
 Remarques :
 La signature de la méthode redéfinie doit être strictement
identique à celle de la super-classe : même nom, même
paramètres et même type de retour
 Grâce au mot-clé super, la méthode redéfinie dans la classe fille
peut réutiliser le code écrit dans la méthode de la super-classe

24 Mohamed Aymen CHARRADA 23/10/2023

  Redéfinition et surcharge de membres
 Exemple :
//Classe mère //classe fille
class Graphique { class Cercle extends Graphique {
double rayon ;
private int x, y ; //redéfinition de « surface »
public String couleur ; public double surface ( ) {
return (rayon * 2* 3.14) ;
public void affiche () { }
System.out.print ("Le centre de //redéfinition de la méthode «
l’objet = (" + x + " , " + y + ") " ) ; //affiche »
} public void affiche () {
// appel de affiche de la super-
public double surface ( ) { //classe
return (0) ; super.affiche () ;
} System.out.println (" Le rayon = "+
} //fin de la classe graphiques rayon + " La couleur = " + couleur ) ;
}
}
25 Mohamed Aymen CHARRADA 23/10/2023
  Activité
 Ajoutez un constructeur à trois arguments à la classe
« Graphique » et un constructeur à quatre arguments à la
classe « Cercle »
 Donnez le résultat de l’exécution du code suivant :

Cercle c = new Cercle (2, 4, "rouge", 5.2);

System.out.println (c.surface( ));
c.affiche ( );

26 Mohamed Aymen CHARRADA 23/10/2023

  Redéfinition de méthodes et dérivations successives
 Soit l’arborescence suivante : La présence de (*) signale la
définition ou la redéfinition d’une méthode appelée « f »
L’appel de la fonction « f »
conduira pour chaque classe à
A*
l’appel de la méthode indiquée :

B C*
D* E F
27 Mohamed Aymen CHARRADA
✓ Classe A : Méthode « f » de « A »
✓ Classe B : Méthode « f » de « A »
✓ Classe C : Méthode « f » de « C »
✓ Classe D : Méthode « f » de « D »
✓ Classe E : Méthode « f » de « A »
✓ Classe F : Méthode « f » de « C »
23/10/2023
  Héritage et surcharge des méthodes
 En Java, une méthode fille peut surcharger une méthode
d’une classe ascendante
 Exemple :
class A A a , B b ;
{ int n; float x;
public void f (int n) {…} a.f(n); Appel de f(int) de A
… a.f(x); Erreur, pas de f(float)
} dans A

class B extends A b.f(n); Appel de f(int) de A

{ b.f(x); Appel de f(float) de B
public void f (float n) {…}
…
}

28 Mohamed Aymen CHARRADA 23/10/2023

  Utilisation simultanée de surcharge et de redéfinition
class A { A a , B b ;
public void f (int n) {…..} int n , float x, double y ;
public void f (float n) {…..} a.f(n); Appel de f(int) de A
…
a.f(x); Appel de f(float) de A
}
a.f(y); Erreur, pas f(double)
class B extends A { dans A
// redefinition de la méthode f( Appel de f(int) de B car
//int ) de A b.f(n);
f(int) est redéfinie dans
public void f (int n) {…} B
// Surcharge de la méthode f
b.f(x); Appel de f(float) de A
//de A et de B
public void f (double n) {…} b.f(y); Appel de f(double) de B
…
}

29 Mohamed Aymen CHARRADA 23/10/2023

  Héritage des méthodes statiques
 Une méthode statique héritée ne peut pas être redéfinie
 On peut définir une méthode statique dans la classe fille
avec la même signature d’une méthode statique de la classe
mère. Dans ce cas, la méthode de la classe fille n'est pas une
redéfinition mais elle masque la méthode de la classe mère
class A { class B extends A {
… …
public static void F ( ) { public static void F ( ) { … }
… /*cette méthode n’est une
} redéfinition de F de la classe A
} mais elle masque cette méthode*/
}

 Une méthode statique ne peut être masquée que par une

méthode statique
30 Mohamed Aymen CHARRADA 23/10/2023
 z = m;
 Activité }
 Indiquez quel affichage va int ajoute(int a) { return x+3*a; }
produire l'exécution de la classe public void moi() {
super.moi();
« Essai » System.out.println("z = "+z);
public class Toto { }
int x; }
Toto(int k) { x = k; } public class Essai {
int ajoute(int a) { return x+a; } public static void main (String [] args) {
public void moi() { int a = 2;
System.out.println("x = "+x); Toto p = new Toto(3);
} p.moi();
} System.out.println("ajoute("+ a +") = "+
public class Titi extends Toto { p.ajoute(a));
int y; Titi e1 = new Titi(3, 4);
Titi(int k, int l) { e1.moi();
super(k); System.out.println("ajoute("+ a +") = "+
y = l; e1.ajoute(a));
} Tutu e2 = new Tutu(3, 4, 5);
int ajoute(int a) { return x+2*a; } e2.moi();
} System.out.println("ajoute("+ a +") = "+
public class Tutu extends Titi { e2.ajoute(a));
int z; }
Tutu(int k, int l, int m) { }
31 super(k,Aymen
Mohamed l); CHARRADA 23/10/2023
  Mot clé « final »
 Les classes et les méthodes peuvent être déclarées « final »
 Le modificateur « final » placé devant une classe interdit sa
dérivation
 Exemple :
final class A {
…
}
class B extends A { Erreur car la classe A est déclarée finale
...
}

32 Mohamed Aymen CHARRADA 23/10/2023

  Mot clé « final »
 Le modificateur « final » placé devant une méthode
permet d’interdire sa redéfinition
 Exemple :
class A {
final public void f (int x) {…}
…
}
class B extends A{ Erreur car la méthode f est
public void f (int x) {…} déclarée finale (Pas de
} redéfinition possible)

33 Mohamed Aymen CHARRADA 23/10/2023

  Exercice 1
 Dans les cas suivants, déterminez les classes existantes, dites
s’il y a une relation d’héritage entre les classes et donnez le
sens de la relation si elle existe :
 Un chien est un animal Héritage
 Une voiture contient quatre roues Composition
 Une personne peut être male ou femelle Héritage
 Dans une usine travaillent des techniciens, des ouvriers et des
ingénieurs Agrégation
 Dans un département, on trouve des classes Composition
 Les romans et les dictionnaires sont des livres Héritage
 La ville de Paris est une capitale Héritage

34 Mohamed Aymen CHARRADA 23/10/2023

  Exercice 2
 Dites si les cas suivants sont exactes ou non. Justifiez votre
réponse et proposez des corrections si possible :
Cas 1 Cas 2 Cas 3
class A { class A { class A {
int x, y; public A ( int n) { private int f ( ) {
public A (int a, int b) } return 0;
{ } }
x = a; y = b; }
} class B extends A {
} private int x, y; class B extends A {
public B (int a, int b)
void g ( ) {
class B extends A { {
super(a); super.f( );
int z;
public void f ( ) { } y = b; }
} } }
}

35 Mohamed Aymen CHARRADA 23/10/2023

  Exercice 2
 Dites si les cas suivants sont exactes ou non. Justifiez votre
réponse et proposez des corrections si possible :
Cas 4 Cas 5 Cas 6
class A{ class A { class A {
public void f (int n) { Final void f (int x) { int f ( int a) {
} } return 0;
} } }
}
class B extends A{ class B extends A{
public void f (float n) public void f (int x) { class B extends A {
{ } }
void f ( int x ) {
} }
}
class test { }
public… main (…) {
A a; B b ;
int n; double y ;
36 a.f(y) ; Aymen
Mohamed } } CHARRADA 23/10/2023
  Exercice 3
 Quels résultats fournit le programme suivant ?
class A public class test
{ public void affiche() { {
System.out.print ("Je suis un A"); } public static void main (String[] arg)
} {
class B extends A { } A a = new A() ; a.affiche() ;
class C extends A B b = new B() ; b.affiche() ;
{ public void affiche() { C c = new C() ; c.affiche() ;
System.out.print ("Je suis un C"); } D d = new D() ; d.affiche() ;
} E e = new E() ; e.affiche() ;
class D extends C F f = new F() ; f.affiche() ;
{ public void affiche() { }
System.out.print ("Je suis un D"); } }
}
class E extends B { }
class F extends C { }

37 Mohamed Aymen CHARRADA 23/10/2023

  Exercice 4
 Considérant les deux classes suivantes :
public class A {
public void m1(int i) { }
public void m2 (int i) { }
public static void m3 (int i) { }
public static void m4 (int i) { }
}
public class B extends A {
public static void m1(int i) { }
public void m2 (int i) { }
public void m3 (int i) { }
public static void m4 (int i) { }
}
 Expliquez l’état de chaque méthode de la classe « B » (redéfinition,
surcharge, masque ou autre)

38 Mohamed Aymen CHARRADA 23/10/2023

  Exercice 5
 Etant donné que :
 Une personne est identifiée avec son CIN, son nom et son prénom
 Un employé est une personne qui est identifiée de plus par un
salaire et le nombre d’heures de travail
 Un étudiant est une personne qui est identifiée de plus par son
numéro d’inscription
 Un enseignant est un employé qui identifié de plus par sa spécialité.
1. Développez les classes nécessaires sachant que chaque classe doit
contenir un constructeur d'initialisation variable et doit redéfinir la
méthode « toString() » (qui renvoie une représentation textuelle de
l’objet appelant)
2. Développez la classe principale « Test » qui permet de créer trois
objets : un employé, un enseignant et un étudiant puis afficher leurs
informations
39 Mohamed Aymen CHARRADA 23/10/2023
  Exercice 6  Modifiez la classe « Question »
 Un développeur a écrit la
afin de s’assurer que l’attribut
« difficulte » ne peut prendre
classe suivante : que des valeurs comprises entre
class Question {
private String enonce; 0 et 100
private int difficulte;  On veut représenter les
public Question(String e){ questions QCM. Chaque
this.enonce = e; question à choix multiple a, en
}
public void setDifficulte(int d){
plus d'un énoncé et d'une
this.difficulte = d; difficulté, un ensemble de
} réponses possibles, qui varient
public int getDifficulte(){ entre 2 et 6. Chaque réponse
return this.difficulte; admet une description et une
} valeur de vérité (qui peut être
public String getEnonce(){
return this.enonce;
vraie ou fausse). Proposez le
} code nécessaire pour
} représenter les QCM
40 Mohamed Aymen CHARRADA 23/10/2023
  Exercice 6 (suite)
 Un sujet d’examen est un ensemble de questions (QCM ou
autres) avec un barème (réel). Pour faciliter la tâche, on va
supposer que le nombre de questions dans un sujet ne peut
pas dépasser 10. Créez la classe « SujetExam », qui doit
contenir en particulier une méthode « afficheDiff » qui
permet d’afficher la difficulté moyenne du sujet : La
difficulté moyenne est égale à la somme des difficultés des
questions du sujet, divisée par le nombre de questions.

41 Mohamed Aymen CHARRADA 23/10/2023

42 Mohamed Aymen CHARRADA 23/10/2023