module de programmation

1. Chapitre 4
Héritage & polymorphisme
Cours réalisé par:
Mme Meriem Ennigrou
Support de cours POO
1

2. Définition
2
 Technique permettant de définir une nouvelle classe
appelée classe fille ou sous-classe à partir d’une
classe de base appelée classe mère ou super classe
 La classe fille hérite tous les membres de sa classe
mère : attributs et méthodes et rajoute ses propres
membres qui la diffère de sa classe mère
 JAVA ne permet que l’héritage simple alors que
l’héritage multiple n’est pas accepté. Une classe ne
peut avoir qu’une seule classe mère.
 Syntaxe
class nomClasseFille extends nomClasseBase
{//définition des propriétés spécifiques à la sous-classe}

3. Héritage en JAVA
3
 Une sous-classe ne peut accéder aux propriétés
private de sa classe mère
 Une sous-classe peut accéder aux propriétés
protected, public et par défaut de sa classe mère

4. Héritage en JAVA
4
class c1 {
public int A;
protected int B;
int C;
private int D;
}
class c3 {
...
}
class c5 {
...
}
A B C D
Accessible par c2 o o o -
Accessible par c3 o o o -
Accessible par c4 o o - -
Accessible par c5 o - - -
Package P1 Package P2
class c4 extends c1 {
...
}
class c2 extends c1 {
...
}

5. Redéfinition de méthodes
5
 Il est possible qu’une classe fille redéfinit une des
méthodes de la classe mère  on parle alors de
redéfinition. Dans ce cas, la méthode redéfinie sera
de même nom, de même type et de mêmes
paramètres
 Redéfinition ≠ surdéfinition (surcharge) : méthodes
de même nom mais de paramètres différents
 Une méthode redéfinie dans une sous-classe peut
appeler celle qui est définie dans la super-classe.
 Comme les 2 méthodes sont de même nom et afin
d’éviter l’appel récursif à la méthode de la sous-
classe, on utilise le mot clé super qui désigne la

6. Mot clé super
6
 Le constructeur de la sous-classe peut appeler celui
de la classe mère.
 Le mot clé super désigne dans ce cas le
constructeur de la classe mère
 Attention le constructeur de la classe fille doit
comporter au moins les paramètres de la classe
mère
 L’instruction d’appel du constructeur de la classe
mère doit être la première instruction dans le
constructeur de la classe fille

7. Redéfinition de méthodes - Exemple
7
class Personne
protected String nom;
protected String prenom;
Personne (String n, String p){
this.nom=n;
this.prenom=p;}
public void toString () {
System.out.println(nom + " " + prenom);}
}
class Etudiant extends Personne {
private String groupe;
Etudiant (String n, String p, String g) {
super(n,p);
this.groupe=g;}
pubic void toString(){
super.toString();
System.out.println(" inscrit en " + groupe);}
}

8. Exercice
8
Implémenter les classes Personne, Enseignant et
Etudiant comme suit :
Classe Personne Classe
Enseignant
Classe Etudiant
Attributs nom
prénom
rue
ville
nbPersonnes
specialite
remplaçant *
nbEnseignants
diplomeEnCours
moyenne
nbEtudiants
Méthodes Personne(n,p,r,v)
toString()
nbPersonnes()
ModiferPersonne(r,v)
Enseignant(n,p,r,v,s)
toString()
nbEnseignants()
affecterRemplaçant(e)
Etudiant(n,p,r,v,d,m)
toString()
nbEtudiants
* L’enseignant pouvant remplacer l’enseignant courant en cas de besoin

9. Exercice – Correction
9
public class Personne {
protected String nom;
protected String prenom;
protected String rue;
protected String ville;
protected static int nbPersonnes = 0;
Personne (String n, String p, String r, String v) {
this.nom=n;
this.prenom=p;
this.rue=r;
this.ville=v;
nbPersonnes++;
}
public String toString(){
return nom + " " +prenom + " " +rue+ " " +ville+ " " ;
}

10. Exercice – Correction
10
static void nbPersonnes(){
System.out.println(
"nNombre de personnes :" + nbPersonnes +
"nNombre d’enseignants :" + Enseignant.nbEnseignants() +
"nNombre d’étudiants :" + Etudiant.nbEtudiants());
}
Void modifierPersonne (String rue, String ville){
this.rue=rue;
this.ville=ville;
}
}

