Chapitre 6

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
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
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 ;
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é
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
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
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
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
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é
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()
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
l  Structure d’une

classe Java
l  Exemple de classe Java : la classe Etudiant

1.  // prog 6.1: Etudiant.java
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
l  Exemple de classe Java : la classe Professeur

1.  // prog 6.3: Professeur.java
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
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
1.  // TestEtudiantProfesseur.java
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.  e1.nom = "Merzaki";
17.  e1.prenom = "Ali";
18.  e1.note1 = 12;
19.  e1.note2 = 14;
20. 
21.  p1 = new Professeur();
22.  p1.nom = "Tachfine";
23.  p1.prenom = "Hamid";
24.  p1.nombreHeures = 10;
25. 
26.  nomCompletEt = e1.getNomComplet();
27.  moy = e1.getMoyenne();
28.  System.out.println("La moyenne de l’étudiant "+ nomCompletEt +" est :"+moy);
29. 
30.  nomCompletPr = p1.getNomComplet();
31.  sal = p1.getSalaire();
32.  System.out.println("Le salaire du professeur "+ nomCompletPr +" est :"+sal);
33.  }
34.  }// Fin de la classe TestEtudiantEtProfesseur
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
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
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
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 "." :

-  e1.nom
-  e1.getNomComplet()
16.  e1.nom = "Merzaki";

17.  e1.prenom = "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
21.  p1 = new Professeur();

22.  p1.nom = "Tachfine";
23.  p1.prenom = "Hamid";
24.  p1.nombreHeures = 10;
l  Lignes 21 à 24
-  créer en mémoire l’objet p1
-  donner des valeurs à ses différentes données
26.  nomCompletEt = e1.getNomComplet();

27.  moy = e1.getMoyenne();
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 ;
-  Résultat : Affectation (12+14)/2 = 13 à moy
public String getNomComplet() {
return nom + " " + prenom;
}
public double getMoyenne() {
return (note1 + note2)/2;
}
}
30.  nomCompletPr = p1.getNomComplet();

31.  sal = p1.getSalaire();
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 double getSalaire () {

return TAUX_HORAIRE * nombreHeures ;
}
}
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)
l  Exécution du programme
-  Trois classes dans trois fichiers différents : 1) Etudiant.java, 2) Professeur.java et
3) TestEtudiantProfesseur.java
-  3) utilise 1) et 2) à nécessité de compiler 1) et 2) avant 3)
6.3 Contrôle d’accès aux données
l  Classe Etudiant
public String nom ;
-  Données précédées par public public
public
String
double
prenom ;
note1 ;
-  Modificateur d’accès : indique la manière
avec laquelle il est possible d’accéder à return nom + " " + prenom;
une donnée/méthode/classe }
-  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();

e1.nom = "Merzaki";
e1.prenom = "Ali";
e1.note1 = 12;
e1.note2 = 14;
}
}
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() {

l  Restreindre l’accès à la donnée note1 }
pour intégrité }
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();

e1.nom = "Merzaki";
déclarée e1.prenom = "Ali";
e1.note1 = 12;
l  Exemple e1.note2 = 14;
}
}
l  Que faire pour permettre public class Etudiant {
private String nom ;
private String prenom ;
quand même de changer la private double note1 ;
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() {

donnée au sein de la }
méthode }
l  Programme de test
public class TestEtudiant2 {
public static void main(String args[]) {
String nomCompletEt;
double moy;
Etudiant e1, e2 ;
e1 = new Etudiant();
e1.setNom("Merzaki");
e1.setPrenom("Ali");
e1.setNote1(12);
e1.setNote2(14);
e2 = new Etudiant ();
e2.setNom("Hamdane");
e2.setPrenom("Youssef");
e2.setNote1(-6);
e2.setNote2(24);
nomCompletEt = e1.getNomComplet();
moy = e1.getMoyenne();
System.out.println("La moyenne de l’étudiant "+ nomCompletEt +" est :« + moy);
System.out.println("La moyenne de l’étudiant " + e2.getNom() + " " + e2.getPrenom() + " est :" +
(e2.getNote1()+e2.getNote2())/2);
}
}
6.4 Utilisation de la référence this
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 {
-  Logique de nommer ces paramètres avec le même private String prenom ;
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;
}
…
}
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 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);
}
…
6.5 Surcharge des constructeurs
l  Exemple

