Chapitre 6 : Programmation Orientée-Objet

l  Objectifs
-  Connaître les limites de la programmation modulaire
-  Comprendre les avantages de la programmation orientée-objet
-  Connaître les principes de la programmation orientée-objet :
l’encapsulation, l’héritage, le polymorphisme
-  Connaître les caractéristiques de java concernant la programmation
orientée-objet

© Karim Bouzoubaa 1
 Chapitre 6 : La programmation Orientée-Objet
l  Sommaire
-  Limites de la programmation modulaire
-  Principes de la programmation orientée-objet
-  Contrôle d’accès aux données
-  Utilisation de la référence this
-  Surcharge des constructeurs
-  Premier principe de la POO : Encapsulation
-  Composition de classes
-  Données et méthodes statiques
-  Ramasse miettes et la méthode finalize
-  Deuxième principe de la POO : L’héritage
-  Données avec modificateur d’accès protected
-  Constructeurs dans les sous classes
-  Troisième principe de la POO : Le polymorphisme

© Karim Bouzoubaa 2
 6.1 Limites de la programmation modulaire

l  Premier type de programmation : de bas niveau (Langage

Assembleur)
-  connaissance des composantes physiques
-  un grand nombre de lignes

l  Invention de la programmation modulaire

-  proche de la manière de pensée des humains
-  structures de contrôle & modules
-  principales limites:
l  difficulté de gérer des problèmes complexes
l  difficulté de gérer un grand nombre de (lignes de code, modules, appels entre
modules)
l  difficulté de gérer de manière équilibrée aussi bien les données que les traitements

© Karim Bouzoubaa 3
 6.1 Limites de la programmation modulaire

l  Illustration des limites de la programmation modulaire

struct etudiant {
char [50] nom ;
char [50] prenom ;
double note1 ;
double note2
}

struct professeur {
char [50] nom ;
char [50] prenom ;
int nombreHeures ;
}

struct etudiant e1 ;
struct professeur p1 ;

© Karim Bouzoubaa 4
 6.1 Limites de la programmation modulaire

l  1) Problème de nommage non significatif des fonctions

-  Fonction d’ajout d’un étudiant f1(struct etudiant)

-  Fonction d’ajout d’un professeur f2(struct professeur)

-  Type des arguments pour comprendre sur quel type de

structure

à  Seul le nom de la fonction ne renseigne

–  ni sur la fonctionnalité en question (ajout)
–  ni sur la structure à laquelle il est associé

© Karim Bouzoubaa 5
 6.1 Limites de la programmation modulaire

l  2) Problème d’arguments

-  Ajout d’un étudiant ajouter(struct etudiant)

-  Ajout d’un professeur ajouter(struct professeur)

-  Nom significatif mais cela nécessiterait de voir le

contenu des arguments de la fonction afin de savoir si
l’ajout concerne un étudiant ou un professeur.

à Nom de fonction significatif mais nécessité de voir le

contenu des arguments

© Karim Bouzoubaa 6
 6.1 Limites de la programmation modulaire

l  3) Problème de redondance

-  Ajout d’un étudiant ajouterEtudiant(struct etudiant)

-  Ajout d’un professeur ajouterProfesseur(struct professeur)

-  Noms significatifs et type de la structure indiqué dans le

nom

à Redondance dans l’utilisation du nom de la structure

car nous avons été obligés de préciser le type aussi
bien dans le nom que dans l’argument

© Karim Bouzoubaa 7
 6.1 Limites de la programmation modulaire

l  4) Problème d’emplacement des fonctions

-  Emplacement des fonctions (ajout, modification,
suppression, etc.) peuvent se trouver à n’importe quel
endroit du code et pas nécessairement avec les
structures elles mêmes

à Maintenance difficile et coûteuse

© Karim Bouzoubaa 8
 6.1 Limites de la programmation modulaire
l  5 ) Problème de redondance de traitement
-  Structures Etudiant et Professeur partagent le nom et l’adresse
comme données communes
-  Fonction d’ajout :
l  Instructions relatives à ces deux données sont pareilles et sont répétées
-  Même raisonnement pour les autres fonctions (modification,
suppression, etc.)

à  Traiter des instructions en redondance

à  Maintenance encore plus coûteuse et fastidieuse
à  Application effective de la programmation modulaire dans des
problèmes réels et complexes exhibe plusieurs limitations
à  Penser à une nouvelle approche de programmation : POO
© Karim Bouzoubaa 9
 6.2 Principes de la programmation orientée-objet

l  Principe de la programmation modulaire :

-  Regrouper les données dans une même entité
-  Données et traitements séparés
-  Engendre beaucoup de problèmes

l  Principe de la programmation orientée-objet :

-  Regrouper données et traitements d’une même structure
dans une seule entité

© Karim Bouzoubaa 10
6.2 Principes de la programmation orientée-objet
struct etudiant {
char [50] nom
char [50] prenom class Etudiant {
double note1 String nom
double note2 String prenom
double note1
}
struct professeur { double note2
char [50] nom
char [50] prenom ajouter()
int nombreHeures supprimer()
} modifier()
}
ajouter(struct etudiant)
…
ajouter(struct professeur) class professeur {
String nom
…
supprimer(struct etudiant) String prenom
… int nombreHeures
supprimer(struct professeur)
… ajouter()
supprimer()
modifier(struct etudiant)
… modifier()
modifier(struct professeur) }
…
main()
main()

© Karim Bouzoubaa 11
 6.2 Programmation orientée-objet

l  Programmation orientée-objet :

-  Regrouper données/traitements dans une seule entité
-  Traitements directs qui s’opèrent sur une certaine structure sont directement
liés à cette structure
-  Idée générale : considérer comme faisant partie d’une même structure non
seulement les données mais également les fonctions qui s’y rattachent
-  Entité appelé Classe au lieu de structure de données ou une structure de
traitement
-  Appellations OO
l  Entité globale : classe
l  Données : membres ou attributs
l  Traitements : méthodes

© Karim Bouzoubaa 12
 6.2 Programmation orientée-objet

l  Structure d’une

classe Java

© Karim Bouzoubaa 13
 6.2 Programmation orientée-objet

l  Exemple de classe Java : la classe Etudiant

1.  // prog 6.1: [Link]
2.  // classe Etudiant
3.  -  Ligne 4 : Programme qui définit la classe
4.  public class Etudiant { Etudiant
5. 
6.  public String nom ;
7.  public String prenom ;
-  Lignes 6-9: données membres de la
8.  public double note1 ;
9.  public double note2 ;
classe
10. 
11.  public String getNomComplet() {
12.  return nom + " " + prenom; -  Lignes 11-13: méthode getNomComplet
13.  }
14.  public double getMoyenne() {
15.  return (note1 + note2)/2;
16.  } -  Lignes 14-16: méthode getMoyenne
17. 
18.  }// Fin de la classe Etudiant