11. Exercice – Correction
11
Class Enseignant extends Personne{
private String specialite;
private Enseignant remplacant;
private static int nbEnseignants = 0;
Enseignant (String n, String p, String r, String v, String s) {
super(n,p,r,v);
this.specialite=s;
nbEnseignants++;}
public String toString(){
if (remplacant != null) {return super.toString() + "n
spécialité : " +specialite + "et est remplacé par" +
remplacant.nom + " "+ remplacant.prenom } else {return
super.toString() + "n spécialité : " +specialite };
}
static int nbEnseignants(){reurn nbEnseignants;}
public void affecterRemplacant(Enseignant e) {
remplacant = e;
}
}

12. Exercice – Correction
12
Class Etudiant extends Personne{
private String diplomeEnCours;
private double moyenne;
private static int nbEtudiants = 0;
Etudiant (String n, String p, String r, String v, String d,
double m ) {
super(n,p,r,v);
this.diplomeEnCours=d;
this.moyenne=m;
nbEtudiants++;
}
public String toString(){
return super.toString() + "n Diplôme en cours : "
+diplomeEnCours + "de moyenne " + moyenne;
}
static int nbEtudiants(){return nbEtudiants;}
public double moyenne() {return moyenne;}
}

13. Exercice
13
Ecrire le main dans une autre classe appelée Principale
permettant de créer une personne, un étudiant et
deux enseignants e1 et e2 tels que e2 est le
remplaçant de e1. Ce programme permettra
également d’afficher le nombre de personnes,
d’étudiants et d’enseignants créés à chaque fois