Etudiant e1, e2 ;
e1 = new Etudiant();
e2 = new Etudiant ("Hamdane", "Youssef", -6, 24 );
System.out.println(
"La moyenne de l’étudiant " + e1.getNomComplet() + " est :" + e1.getMoyenne() );
System.out.println(
"La moyenne de l’étudiant " + e2.getNomComplet() + " est :" + e2.getMoyenne() );
}
}
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
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
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 this.jour = 1;
else this.jour = 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 + "]";
}
l  Etape 2 : Redéfinir la classe Etudiant
-  Rajouter une date de naissance comme étant une donnée de type Date

private Date dateDeNaissance ;
public Etudiant(String nom, String prenom,

double note1, double note2, Date dateDeNaissance ) {
this.nom = nom ;
this.prenom = prenom ;
this.note1 = note1 ;
this.dateDeNaissance = dateDeNaissance ;
}
public String toString() {

return nom + " " + prenom + "," +
(note1+note2)/2 + "," + dateDeNaissance ;
}
}
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 System.out.println("L’étudiant est " + etudiant );
}
}
etudiant date
5BC8 C98A jour

5
mois
11
nom
Hamdane annee
Prenom 1980
Youssef
note1
12
note2
14
dateDeNaisssance
C98A
l  Exécution
l  Exécution grâce à la ligne :

System.out.println("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 etudiant.toString())
-  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)
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

private double note ;
private int compteur = 0 ;
public Etudiant(String nom, String prenom, double note ) {

this.nom = nom ;
this.note1 = note ;
compteur++ ;
}
public int getCompteur() { return compteur; }
l  Programme de test : problème
Etudiant e1, e2 ;
e1 = new Etudiant("Hamdane", "Youssef", 12);

System.out.println("Le nombre d’étudiants créé est" + e1.getCompteur());
e2 = new Etudiant("Marzaki", "Ali", 15);

}
}
e2 nom
e1 nom
A49D Merzaki
4AC5 Tachfine
prenom prenom
Hamid Ali
note note
12 15
compteur compteur
1 1
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)

private static int compteur = 0 ;

this.nom = nom ;
this.note1 = note ;
System.out.println("Création de l’étudiant " + nom + " " + prenom);
compteur++ ;
}
public static int getCompteur() { return compteur; }
l  Même programme de test : sauf Etudiant.getCompteur()
Etudiant e1, e2 ;
System.out.println("Le nombre d’étudiants créé est" + Etudiant.getCompteur());


}
}
e2 nom
e1 nom
A49D Merzaki
4AC5 Tachfine
prenom prenom
Hamid Ali
note note
12 2 15
compteur compteur
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
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 System.gc() (g pour garbage et c pour collector)
l  Intervalle de temps régulier
Etudiant e1, e2 ;
System.out.println("Le nombre d’étudiants créé est" + Etudiant.getCompteur());
e1 = null ;
System.gc() ;
}
}
e1 e2 nom
A49D Merzaki
null
prenom
Ali
note
2 15
compteur
l  Problème qui persiste : mettre à jour le compteur
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
private static int compteur = 0 ;

this.nom = nom ;
this.note1 = note ;
System.out.println("Création de l’étudiant " + nom + " " + prenom);
compteur++ ;
System.out.println("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 System.out.println("Suppression de l’étudiant " +nom+ " " + prenom);
mémoire compteur-- ;
System.out.println("Le nombre d’étudiants est : " + compteur);
Décrémente compteur }
affiche sa nouvelle
valeur public static int getCompteur() { return compteur; }

l  Programme test Etudiant e1, e2 ;
e1 = null ;
e2 = null ;
System.gc() ;
}
}
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.)
l  Classe Personne
public class Personne {

public String getNom() { return nom ; }

public String getPrenom() { return prenom ; }
public void setNom(String nom) {
this.nom = nom ;
}
public void setPrenom(String prenom) {
}
}
}
l  Classe Etudiant hérite de la classe Personne
public class Etudiant extends Personne
public class Etudiant extends Personne {
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() {
-  Méthode toString() définie dans les deux }
classes public String toString() {
return super.toString() + " "
l  toString() : Etudiant + note1 + " " + note2;
}
l  super.toString() : Person
}
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)
this.nombreHeures = 0 ;
else this.nombreHeures = nombreHeures ;
}
public int getSalaire() {
return TAUX_HORAIRE * nombreHeures ;
}