© Karim Bouzoubaa 14
 6.2 Programmation orientée-objet

l  Exemple de classe Java : la classe Professeur

1.  // prog 6.3: [Link]
2.  // classe Etudiant
3.  -  Ligne 4 : Programme qui définit la classe
4.  public class Professeur { Professeur
5. 
6.  public String nom ;
7.  public String prenom ;
8.  public int nombreHeures ;
9.  public final int TAUX_HORAIRE = 200;
-  Lignes 6-9: données membres de la
10.  classe
11.  public String getNomComplet() {
12.  return nom + " " + prenom;
13.  }
14.  -  Lignes 11-13: méthode getNomComplet
15.  public double getSalaire () {
16.  return TAUX_HORAIRE * nombreHeures ;
17.  }
18.  -  Lignes 15-17: méthode getSalaire
19.  }// Fin de la classe Professeur

© Karim Bouzoubaa 15
 6.2 Programmation orientée-objet

l  Les classes Etudiant et Professeur sont des

classes service
-  ne contiennent pas la méthode main()
-  représentent notre connaissance sur les entités
Etudiant et Professeur
-  fournissent les services nécessaires concernant le
traitement d’un étudiant ou d’un professeur

l  Besoin d’une autre classe de test

-  contient la méthode main()
-  créer des instances des classes Etudiant et
Professeur
-  utiliser les services offerts par ces classes
© Karim Bouzoubaa 16
 6.2 Programmation orientée-objet
1.  // [Link]
2.  // Une programme qui teste
3.  // les classes Etudiant et Professeur
4. 
5.  public class TestEtudiantEtProfesseur {
6. 
7.  public static void main(String args[]) {
8.  String nomCompletEt, nomCompletPr;
9.  int sal;
10.  double moy;
11. 
12.  Etudiant e1 ;
13.  Professeur p1 ;
14. 
15.  e1 = new Etudiant();
16.  [Link] = "Merzaki";
17.  [Link] = "Ali";
18.  e1.note1 = 12;
19.  e1.note2 = 14;
20. 
21.  p1 = new Professeur();
22.  [Link] = "Tachfine";
23.  [Link] = "Hamid";
24.  [Link] = 10;
25. 
26.  nomCompletEt = [Link]();
27.  moy = [Link]();
28.  [Link]("La moyenne de l’étudiant "+ nomCompletEt +" est :"+moy);
29. 
30.  nomCompletPr = [Link]();
31.  sal = [Link]();
32.  [Link]("Le salaire du professeur "+ nomCompletPr +" est :"+sal);
33.  }
34.  }// Fin de la classe TestEtudiantEtProfesseur

© Karim Bouzoubaa 17
 6.2 Programmation orientée-objet
8.  String nomCompletEt, nomCompletPr;
9.  int sal;
10.  double moy;

l  Variables de travail

12.  Etudiant e1 ;
13.  Professeur p1 ;

l  Programme 6.1 à La classe Etudiant devient un nouveau type

l  Variable nommée e1 de type Etudiant
l  Idem pour p1 et classe Professeur
l  e1 et p1 sont des objets
l  Un objet : une variable du type d’une certaine classe à POO

© Karim Bouzoubaa 18
 6.2 Programmation orientée-objet

l  Sur le plan mémoire:

-  Un objet = case mémoire contenant l’adresse vers la structure pour laquelle elle
a été définie

l  Exemple: e1 et p1 adresses vers des objets de type Etudiant et

Professeur

© Karim Bouzoubaa 19
 6.2 Programmation orientée-objet
l  Ajouter un étudiant à trouver de l’espace mémoire pour stocker toutes les données
d’un étudiant
l  Mot clé new : chercher de l’espace mémoire
15.  e1 = new Etudiant();

l  La ligne 15 consiste dans sa première étape (new Etudiant();)

-  new : mot clé Java pour chercher de l’espace mémoire

-  new Etudiant() : espace mémoire nécessaire pour un étudiant (nom, prenom et note1,
note2)

l  De manière générale:

-  new NOM_CLASSE(): classe pour laquelle nous voulons créer une instance

-  NOM_CLASSE(): méthode spéciale d’une classe appelé un constructeur

-  utilisé seulement pour créer un objet

l  Dans une seconde étape (e1 = … ;)

-  Appel au constructeur retourne l’adresse de la première case mémoire de l’espace

trouvé à Affectation de cette adresse à la variable objet e1
© Karim Bouzoubaa 20
 6.2 Programmation orientée-objet
l  Contenu mémoire après exécution ligne 15
l  Avantage de POO par rapport à la programmation modulaire :
-  non nécessité de définir pour chaque structure une fonction d’ajout
(réalisée par le constructeur de la classe)

l  Accès aux données et aux méthodes par le symbole "." :

-  [Link]
-  [Link]()

16.  [Link] = "Merzaki";

17.  [Link] = "Ali";
18.  e1.note1 = 12;
19.  e1.note2 = 14;

l  Lignes 16 et 19 consistent à donner des

valeurs à chacune des données de
l’objet e1 de la classe Etudiant

© Karim Bouzoubaa 21
 6.2 Programmation orientée-objet

21.  p1 = new Professeur();

22.  [Link] = "Tachfine";
23.  [Link] = "Hamid";
24.  [Link] = 10;

l  Lignes 21 à 24
-  créer en mémoire l’objet p1
-  donner des valeurs à ses différentes données

© Karim Bouzoubaa 22
 6.2 Programmation orientée-objet

26.  nomCompletEt = [Link]();

27.  moy = [Link]();

l  Ligne 26
-  Appel de la méthode getNomComplet() de l’objet e1
-  Résultat : Affectation "Merzaki Ali" à nomCompletEt

public class Etudiant {

l  Ligne 27
public String nom ;
-  Appel de la méthode getMoyenne() de l’objet e1 public String prenom ;
public double note1 ;
public double note2 ;
-  Résultat : Affectation (12+14)/2 = 13 à moy
public String getNomComplet() {
return nom + " " + prenom;
}
public double getMoyenne() {
return (note1 + note2)/2;
}
}

© Karim Bouzoubaa 23
 6.2 Programmation orientée-objet

30.  nomCompletPr = [Link]();

31.  sal = [Link]();

l  Ligne 30
-  Appel de la méthode getNomComplet() de p1
-  Résultat : Affectation "Tachfine Hamid" à
nomCompletPr

l  Ligne 31 public class Professeur {

public String nom ;

-  Appel de la méthode getSalaire() de p1 public String prenom ;
public int nombreHeures ;
public final int TAUX_HORAIRE = 200;
-  Résultat : Affectation 200*10 = 2000 à sal
public String getNomComplet() {
return nom + " " + prenom;
}

public double getSalaire () {

return TAUX_HORAIRE * nombreHeures ;
}
}