14. Exercice – Correction
14
public class Principale{
public static void main (String [] args){
String a = JOptionPane.showInputDialog("Entrer le nom");
String b = JOptionPane.showInputDialog("Entrer le prénom");
String c = JOptionPane.showInputDialog("Entrer la rue");
String d = JOptionPane.showInputDialog("Entrer la ville");
Personne p = new Personne(a,b,c,d);
System.out.println(p.toString());
p.nbPersonnes();
a = JOptionPane.showInputDialog("Entrer le nom de l’étudiant");
b=JOptionPane.showInputDialog("Entrer le prénom de
l’étudiant");
c = JOptionPane.showInputDialog("Entrer la rue de l’étudiant");
d=JOptionPane.showInputDialog("Entrer la ville de l’étudiant");
String f = JOptionPane.showInputDialog("Entrer le diplôme");
double m = Double.parseDouble(JOptionPane.showInputDialog
("Entrer la moyenne"));
Etudiant e = new Etudiant(a,b,c,d,f,m);

15. Exercice – Correction
15
System.out.println(e.toString());
Personne.nbPersonnes();
Etudiant.nbEtudiant();
a = JOptionPane.showInputDialog("Entrer le nom de
l’enseignant1");
b=JOptionPane.showInputDialog("Entrer le prénom de
l’enseignant1");
c = JOptionPane.showInputDialog("Entrer la rue de
l’enseignant1");
d=JOptionPane.showInputDialog("Entrer la ville de
l’enseignant1");
String g = JOptionPane.showInputDialog("Entrer la spécialité de
l’enseignant1");
Enseignant e1 = new Enseignant(a,b,c,d,g);
a = JOptionPane.showInputDialog("Entrer le nom de
l’enseignant2");
b=JOptionPane.showInputDialog("Entrer le prénom de
l’enseignant2");
c = JOptionPane.showInputDialog("Entrer la rue de
l’enseignant2");

16. Exercice – Correction
16
d=JOptionPane.showInputDialog("Entrer la ville de
l’enseignant2");
String g = JOptionPane.showInputDialog("Entrer la spécialité de
l’enseignant2");
Enseignant e2 = new Enseignant(a,b,c,d,g);
e1.affecterRemplacant(e2);
System.out.println(e1.toString());
System.out.println(e2.toString());
Personne.nbPersonnes();
Etudiant.nbEtudiant();
Enseignant.nbEnseignant();
}
}

17. Exercice
17
Ecrire un autre programme main dans une autre classe
appelée Principale2 permettant de créer un tableau
de 5 étudiants et de calculer la moyenne
arithmétique de leur moyenne

18. Exercice – Correction
18
public class Principale2{
public static void main (String [] args){
Etudiant[] T = new Etudiant[5];
String a = new String();
String b = new String();
String c = new String();
String d = new String();
String f = new String();
double m;
int i;
for (i = 0; i<T.length; i++) {
a = JOptionPane.showInputDialog("Entrer le nom de l’étudiant
" + i);
b = JOptionPane.showInputDialog("Entrer le prénom de
l’étudiant " + i);
c = JOptionPane.showInputDialog("Entrer la rue de l’étudiant
" + i);
d = JOptionPane.showInputDialog("Entrer la ville de
l’étudiant " + i););

19. Exercice – Correction
19
String f = JOptionPane.showInputDialog("Entrer le diplôme");
m = Double.parseDouble(JOptionPane.showInputDialog ("Entrer la
moyenne"));
T[i] = new Etudiant(a,b,c,d,f,m);
}
int s=0;
for (i = 0; i<T.length; i++) s=s+T[i].moyenne();
System.out.println("la moyenne arithmétique est " + s/5);
}
}

20. Les classes et méthodes finales
20
 Une classe est dite finale si elle ne peut plus être
héritée par une autre classe
 Elle correspond à une feuille dans une
représentation arborescente de l’héritage
 Pour déclarer une classe finale on la fait précéder
par le mot clé final
final class nomClasse
 Une méthode déclarée dans une classe mère est
dite finale si elle ne peut plus être redéfinie dans
les classes filles
 Pour déclarer une méthode finale on utilise final
public final type nomMéthode (paramètres)

21. Les classes et méthodes abstraites
21
 Une méthode d’une super-classe est dite abstraite
si elle n’a pas de corps, elle a juste une signature.
 Une méthode abstraite doit donc être redéfinie
dans l’une des sous-classes.
 Une méthode abstraite ne peut pas être exécuté
 Pour déclarer une méthode abstraite on utilise le
mot clé abstract dans son entête.
public abstract type nomMéthode (paramètres)

22. Les classes et méthodes abstraites
22
 Une classe est dite abstraite si elle contient au
moins une méthode abstraite
 Cette classe ne peut pas être instanciée (on ne peut
pas créer d’objets de cette classe)
 Seules les sous-classes qui redéfinissent toutes les
méthodes abstraites sont instanciables
 Pour déclarer une classe abstraite on la fait
précéder par le mot clé abstract
 Une sous-classe d’une classe abstraite ne
redéfinissant pas toutes les méthodes abstraite est-
elle-même abstraite

23. Les classes et méthodes abstraites –
Exemple
23
class abstract Forme{
public abstract double perimetre();
public abstract double surface();
}
class Cercle extends Forme{
private int rayon;
private Point centre;
public double perimetre() { return 2 * Math.PI * r ; }
}
class Rectangle extends Forme{
...
public double perimetre() { return 2 * (hauteur+
largeur); }
}
...
Forme[] formes= {new Cercle(2), new Rectangle(2,3), new
Cercle(5)};
double som_perimetres = 0;
for(int i=0; i<formes.length; i++)
som_perimetres = formes[i].perimetre();

24. Les interfaces
24
 Une interface est une classe abstraite particulière :
 Qui ne contient aucun attribut
 Peut contenir des constantes
 Toutes ses méthodes sont abstraites
 Pour déclarer une interface, on utilise le mot clé interface
public interface nomInterface {
//liste des signatures des méthodes}
 Il doit y avoir une(des) classe(s) qui implémente les
méthodes d’une interface
 Si une classe implémente une interface elle doit
implémenter toutes les méthodes de cette interface
 Une classe peut implémenter une ou plusieurs interfaces.
On utilise le mot clé implements une seule fois
public class nomClasse implements interface1,