return super.toString() + " "
+ nombreHeures ;
}
}
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
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
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)
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
public class TestEtudiantEtProfesseur2 {
l  Programme public static void main(String args[]) {

Personne personne;
de test Etudiant etudiant ;
Professeur professeur ;
personne = new Personne();

personne.setNom("Moumen");
personne.setPrenom("Khalid");
etudiant = new Etudiant();

etudiant.setNom("Merzaki");
etudiant.setPrenom("Ali");
etudiant.setNote1(12);
professeur = new Professeur();

professeur.setNom("Tachfine");
professeur.setPrenom("Hamid");
professeur.setNombreHeures(10);
System.out.println("La personne est "+ personne);

System.out.println("L’étudiant est "+ etudiant);
System.out.println("Le professeur est "+ professeur);
}
}
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)
6.11 Données avec modificateur d’accès protected
public class Personne {
protected String nom ;
protected String prenom ;
public String getNom() { return nom ; }

this.nom = nom ;
}
public void setPrenom(String prenom) {
this.prenom = prenom ; public class Etudiant extends Personne {
} private double note1 ;
return nom + " " + prenom; public double getNote1() { return note1 ; }
}
public void setNote1(double note1) {
} if (note1<0 || note1>20)
this.note1 = 0;
}
this.note2 = 0;
}
}
return "L’étudiant " + nom + " " + prenom +
" possède les notes : " + note1 + " et " + note2;
}
}
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();

etudiant.setNom("Merzaki");
etudiant.setPrenom("Ali");
System.out.println(etudiant);
}
}
6.12 Les constructeurs dans les sous classes
l  Dans la classe Personne : pas public class Personne {
de constructeur protected String nom ;

-  Ajout d’un étudiant ou professeur public Personne (String nom, String prenom) {
nécessite plusieurs instructions this.nom = nom;
this.prenom = prenom;
}
-  Objectif : Ajouter un étudiant en
une seule instruction public String getNom() { return nom ; }
l  Créer un constructeur dans la this.nom = nom ;
}
classe Personne public void setPrenom(String prenom) {
l  Créer un constructeur dans la }
classe Etudiant en profitant du return nom + " " + prenom;
constructeur Personne }
}
6.12 Constructeurs dans les sous classes

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 ;
Personne }

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

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

}
return "L’étudiant " + nom + " " + prenom +
" possède les notes : " + note1 + "
et " + note2;
}
}
6.12 Constructeurs dans les sous classes


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

etudiant = new Etudiant("Merzaki", "Ali", 12, 14);
System.out.println(personne);
System.out.println(etudiant);
}
}
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
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
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() {
System.out.print("miau");
}
…
•  Implémentation de la méthode
} abstraite héritée de la classe Animal
public class Test •  Une classe de test

Animal a = new Animal();
Chat c = new Chat(); •  Pas possible de créer un objet de
c.parler(); type Animal
} •  Possible de créer un objet de type
} Chat
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
public abtract class Personne {
l  classe Personne protected String nom ;

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

this.nom = nom;
-  setters et getters }
this.prenom = prenom;
public String getNom() {

-  toString() return nom ;
}
-  calculSalaire() public String getPrenom() {
return prenom ;
l  abstraite }
this.nom = nom ;
l  déclarer la méthode sans }
l’implémenter en fermant la public void setPrenom(String prenom) {
ligne par un point virgule "; }
l  redéfinie pour chaque sous return "\nNom: " + nom + " - Prenom : " + prenom;
classe de Personne }
public abstract double calculSalaire() ;
}
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) {
-  TAUX_HORAIRE statique car applicable this.note2 = note2 ;
this.nombreHeures = nombreHeures ;
à tous les étudiants }
-  constructeur public double getNote2() { return note2 ; }
public double getNombreHeure() { return nombreHeures ; }
-  setters et getters pour les trois if (note1<0 || note1>20)
données note1, note2 ainsi que this.note1 = 0;
nombreHeures }
-  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)
notes et sa moyenne else this.nombreHeures = nombreHeures ;
}
-  implémente calculSalaire() à public double getMoyenne() {
classe concrète }
return super.toString() +
"\nIl possede les notes : " + note1 + " et " + note2 ;
}
public double calculSalaire() {
return nombreHeure * TAUX_HORAIRE ;
}
}
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) {
-  constructeur this.salaire = salaire ;
this.poste = 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 this.salaire = 0 ;
else this.salaire = 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 this.poste = poste ;
}
-  implémente calculSalaire() à return super.toString() +
classe concrète "\nIl est au poste de : " + poste;
}
return salaire ;
}
}
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) {
this.cours = 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 this.cours = cours ;
}
concernant le professeur en
question, à savoir son cours public String toString() {
return super.toString() +
-  calculSalaire() non encore }
"\nIl enseigne le cours : " + cours;
implémentée, ce qui en fait une }

classe abstraite
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 this.salaire = 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)
this.salaire = 0 ;
classe concrète else this.salaire = salaire ;
}