© Karim Bouzoubaa 24
 6.2 Programmation orientée-objet
l  Autre Avantage de POO par rapport à la programmation
modulaire :
-  Modulaire : structure de données & fonctions associées (pb
nomination, maintenance, etc.)
-  POO : problème absent
l  méthode définie à l’intérieur de la classe même
l  mise à jour : le programmeur connaît l’endroit où la méthode est définie
l  pas de problème de nomination car l’appel est précédé par l’objet qui
l’appelle (getNomComplet() par e1 et p1)

© Karim Bouzoubaa 25
 6.2 Programmation orientée-objet
l  Exécution du programme
-  Trois classes dans trois fichiers différents : 1) [Link], 2) [Link] et
3) [Link]
-  3) utilise 1) et 2) à nécessité de compiler 1) et 2) avant 3)

© Karim Bouzoubaa 26
 6.3 Contrôle d’accès aux données
public class Etudiant {
l  Classe Etudiant
public String nom ;
-  Données précédées par public public
public
String
double
prenom ;
note1 ;
public double note2 ;
-  Modificateur d’accès : indique la manière
public String getNomComplet() {
avec laquelle il est possible d’accéder à return nom + " " + prenom;
une donnée/méthode/classe }
public double getMoyenne() {
return (note1 + note2)/2;
-  Syntaxe générale : }
}
modificateur_d’acces type donnée/méthode/classe

-  modificateur_d’acces = public / private public class TestEtudiantEtProfesseur {

-  public : donnée accessible de manière public static void main(String args[]) {

…
publique, c'est-à-dire accessible (ou
Etudiant e1 ;
utilisable) par n’importe qui et n’importe où Professeur p1 ;

-  Exemple e1 = new Etudiant();

[Link] = "Merzaki";
[Link] = "Ali";
e1.note1 = 12;
e1.note2 = 14;

}
}

© Karim Bouzoubaa 27
 6.3 Contrôle d’accès aux données
l  Instructions suivantes : public class Etudiant {

public String nom ;

e1.note1 = 25 ; public String prenom ;
private double note1 ;
e1.note1 = -7 ; public double note2 ;

à incohérence public String getNomComplet() {

return nom + " " + prenom;
l  Restreindre l’accès à la donnée note1 }
public double getMoyenne() {
pour intégrité }
return (note1 + note2)/2;

l  Conseillé (primordiale) de ne pas }

donner libre accès à une donnée public class TestEtudiantEtProfesseur {

l  Utilisons le modificateur d’accès public static void main(String args[]) {

…
private
Etudiant e1 ;

l  private : donnée accessible Professeur p1 ;

seulement dans la classe où elle est e1 = new Etudiant();

[Link] = "Merzaki";
déclarée [Link] = "Ali";
e1.note1 = 12;
l  Exemple e1.note2 = 14;

}
}

© Karim Bouzoubaa 28
 6.3 Contrôle d’accès aux données
l  Que faire pour permettre public class Etudiant {
private String nom ;
private String prenom ;
quand même de changer la private double note1 ;
private double note2 ;
valeur d’une donnée d’une public String getNom() { return nom ; }

autre classe tout en public

public
String
double
getPrenom() { return prenom ; }
getNote1() { return note1 ; }
public double getNote2() { return note2 ; }
garantissant son intégrité de public void setNom(String n) {
la donnée ? }
nom = n ;

public void setPrenom(String p) {

l  Solution utilisée en POO }

prenom = p ;

public void setNote1(double n1) {

if (n1<0 || n1>20)
-  Associer des méthodes note1 = 0;
else note1 = n1;
d’accès publiques à chaque }
public void setNote2(double n2) {
donnée privée (getters et if (n2<0 || n2>20)
note2 = 0;
setters) else note2 = n2;
}

-  S’assurer de l’intégrité de la public String getNomComplet() {

return nom + " " + prenom;

donnée au sein de la }
public double getMoyenne() {

méthode }
return (note1 + note2)/2;

© Karim Bouzoubaa 29
 6.3 Contrôle d’accès aux données
l  Programme de test
public class TestEtudiant2 {
public static void main(String args[]) {
String nomCompletEt;
double moy;
Etudiant e1, e2 ;
e1 = new Etudiant();
[Link]("Merzaki");
[Link]("Ali");
e1.setNote1(12);
e1.setNote2(14);
e2 = new Etudiant ();
[Link]("Hamdane");
[Link]("Youssef");
e2.setNote1(-6);
e2.setNote2(24);
nomCompletEt = [Link]();
moy = [Link]();
[Link]("La moyenne de l’étudiant "+ nomCompletEt +" est :« + moy);
[Link]("La moyenne de l’étudiant " + [Link]() + " " + [Link]() + " est :" +
(e2.getNote1()+e2.getNote2())/2);
}
}

© Karim Bouzoubaa 30
 6.4 Utilisation de la référence this
public class Etudiant {
private String nom ;
private String prenom ;
l  Classe Etudiant : utilisation de nouvelles variables private double note1 ;
pour la nomination des paramètres des getters et private double note2 ;
…
setters (n, p, n1 et n2) public void setNote1(double n1)
{
if (n1<0 || n1>20)
l  Lorsque la classe contient plus que ces quatre note1 = 0;
données à trouver d’autres appellations de }
else note1 = n1;

variables et les faire correspondre aux appellations …

}
des données
l  Pour garantir une bonne lecture, lisibilité et
maintenance du programme public class Etudiant {
private String nom ;
-  Logique de nommer ces paramètres avec le même private String prenom ;
private double note1 ;
nom que la donnée de la classe (note1 pour private double note2 ;
setNote1) à problème d’incohérence …
public void setNote1(double note1)
{
-  Solution Java : mot clé this qui fait référence à une if (note1<0 || note1>20)
donnée de la classe. this.note1 = 0;
else this.note1 = note1;
}
…
}

© Karim Bouzoubaa 31
 6.5 Surcharge des constructeurs
l  Rappel sur chapitre 5
-  Surcharge des méthodes : déclarer plusieurs méthodes avec le même nom mais avec
des paramètres ou un type de retour différents
l  Surcharge du constructeur
-  constructeur par défaut : nom de la classe précédée du mot clé new sans paramètres
(nécessite un travail supplémentaire)
-  La surcharge du constructeur
l  redéfinir le constructeur afin d’attribuer aux données de la classe des valeurs par défaut
l  redéfinir le constructeur avec les paramètres voulues

public class Etudiant {

…
public Etudiant() {
setEtudiant("Mohamed" , "Mohamed", 10, 10) ;
}
public Etudiant(String nom, String prenom, double note1, double note2) {
setEtudiant(nom, prenom, note1, note2) ;
}
public void setEtudiant(String nom, String prenom, double note1, double note2) {
setNom(nom);
setPrenom(prenom);
setNote1(note1);
setNote2(note2);
}
…
© Karim Bouzoubaa 32
 6.5 Surcharge des constructeurs
l  Exemple
public class TestEtudiant3 {

public static void main(String args[]) {

Etudiant e1, e2 ;

e1 = new Etudiant();
e2 = new Etudiant ("Hamdane", "Youssef", -6, 24 );

[Link](
"La moyenne de l’étudiant " + [Link]() + " est :" + [Link]() );

[Link](
"La moyenne de l’étudiant " + [Link]() + " est :" + [Link]() );
}
}

© Karim Bouzoubaa 33
6.6 Premier principe de la POO : Encapsulation
l  Programmation modulaire
-  Déclarer des données générales / un ensemble de fonctions destinées à les gérer de
manière séparée

Variable Objet
Variable
Donnée Donnée Donnée
Fonction
Fonction
Méthode Méthode
Variable

l  Encapsulation : Nouvelle manière de gérer les données (cœur de POO)

-  Réunir sous la même entité (classe) les données et les méthodes correspondantes
-  Masquer certaines données et méthodes (privées) et laisser visibles d'autres
(publiques)
à encapsulation masque aux yeux d'un programmeur les détails d'un objet
à encapsulation garde une cohérence dans la gestion des objets, tout en assurant l'intégrité des
données qui ne pourront être accédées qu'au travers des méthodes visibles

© Karim Bouzoubaa 34
6.6 Premier principe de la POO : Encapsulation
l  En théorie : les données et les
traitements peuvent être aussi bien
publiques que privées
l  Bonnes pratiques recommandent de :
public class C {
-  mettre les données qui définissent une classe …
private double data ;
comme étant privées …
public void setData(double data)
-  mettre des méthodes d’accès à ces données …
public double getData()
(getters et setters) comme étant publiques et …
private type methodeInterne(param)
de les implémenter de manière à assurer …
l’intégrité des données public type methodeExterne(param)
…
}
-  mettre les méthodes qui ne vont servir qu’à
une gestion interne d’une classe donnée
comme étant privées
-  mettre les méthodes qui sont appelées à être
utilisées par des programmes externes
comme étant publiques

© Karim Bouzoubaa 35
 6.7 Composition de classes
l  Une donnée d’une classe peut public class Date {
private int jour;
être private int mois ;
private int annee ;
-  un type déjà connu en Java
public Date()
-  un objet d’une autre classe
public Date(int jour, int mois, int annee)
l  Exemple : date de naissance
d’un étudiant public void setJour(int jour) {
if (jour < 1 || jour > 31)
-  Déclarer une nouvelle classe [Link] = 1;
else [Link] = jour;
nommée Date }
-  Données : jour, mois et année public void setMois(int mois)
-  Constructeur public void setAnnee(int annee)
-  Accesseurs avec code qui public String toString()
assure l’intégrité des données return "[" + jour + "/" + mois + "/"
(jour dans [1, 31], etc.) + annee + "]";
}

© Karim Bouzoubaa 36
 6.7 Composition de classes
l  Etape 2 : Redéfinir la classe Etudiant
-  Rajouter une date de naissance comme étant une donnée de type Date

public class Etudiant {

private String nom ;
private String prenom ;
private double note1 ;
private double note2 ;
private Date dateDeNaissance ;

public Etudiant(String nom, String prenom,

double note1, double note2, Date dateDeNaissance ) {
[Link] = nom ;
[Link] = prenom ;
this.note1 = note1 ;
this.note2 = note2 ;
[Link] = dateDeNaissance ;
}

public String toString() {

return nom + " " + prenom + "," +
(note1+note2)/2 + "," + dateDeNaissance ;
}
}

© Karim Bouzoubaa 37
 6.7 Composition de classes
l  Etape 3 : classe de public class TestEtudiant4 {

test public static void main(String args[]) {

Etudiant etudiant ;
Date date ;
-  Deux objets : une date = new Date(5, 11, 1980);
etudiant = new Etudiant("Hamdane", "Youssef", 12, 14, date);
Date et un Etudiant [Link]("L’étudiant est " + etudiant );
}
}

etudiant date

5BC8 C98A jour

5

mois
11
nom
Hamdane annee

Prenom 1980
Youssef

note1
12

note2
14

dateDeNaisssance
C98A

© Karim Bouzoubaa 38
 6.7 Composition de classes
l  Exécution

l  Exécution grâce à la ligne :

[Link]("L’étudiant est " + etudiant );

l  Normalement, l’exécution serait "L’étudiant est 5BC8" (5BC8 adresse de l’objet
etudiant
l  Cependant, fonctionnement de Java lors de la concaténation d’une chaîne avec
une autre variable non chaîne de caractères
-  Appel de la méthode toString() du paramètre en question pour le transformer en une
chaîne de caractères (etudiant est remplacé par [Link]())
-  Par défaut, toString() retourne la valeur de son adresse en mémoire
-  Sauf si redéfinit par le programmeur (cas des classes Etudiant et Date)

© Karim Bouzoubaa 39
 6.8 Données et méthodes statiques
l  Supposons : connaître à tout moment le nombre d’étudiants qui ont
été créés
l  Rajouter dans la classe Etudiant une donnée appelé compteur
-  initialisée à 0
-  incrémentée de 1 à chaque nouvel appel au constructeur

public class Etudiant {

private String nom ;
private String prenom ;
private double note ;
private int compteur = 0 ;

public Etudiant(String nom, String prenom, double note ) {

[Link] = nom ;
[Link] = prenom ;
this.note1 = note ;
compteur++ ;
}

public int getCompteur() { return compteur; }

© Karim Bouzoubaa 40
 6.8 Données et méthodes statiques
l  Programme de test : problème
public class TestEtudiant5 {
public static void main(String args[]) {
Etudiant e1, e2 ;

e1 = new Etudiant("Hamdane", "Youssef", 12);

[Link]("Le nombre d’étudiants créé est" + [Link]());

e2 = new Etudiant("Marzaki", "Ali", 15);

[Link]("Le nombre d’étudiants créé est" + [Link]());
}
}

e2 nom
e1 nom
A49D Merzaki
4AC5 Tachfine

prenom prenom
Hamid Ali
note note
12 15

compteur compteur
1 1

© Karim Bouzoubaa 41
 6.8 Données et méthodes statiques
l  Pour pallier au problème :
-  Solution : permettre à plusieurs objets de partager une même donnée
-  Considérer cette donnée comme étant statique
-  Donnée statique peut changer de valeur mais possède cette même valeur pour tous les
objets de la classe même
-  Méthode peut également être statique (e.g. pour accéder à une donnée statique privée)

public class Etudiant {

private String nom ;
private String prenom ;
private double note ;
private static int compteur = 0 ;

public Etudiant(String nom, String prenom, double note ) {

[Link] = nom ;
[Link] = prenom ;
this.note1 = note ;
[Link]("Création de l’étudiant " + nom + " " + prenom);
compteur++ ;
}

public static int getCompteur() { return compteur; }

© Karim Bouzoubaa 42
 6.8 Données et méthodes statiques
l  Même programme de test : sauf [Link]()
public class TestEtudiant6 {
public static void main(String args[]) {
Etudiant e1, e2 ;

[Link]("Le nombre d’étudiants créé est" + [Link]());

e1 = new Etudiant("Hamdane", "Youssef", 12);

[Link]("Le nombre d’étudiants créé est" + [Link]());

e2 = new Etudiant("Marzaki", "Ali", 15);

[Link]("Le nombre d’étudiants créé est" + [Link]());
}
}

e2 nom
e1 nom
A49D Merzaki
4AC5 Tachfine

prenom prenom
Hamid Ali
note note
12 2 15

compteur compteur

© Karim Bouzoubaa 43
 6.9 Ramasse miettes et la méthode finalize
l  Variable compteur statique: connaître le nombre d’étudiants à jour
-  A chaque nouvel étudiant, le compteur est incrémenté de un
l  Que se passerait-il si un étudiant est supprimé ?
-  Aucune instruction pour décrémenter compteur de un
l  Supprimer un étudiant : e1 = null ;

-  Deux problèmes :
l  Objet (Tachfine, Hamid, 12, 2) existe toujours en mémoire
l  compteur = 2
e2 nom
e1 nom
A49D Merzaki
null Tachfine

prenom prenom
Hamid Ali
note note
12 2 15

compteur compteur

© Karim Bouzoubaa 44
 6.9 Ramasse miettes et la méthode finalize

l  Solution Java : ramasse miettes (Garbage collector en

Anglais)
l  Ramasse miettes : processus qui cherche en mémoire
tous les objets qui ne sont plus référencés et les supprime
-  Nous disons qu’il ramasse les miettes de la mémoire, une miette
étant un objet qui ne sert plus à rien
-  L’appel au ramasse miettes :
l  méthode [Link]() (g pour garbage et c pour collector)
l  Intervalle de temps régulier

© Karim Bouzoubaa 45
 6.9 Ramasse miettes et la méthode finalize
public class TestEtudiant7 {
public static void main(String args[]) {
Etudiant e1, e2 ;
[Link]("Le nombre d’étudiants créé est" + [Link]());
e1 = new Etudiant("Hamdane", "Youssef", 12);
[Link]("Le nombre d’étudiants créé est" + [Link]());
e2 = new Etudiant("Marzaki", "Ali", 15);
[Link]("Le nombre d’étudiants créé est" + [Link]());
e1 = null ;
[Link]() ;
}
}

e1 e2 nom
A49D Merzaki
null
prenom
Ali
note
2 15
compteur

l  Problème qui persiste : mettre à jour le compteur

© Karim Bouzoubaa 46
 6.9 Ramasse miettes et la méthode finalize
l  Solution Java : méthode finalize()
-  s’exécute à chaque fois qu’un objet est sur le point d’être éliminé de la
mémoire
public class Etudiant {
private String nom ;
private String prenom ;
private double note ;
private static int compteur = 0 ;

public Etudiant(String nom, String prenom, double note ) {

[Link] = nom ;
[Link] = prenom ;
this.note1 = note ;
[Link]("Création de l’étudiant " + nom + " " + prenom);
compteur++ ;
[Link]("Le nombre d’étudiants est : " + compteur);
affiche à l’écran un }
message informant
l’utilisateur que
l’étudiant en question public void finalize() {
est supprimé de la [Link]("Suppression de l’étudiant " +nom+ " " + prenom);
mémoire compteur-- ;
[Link]("Le nombre d’étudiants est : " + compteur);
Décrémente compteur }
affiche sa nouvelle
valeur public static int getCompteur() { return compteur; }

© Karim Bouzoubaa 47
 6.9 Ramasse miettes et la méthode finalize
public class TestEtudiant8 {

public static void main(String args[]) {

l  Programme test Etudiant e1, e2 ;
e1 = new Etudiant("Hamdane", "Youssef", 12);
e2 = new Etudiant("Marzaki", "Ali", 15);
e1 = null ;
e2 = null ;
[Link]() ;
}
}

© Karim Bouzoubaa 48
 6.10 Deuxième principe de la POO : L’héritage
l  Principe d’héritage : faire hériter à une classe toutes les propriétés d’une autre
classe de laquelle elle hérite
-  Rapidité de développement
-  Réutilisation d’un code

l  Exemple concernant notre établissement d’enseignement

-  Données (nom et prénom) d’étudiant et de professeur sont exactement les mêmes
-  Traitement (getters et setters) de ces deux données sont également les mêmes
-  Dans la réalité :
l  Il existe d’autres données ayant même caractéristiques

l  A cela peut s’ajouter d’autres classes telles que administrateurs, associés, etc.

à  considérer le traitement une seule fois

à  Rassembler dans une autre classe toutes les propriétés partagées
-  Création de la classe Personne
-  Garder dans les classes Etudiant et Professeur les traitements spécifiques (note,
salaire, etc.)
© Karim Bouzoubaa 49
6.10 Deuxième principe de la POO : L’héritage
l  Classe Personne

public class Personne {

private String nom ;
private String prenom ;

public String getNom() { return nom ; }

public String getPrenom() { return prenom ; }
public void setNom(String nom) {
[Link] = nom ;
}
public void setPrenom(String prenom) {
[Link] = prenom ;
}
public String toString() {
return nom + " " + prenom;
}
}

© Karim Bouzoubaa 50
 6.10 Deuxième principe de la POO : L’héritage
l  Classe Etudiant hérite de la classe Personne
public class Etudiant extends Personne
public class Etudiant extends Personne {
private double note1 ;
l  extends : private double note2 ;

-  "étend" en Français public double getNote1() {

return note1 ; }
-  Etudiant hérite de toutes les propriétés (données public double getNote2() {
et traitements) de la classe Personne. return note2 ; }

-  Etudiant possède note1, note2 mais également public void setNote1(double note1) {
les données nom et prenom if (note1<0 || note1>20)
this.note1 = 0;
-  Etudiant possède les méthodes else this.note1 = note1;
}
l  getNom() , getPrenom() public void setNote2(double note1) {
if (note2<0 || note2>20)
l  setNom() , setPrenom()
this.note2 = 0;
l  toString() else this.note2 = note2;
}
l  super : public double getMoyenne() {
return (note1 + note2)/2;
-  Méthode toString() définie dans les deux }
classes public String toString() {
return [Link]() + " "
l  toString() : Etudiant + note1 + " " + note2;
}
l  [Link]() : Person
}

© Karim Bouzoubaa 51
 6.10 Deuxième principe de la POO : L’héritage
l  Même chose pour la classe Professeur

public class Professeur extends Personne {

private int nombreHeures ;
public final int TAUX_HORAIRE = 200;

public int getNombreHeures() {

return nombreHeures; }

public void setNombreHeures(int nombreHeures) {

if (nombreHeures < 0)
[Link] = 0 ;
else [Link] = nombreHeures ;
}
public int getSalaire() {
return TAUX_HORAIRE * nombreHeures ;
}

public String toString() {

return [Link]() + " "
+ nombreHeures ;
}
}

© Karim Bouzoubaa 52
6.10 Deuxième principe de la POO : L’héritage

l  Classes Etudiant et Professeur sont des sous

classes de la classe Personne
l  Classe Personne est la super classe des
classes Etudiant et Professeur

Personne

Etudiant Professeur

© Karim Bouzoubaa 53
 6.10 Deuxième principe de la POO : L’héritage
l  Autre hiérarchie plus élaborée
l  Type d’héritage
-  Héritage direct : une classe est une sous classe directe d’une autre sous classe
(Professeur et ProfesseurPermanent, Ressources et Personne)
-  Héritage indirect : une classe hérite d’une autre classe à travers des classes
intermédiaires (Professeur et Ressources, Ressources et ProfesseurVacataire)
-  Aucun lien d’héritage (RessourcesMaterielles et Professeur)

Ressources

RessourcesMaterielles Personne

Etudiant Professeur

ProfesseurVacataire ProfesseurPermanent

© Karim Bouzoubaa 54
 6.10 Deuxième principe de la POO : L’héritage
l  Java possède une hiérarchie des toutes les classes que ses développeurs ont
implémentée
l  Classe mère est la classe nommée Object
l  Lorsque nous définissons nos propres classes en Java avec des relations
d’hiérarchie entre elles, cette dernière est obligatoirement rattachée à la
hiérarchie initiale du langage Java
-  Ceci est réalisé en rattachant la classe mère de la hiérarchie développée à l’une des
classes définies dans la hiérarchie du langage Java
-  Si non spécifiée, par défaut la classe mère du programmeur devient une sous classe
de la classe Object

l  Pas d’héritage multiple en Java, héritage simple :

-  Java ne permet pas qu’une classe hérite de deux classes différentes
public class Professeur extends Class1, Class2

l  En cas de besoin d’héritage multiple, Java utilise le concept d’Interface (ch 7)

© Karim Bouzoubaa 55
6.10 Deuxième principe de la POO : L’héritage

l  Avantages de l’héritage :

-  Éviter la redondance des traitements communs entre
plusieurs classes
-  Réutiliser le code existant si besoin d’autres classes
partageant des données ou traitements communs

© Karim Bouzoubaa 56
6.10 Deuxième principe de la POO : L’héritage
public class TestEtudiantEtProfesseur2 {

l  Programme public static void main(String args[]) {

Personne personne;
de test Etudiant etudiant ;
Professeur professeur ;

personne = new Personne();

[Link]("Moumen");
[Link]("Khalid");

etudiant = new Etudiant();

[Link]("Merzaki");
[Link]("Ali");
etudiant.setNote1(12);
etudiant.setNote2(14);

professeur = new Professeur();

[Link]("Tachfine");
[Link]("Hamid");
[Link](10);

[Link]("La personne est "+ personne);

[Link]("L’étudiant est "+ etudiant);
[Link]("Le professeur est "+ professeur);
}
}

© Karim Bouzoubaa 57
 6.11 Données avec modificateur d’accès protected

l  Composante d’une classe : publique ou privée

l  Composante d’une classe mère
-  Publique pour les classes filles, Privée pour toute autre classe (contradiction)
-  Quoi mettre ? public ou private
-  Java introduit un autre modificateur d’accès spécifique protected
-  Niveau d’accès intermédiaire entre l’accès public et l’accès privé
-  Composante protégée (protected) est visible pour la classe elle-même et
pour toutes ses classes filles (mais pas les autres)

© Karim Bouzoubaa 58
 6.11 Données avec modificateur d’accès protected
public class Personne {
protected String nom ;
protected String prenom ;

public String getNom() { return nom ; }

public String getPrenom() { return prenom ; }
public void setNom(String nom) {
[Link] = nom ;
}
public void setPrenom(String prenom) {
[Link] = prenom ; public class Etudiant extends Personne {
} private double note1 ;
private double note2 ;
public String toString() {
return nom + " " + prenom; public double getNote1() { return note1 ; }
public double getNote2() { return note2 ; }
}
public void setNote1(double note1) {
} if (note1<0 || note1>20)
this.note1 = 0;
else this.note1 = note1;
}
public void setNote2(double note1) {
if (note2<0 || note2>20)
this.note2 = 0;
else this.note2 = note2;
}
public double getMoyenne() {
return (note1 + note2)/2;
}
public String toString() {
return "L’étudiant " + nom + " " + prenom +
" possède les notes : " + note1 + " et " + note2;
}
}

© Karim Bouzoubaa 59
6.11 Les données avec modificateur d’accès protected

l  Programme public class TestEtudiant3 {

de test public static void main(String args[]) {

Etudiant etudiant ;

etudiant = new Etudiant();

[Link]("Merzaki");
[Link]("Ali");
etudiant.setNote1(12);
etudiant.setNote2(14);
[Link](etudiant);
}
}

© Karim Bouzoubaa 60
 6.12 Les constructeurs dans les sous classes

l  Dans la classe Personne : pas public class Personne {

de constructeur protected String nom ;

protected String prenom ;
-  Ajout d’un étudiant ou professeur public Personne (String nom, String prenom) {
nécessite plusieurs instructions [Link] = nom;
[Link] = prenom;
}
-  Objectif : Ajouter un étudiant en
une seule instruction public String getNom() { return nom ; }
public String getPrenom() { return prenom ; }
public void setNom(String nom) {
l  Créer un constructeur dans la [Link] = nom ;
}
classe Personne public void setPrenom(String prenom) {
[Link] = prenom ;
l  Créer un constructeur dans la }
public String toString() {
classe Etudiant en profitant du return nom + " " + prenom;
constructeur Personne }
}

© Karim Bouzoubaa 61
 6.12 Constructeurs dans les sous classes

public class Etudiant extends Personne {

private double note1 ;
private double note2 ;

l  Constructeur dans Etudiant public Etudiant (String nom, String prenom,
int note1, int note2) {
super(nom, prenom) ;
l  Appel au constructeur de la classe mère this.note1 = note1 ;
this.note2 = note2 ;
Personne }

public double getNote1() { return note1 ; }

-  pas par l’instruction new Personne(nom, prenom) public double getNote2() { return note2 ; }

public void setNote1(double note1) {

-  mais par utilisation du mot clé super if (note1<0 || note1>20)
this.note1 = 0;
else this.note1 = note1;
-  super(nom, prenom) }
public void setNote2(double note1) {
if (note2<0 || note2>20)
-  Donner des valeurs à note1 et note2 qui this.note2 = 0;
caractérisent un Etudiant }
else this.note2 = note2;

public double getMoyenne() {

return (note1 + note2)/2;
}
public String toString() {
return "L’étudiant " + nom + " " + prenom +
" possède les notes : " + note1 + "
et " + note2;
}
}

© Karim Bouzoubaa 62
 6.12 Constructeurs dans les sous classes

l  Programme de test

public class TestEtudiant4 {

public static void main(String args[]) {

Personne personne;
Etudiant etudiant ;

personne = new Personne("Moumen", "Khalid");

etudiant = new Etudiant("Merzaki", "Ali", 12, 14);
[Link](personne);
[Link](etudiant);
}
}

© Karim Bouzoubaa 63
6.13 Troisième principe de la POO : Le polymorphisme
l  Principe du polymorphisme
-  programmer dans le « général » plutôt que le « spécifique »
-  consiste à programmer par utilisation d’objets qui partagent la même
superclasse dans une hiérarchie comme s’ils étaient tous des instances de
cette superclasse
-  Capacité à ce qu’un type A apparaisse et soit utilisé comme un autre type B
l  Utilisation primaire : des objets de divers types réagissent à un
appel de méthode du même nom mais avec un comportement
différent

© Karim Bouzoubaa 64
6.13 Troisième principe de la POO : Le polymorphisme
l  Exemple plus réel de polymorphisme
-  besoin du concept "Classe et méthode abstraites"
l  Classe et méthode abstraites
-  Classe abstraite : classe qui ne peut être instanciée (abstract)
-  Objectif : fournir une superclasse (abstraite) à partir de laquelle des sous
classes peuvent hériter et par conséquent partager une conception commune
-  Par exemple
l  Classe Animal abstraite car il n’existe pas concrètement des instances de type
Animal
l  Il existe plutôt des instances de sous classes de Animal telles que Chien et Chat
l  Chien et Chat sont appelées des classes concrètes

© Karim Bouzoubaa 65
6.13 Troisième principe de la POO : Le polymorphisme
l  Classe et méthode abstraites
-  Classe abstraite contient une ou plusieurs méthodes abstraites
-  Méthode abstraite ne fournit pas d’implémentation
-  Toute classe qui contient au moins une méthode abstraite doit être déclarée également
abstraite

public abstrat class Animal { •  Déclaration d’une classe abstraite

…
public abstract void parler() ;
… •  Et d’une méthode abstraite
}

public class Chat extends Animal { •  Déclaration d’une classe concrète

…
public void parler() {
[Link]("miau");
}
…
•  Implémentation de la méthode
} abstraite héritée de la classe Animal

public class Test •  Une classe de test

public static void main(String args[]) {
Animal a = new Animal();
Chat c = new Chat(); •  Pas possible de créer un objet de
[Link](); type Animal
} •  Possible de créer un objet de type
} Chat

© Karim Bouzoubaa 66
6.13 Troisième principe de la POO : Le polymorphisme
l  Exemple de polymorphisme
-  Fonctionnalités du programme de gestion d’un établissement d’enseignement :
l  payer toutes les personnes qu’elle emploie à la fin du mois
-  Personnes de l’établissement : employés, professeurs et étudiants
-  Employés : salaire fixe
-  Étudiants : nombre d’heures travaillées * taux horaire
-  Professeur
l  permanent : salaire fixe
l  vacataire : nombre d’heures enseignées * taux horaire

Ressources

RessourcesMaterielles Personne

Etudiant Professeur Employé

ProfesseurVacataire ProfesseurPermanent

© Karim Bouzoubaa 67
6.13 Troisième principe de la POO : Le polymorphisme

public abtract class Personne {

l  classe Personne protected String nom ;

protected String prenom ;

-  abstraite public Personne (String nom, String prenom) {

[Link] = nom;
-  setters et getters }
[Link] = prenom;

public String getNom() {

-  toString() return nom ;
}
-  calculSalaire() public String getPrenom() {
return prenom ;
l  abstraite }
public void setNom(String nom) {
[Link] = nom ;
l  déclarer la méthode sans }
l’implémenter en fermant la public void setPrenom(String prenom) {
[Link] = prenom ;
ligne par un point virgule "; }
public String toString() {
l  redéfinie pour chaque sous return "\nNom: " + nom + " - Prenom : " + prenom;
classe de Personne }
public abstract double calculSalaire() ;
}

© Karim Bouzoubaa 68
6.13 Troisième principe de la POO : Le polymorphisme
public class Etudiant extends Personne {
private double note1 ;
private double note2 ;
private static final double TAUX_HORAIRE = 50 ;
l  Classe Etudiant private double nombreHeures ;

public Etudiant (String nom, String prenom,

-  étend la classe Personne int note1, int note2, int nombreHeures) {
super(nom, prenom) ;
this.note1 = note1 ;
-  TAUX_HORAIRE statique car applicable this.note2 = note2 ;
[Link] = nombreHeures ;
à tous les étudiants }
public double getNote1() { return note1 ; }
-  constructeur public double getNote2() { return note2 ; }
public double getNombreHeure() { return nombreHeures ; }
public void setNote1(double note1) {
-  setters et getters pour les trois if (note1<0 || note1>20)
données note1, note2 ainsi que this.note1 = 0;
else this.note1 = note1;
nombreHeures }
public void setNote2(double note1) {
-  toString() redéfinie pour afficher, if (note2<0 || note2>20)
this.note2 = 0;
en plus du nom et prénom par else this.note2 = note2;
héritage, les informations concernant }
public void setNombreHeure(double nombreHeures) {
l’étudiant en question, à savoir ses if (nombreHeures<0)
[Link] = 0 ;
notes et sa moyenne else [Link] = nombreHeures ;
}
-  implémente calculSalaire() à public double getMoyenne() {
return (note1 + note2)/2;
classe concrète }
public String toString() {
return [Link]() +
"\nIl possede les notes : " + note1 + " et " + note2 ;
}
public double calculSalaire() {
return nombreHeure * TAUX_HORAIRE ;
}
}

© Karim Bouzoubaa 69
6.13 Troisième principe de la POO : Le polymorphisme

l  Classe Employe

public class Employe extends Personne {
private double salaire;
-  étend la classe Personne private String poste;

-  poste et salaire d’un employé public Employe (String nom, String prenom,
double salaire, String poste) {
super(nom, prenom) ;
-  constructeur [Link] = salaire ;
[Link] = poste;
-  setters et getters pour le salaire et le }
public double getSalaire () { return salaire ; }
poste public void setSalaire (double salaire) {
if (salaire <0)
-  toString() redéfinie pour afficher, en [Link] = 0 ;
else [Link] = salaire ;
plus du nom et prénom par héritage, }
les informations concernant l’employé public String getPoste () { return poste ; }

en question, à savoir son poste public void setPoste (String poste) {

d’emploi [Link] = poste ;
}
public String toString() {
-  implémente calculSalaire() à return [Link]() +
classe concrète "\nIl est au poste de : " + poste;
}
public double calculSalaire() {
return salaire ;
}
}

© Karim Bouzoubaa 70
6.13 Troisième principe de la POO : Le polymorphisme

l  Classe Professeur

-  étend la classe Personne public abstract class Professeur extends Personne {

protected String cours;

-  cours donné par le professeur
public Professeur (String nom,
-  constructeur String prenom, String cours) {
super(nom, prenom) ;
[Link] = cours;
-  setters et getters pour le cours }

-  toString() redéfinie pour afficher, public String getCours () { return cours ; }

en plus du nom et prénom par public void setCours (String cours) {
héritage, les informations [Link] = cours ;
}
concernant le professeur en
question, à savoir son cours public String toString() {
return [Link]() +
-  calculSalaire() non encore }
"\nIl enseigne le cours : " + cours;

implémentée, ce qui en fait une }

classe abstraite

© Karim Bouzoubaa 71
6.13 Troisième principe de la POO : Le polymorphisme

l  Classe ProfesseurPermanent

public class ProfesseurPermanent extends Professeur {
-  étend la classe Professeur
private double salaire ;
-  salaire du professeur
public ProfesseurPermanent(
-  constructeur String nom, String prenom,
String cours, double salaire) {
super(nom, prenom, cours) ;
-  setters et getters pour salaire [Link] = salaire ;
}
-  toString() non redéfinie mais
public double getSalaire () { return salaire ; }
héritée
public void setSalaire (double salaire) {
-  implémente calculSalaire() à if (salaire <0)
[Link] = 0 ;
classe concrète else [Link] = salaire ;
}

public double calculSalaire() {

return salaire ;
}
}

© Karim Bouzoubaa 72
6.13 Troisième principe de la POO : Le polymorphisme

l  Classe ProfesseurVacataire

public class ProfesseurVacataire extends Professeur {
-  étend la classe Professeur private static final double TAUX_HORAIRE = 300 ;
private double nombreHeures ;
-  TAUX_HORAIRE et nombreHeures public ProfesseurVacataire(
salaire du professeur String nom, String prenom,
String cours, int nombreHeures) {
super(nom, prenom, cours) ;
-  Constructeur [Link] = nombreHeures;
}
-  setters et getters pour
public double getNombreHeure() { return nombreHeures ; }
nombreHeures
public void setNombreHeure(double nombreHeures) {
-  toString() non redéfinie mais if (nombreHeures<0)
[Link] = 0 ;
héritée else [Link] = nombreHeures ;
}
-  implémente calculSalaire()
public double calculSalaire() {
à classe concrète return nombreHeures * TAUX_HORAIRE ;
}

© Karim Bouzoubaa 73
6.13 Troisième principe de la POO : Le polymorphisme

l  Programme de test

public class GestionPaie {

public static void main (String args[]) {

int j;
Etudiant unEtudiant = new Etudiant("Karim", "Merzaki", 17, 16, 25) ;
Employe unEmploye = new Employe("Hamid", "Mouline", 4500) ;
ProfesseurPermanent unProfPermanent = new ProfesseurPermanent("Majid","Madihi",5000);
ProfesseurVacataire unProfVacataire = new ProfesseurVacataire("Mohamed","Fermachi",50);

Personne lesSalaries[] = new Personne[4];

lesSalaries[0] = unEtudiant;
lesSalaries[1] = unEmploye ;
lesSalaries[2] = unProfPermanent;
lesSalaries[3] = unProfVacataire;

for (i=0;i<=[Link]-1; i++)

j = i + 1;
[Link]("\n\nLe salarie num " + j + " est un " + lesSalaries[i].getClass().getName());
[Link](lesSalaries[i]);
[Link]("\nSon salaire est de : " + lesSalaries[i].calculSalaire() + "DH");
}
}
}

© Karim Bouzoubaa 74
6.13 Troisième principe de la POO : Le polymorphisme

l  Création d’un objet de chaque type des quatre classes concrètes
Etudiant, Employe, ProfesseurPermanent et ProfesseurVacataire

Etudiant unEtudiant = new Etudiant("Karim", "Merzaki", 17, 16, 25) ;

Employe unEmploye = new Employe("Hamid", "Mouline", 4500) ;
ProfesseurPermanent unProfPermanent = new ProfesseurPermanent("Majid","Madihi",5000);
ProfesseurVacataire unProfVacataire = new ProfesseurVacataire("Mohamed","Fermachi",50);

l  Création d’un tableau de 4 Personnes

l  A chaque emplacement du tableau, nous affectons un des objets
déjà créés précédemment puisque les 4 objets sont d’un type sous
classe de la classe Personne

Personne lesSalaries[] = new Personne[4];

lesSalaries[0] = unEtudiant;
lesSalaries[1] = unEmploye ;
lesSalaries[2] = unProfPermanent;
lesSalaries[3] = unProfVacataire;

© Karim Bouzoubaa 75
6.13 Troisième principe de la POO : Le polymorphisme

l  Traitement polymorphique dans la boucle

-  Affichage du numéro du salarié dans le tableau mais surtout le type d’objet
auquel il appartient getClass().getName()
-  sans faire appel au type d’objet, appel à toString() pour afficher le nom et
prénom ainsi que les informations selon le type d’objet (les notes pour les
étudiants, le poste pour les employés, le cours pour les professeurs
-  Finalement, calcul du salaire et son affichage

for (i=0;i<=[Link]-1; i++) {

j = i + 1;
[Link]("\n\nLe salarie num " + j + " est un " + lesSalaries[i].getClass().getName());
[Link](lesSalaries[i]);
[Link]("\nSon salaire est de : " + lesSalaries[i].calculSalaire() + "DH");
}

© Karim Bouzoubaa 76
6.13 Troisième principe de la POO : Le polymorphisme
l  Dans cette boucle, grâce au polymorphisme
-  Développeur n’a pas à se soucier du spécifique (connaître à chaque fois le type d’objet)
mais programme dans le général
-  4 objets Etudiant, Employe, ProfesseurPermanent et ProfesseurVacataire partagent la
même superclasse Personne et nous les avons traité dans la boucle comme étant des
instances de cette superclasse
-  4 objets ont réagi tous aux appels des méthodes toString() et calculSalaire() chacun
avec un comportement différent

!
© Karim Bouzoubaa 77