return salaire ;
}
}
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 this.nombreHeures = nombreHeures;
}
-  setters et getters pour
public double getNombreHeure() { return nombreHeures ; }
nombreHeures
public void setNombreHeure(double nombreHeures) {
-  toString() non redéfinie mais if (nombreHeures<0)
héritée else this.nombreHeures = nombreHeures ;
}
-  implémente calculSalaire()
à classe concrète return nombreHeures * TAUX_HORAIRE ;
}

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<=lesSalaries.length-1; i++)

j = i + 1;
System.out.print("\n\nLe salarie num " + j + " est un " + lesSalaries[i].getClass().getName());
System.out.print(lesSalaries[i]);
System.out.print("\nSon salaire est de : " + lesSalaries[i].calculSalaire() + "DH");
}
}
}
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;
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<=lesSalaries.length-1; i++) {

j = i + 1;
System.out.print("\n\nLe salarie num " + j + " est un " + lesSalaries[i].getClass().getName());
System.out.print(lesSalaries[i]);
System.out.print("\nSon salaire est de : " + lesSalaries[i].calculSalaire() + "DH");
}
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
!

Chapitre 6

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 6

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 6 : Programmation Orientée-Objet

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

l Invention de la programmation modulaire

l Illustration des limites de la programmation modulaire

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

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

- Type des arguments pour comprendre sur quel type de

à Seul le nom de la fonction ne renseigne

l 2) Problème d’arguments

- Ajout d’un professeur ajouter(struct professeur)

- Nom significatif mais cela nécessiterait de voir le

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

l 3) Problème de redondance

- Ajout d’un professeur ajouterProfesseur(struct professeur)

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

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

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

à Maintenance difficile et coûteuse

à Traiter des instructions en redondance

l Principe de la programmation modulaire :

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

l Programmation orientée-objet :

l Structure d’une

l Exemple de classe Java : la classe Etudiant

l Exemple de classe Java : la classe Professeur

l Les classes Etudiant et Professeur sont des

l Besoin d’une autre classe de test

l Variables de travail

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

l Sur le plan mémoire:

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

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

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

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

- 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

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

16. e1.nom = "Merzaki";

l Lignes 16 et 19 consistent à donner des

21. p1 = new Professeur();

26. nomCompletEt = e1.getNomComplet();

public class Etudiant {

30. nomCompletPr = p1.getNomComplet();

l Ligne 31 public class Professeur {

public String nom ;

public double getSalaire () {

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

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

- Exemple e1 = new Etudiant();

public String nom ;

à incohérence public String getNomComplet() {

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[]) {

l private : donnée accessible Professeur p1 ;

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

autre classe tout en public

public void setPrenom(String p) {

l Solution utilisée en POO }

public void setNote1(double n1) {

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

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

l  Invention de la programmation modulaire

l  Illustration des limites de la programmation modulaire

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

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

-  Type des arguments pour comprendre sur quel type de

à  Seul le nom de la fonction ne renseigne

l  2) Problème d’arguments

-  Ajout d’un professeur ajouter(struct professeur)

-  Nom significatif mais cela nécessiterait de voir le

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

l  3) Problème de redondance

-  Ajout d’un professeur ajouterProfesseur(struct professeur)

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

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

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

à Maintenance difficile et coûteuse

à  Traiter des instructions en redondance

l  Principe de la programmation modulaire :

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

l  Programmation orientée-objet :

l  Structure d’une

l  Exemple de classe Java : la classe Etudiant

l  Exemple de classe Java : la classe Professeur

l  Les classes Etudiant et Professeur sont des

l  Besoin d’une autre classe de test

l  Variables de travail

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

l  Sur le plan mémoire:

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

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

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

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

-  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

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

16.  e1.nom = "Merzaki";

l  Lignes 16 et 19 consistent à donner des

21.  p1 = new Professeur();

26.  nomCompletEt = e1.getNomComplet();

30.  nomCompletPr = p1.getNomComplet();

l  Ligne 31 public class Professeur {

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

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

-  Exemple e1 = new Etudiant();

l  Conseillé (primordiale) de ne pas }

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

l  private : donnée accessible Professeur p1 ;

l  Solution utilisée en POO }

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

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

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

l  Solution Java : ramasse miettes (Garbage collector en

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

l  Exemple concernant notre établissement d’enseignement

à  considérer le traitement une seule fois

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

l  Classes Etudiant et Professeur sont des sous

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

l  Avantages de l’héritage :

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

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

l  Programme public class TestEtudiant3 {

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

l  Programme de test

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

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

public class Test •  Une classe de test

l  classe Personne protected String nom ;

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

l  Classe Employe

l  Classe Professeur

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