Niveau: 2ème Année GL

Enseignante: Sana HAMDI

Email: [Link]@[Link]
[Link]@[Link]
Chapitre1: Introduction à la programmation orientée objet
Chapitre2 : Notions de base Java
Chapitre3 : Classes et Objets Java
Chapitre4 : Héritage, Polymorphisme et Classes Abstraites
Chapitre5 : Les Interfaces
Chapitre6 : Les Exceptions

2
CHAPITRE4

3
PLAN DU CHAPITRE 5
1. Héritage
2. Polymorphisme
3. Classes Abstraites

4
PLAN DU CHAPITRE 5
1. Héritage
2. Polymorphisme
3. Classes Abstraites

5
 public class Enseignant{
private String nom ,prenom ;
public class Personne{ private int age;
private String nom; private String matiere;
private String prenom; public enseignant(){
private int age; prenom = null; Code Redondant!!
public Personne(){ nom = null; Solution??
nom = null; age = 0;
prenom = null; matiere= null;
age=0; }
public void afficher (){
}
[Link](prenom+","
} +nom+","+age+","+ matiere);
}
} 6
 Le concept d’héritage consiste à réutiliser ce qui a été défini pour une classe (la
super-classe) par une autre classe (la classe dérivée) tout en le spécialisant.
 Une sous classe n’accède pas aux membres privés de la super-classe.
 Pour que les variables et les méthodes de la classe mère soient accessibles
uniquement aux classes dérivées, on utilise le modificateur protected
Personne
#String nom,prenom
#int age

Enseignant
- String matiere

+ void afficher()
7
 Pour désigner un héritage d’une classe mère,on utilise le mot clé extends

 Syntaxe: public class nomClasseDerivee extends nomClasseMere

 Par défaut, une classe (qui n’ a pas d’extends dans sa définition) hérite de la
classe Object, qui est la superclasse de toutes les classes
 Déclarer seulement les attributs qui ne figurent pas dans la classe mère
 Utiliser le mot clé super pour invoquer les méthodes et les attributs de la classe
mère
Une classe ne peut avoir qu’une seule super-classe. Il n’y a pas d’héritage
multiple en Java. Par contre, elle peut avoir plusieurs sous-classes.
8
 Constructeur:
 Une sous-classe réutilise le code des constructeurs de la super-classe dans la définition
de ses propres constructeurs.

 L’invocation d’un constructeur de la super-classe se fait par le mot clé super suivi par
les éventuels arguments.

super(paramètres du constructeur de la classe mère)

 super ( ) doit être la première instruction du constructeur de la classe fille.

 Si la sous classe ne possède aucun constructeur, la classe mère doit disposer d’un
constructeur publique sans paramètres (ou aucun constructeur)

9
 public class Personne{
protected String nom;
protected String prenom;
protected int age;
public Personne(){
nom = null;
prenom = null;
age=0;
}
}
public class Enseignant extends Personne{
private String matiere;
public enseignant(){
super();
matiere = null;
} Code non Redondant!
}

 super () doit être la première instruction du constructeur de la classe fille.

 Si la 1ère instruction n’est pas un appel de ce type, Java insère automatiquement
l’appel super() (constructeur par défaut sans paramètres)

10
public class Point {
double x, y ;

public Point (double x, double y) {

this.x = x ;
this.y = y ;
}
…
}

public class PointCouleur extends Point {

Color c;
public PointCouleur (double x, double y, Color c) {

super(x, y) ;
L’appel au constructeur de la super-classe
this.c = c ; Doit toujours être la première instruction
} du corps du constructeur
…
}
11
 super () doit être la première instruction du constructeur de la
classe fille.
 Si la 1ère instruction n’est pas un appel de ce type, Java insère
automatiquement l’appel super()(constructeur par défaut sans
paramètres)

 Chaque fois qu’un objet est créé, les constructeurs sont invoqués en
remontant la hiérarchie jusqu’à la classe Object

12
public class Object {

public Object() { 3
…
} …
}

Ordre des appels

public class Point extends Object {
double x, y ;
public Point(double x, double y) {
super() 2
this.x = x ; this.y = y ;
}…
}

public class PointCouleur extends Point {

Color c ;

public PointCouleur(double x,double y,Color c){

super (x, y) ; 1
this.c = c ;
} … new PointCouleur(…);
} 13
 public class ClasseA {
double x;
// constructeur
public ClasseA(double x) { Constructeur explicite
this.x = x; Masque constructeur par défaut
}
}

public class ClasseB extends ClasseA {

public ClasseB {
double y = 0 ;
Super();
}
// pas de constructeur
} Constructeur par défaut implicite

C:> javac [Link]

[Link][Link] No constructor matching ClasseA() found in classe ClasseA.
public ClasseB() {
^
1 error
Compilation exited abnormally with code 1 at Sat Jan 29 [Link] 14
 C’est la classe dont hérite implicitement toute classe.
 Conséquences:
 Toute classe hérite les méthodes publiques de la classe Object:
- toString()
- equals()….
 Tout objet peut être affecté à une variable de type Object

15
PLAN DU CHAPITRE 5
1. Héritage
2. Polymorphisme
3. Classes Abstraites

16
 Redéfinition d’une méthode de la super –classe pour la spécialiser

 Lorsque la classe définit une méthode dont la signature est

identique à celle d’une méthode héritée.
 nom + types paramètres + type retour = signature

 Lorsqu’une méthode redéfinie par une classe est invoquée par un

objet de cette classe, c’est la nouvelle définition et non pas celle de
la super-classe qui est exécutée

17
public class A {
public void hello() {
[Link](« hello ») ;
}
public void affiche() { A a = new A();
[Link](« je suis un A »)
B b = new B();
;
}
} [Link]() ; --> hello
[Link](); --> je suis un A

[Link]() ; --> hello

public class B extends A {
[Link]() ; --> je suis un B
public void affiche() {
[Link](« Je suis un B ») ;
}

}
18
 Possibilité de réutiliser le code de la méthode héritée (super) (redéfinition avec réutilisation)

public class Etudiant {

String nom ;
String prenom ;
int age ;
…
public void affiche () {
[Link](“nom : ”+ nom + “prénom : ”+ prenom) ;
[Link](“Age : ”+ age);
…
} public class EtudiantSportif extends Etudiant {
… String sportPratiqué ;
} …
public void affiche() {
[Link]() ;
[Link](“Sport pratiqué ” + sportPratiqué );
}
…
} 19
 Une méthode déclarée final ne peut pas être redéfinie
dans une sous classe.

 Une classe déclarée final ne peut plus être dérivée.

20
 La surcharge d’une méthode héritée consiste à écrire une méthode avec le même
nom mais avec des arguments différents et/ou type de retour différent.
 Ne pas confondre redéfinition (overriding) avec surcharge (overloading)

public class A {
public void methodeX(int i) {
}
}

surcharge redéfinition

public class B extends A { public class C extends A {

public void methodeX(double i){ public void methodeX(int j) {
} }
} }

B possède deux méthodes

C possède une seule méthode
• methodeX(int)
• methodeX(int) 21
•methodeX(double)
 Dans un établissement d’enseignement et de manière schématique,
on trouve trois sortes de personnes : des administratifs représentés
par la catégorie secrétaire, des enseignants et des étudiants. Chaque
personne est caractérisée par son nom et prénom, son adresse (rue
et ville)
 nbPersonnes est une variable de classe qui comptabilise le nombre
de Personne dans l’établissement.

22
 Personne

#String nom
#String prénom
#String rue
#String ville
#static int nbpersonnes
+Personne( String nom, String prenom, String rue, String ville)
+String toString()
+static void nbPersonne()
+void modifierPersonne (String rue, String ville)

Enseignant Etudiant
Secretaire
- String specialite - String diplomeEncours
- String numbureau - static int nbEnseignants - static int nbEtudiants
- static int nbSeceratires
+Enseignant( String nom, +Enseignant( String nom,
+Secretaire( String nom, String String prénom, String rue, String prénom, String rue,
prénom, String rue, String ville, String ville, String String ville, String
String numbureau) specialite) diplomeEncours)
+String toString() +String toString() +String toString()
+static int nbsecretaire() +static int nbenseignant() +static int nbetudiants()
23
23
 On définit les méthodes public suivantes de la classe Personne :
1. le constructeur Personne (String nom, String prenom, String rue, String ville) :
crée et initialise un objet de type Personne.
2. String toString () : fournit une chaîne de caractères correspondant aux
caractéristiques (attributs) d’une personne.
3. static nbPersonnes () : écrit le nombre total de personnes et le nombre de
personnes par catégorie. C’est une méthode de classe.
4. modifierPersonne (String rue, String ville) : modifie l’adresse d’une personne.

24
 Les méthodes suivantes sont définies pour un objet de la classe Secretaire :
1. Secretaire (String nom, String prenom, String rue, String ville, String numeroBureau) :
le constructeur d’un objet de la classe Secretaire doit fournir les caractéristiques
pour construire une Personne, plus les spécificités de la classe Secretaire (numéro
de bureau).
2. String toString () : fournit une chaîne contenant les caractéristiques d’une Secretaire
 De même, un Enseignant est une Personne enseignant une spécialité (mathématiques,
informatique, anglais, gestion, etc.). Un Etudiant est une Personne préparant un diplôme
(diplomeEnCours). Les méthodes pour Enseignant et Etudiant sont similaires à celles
de Secretaire.
 Une variable privée static dans chaque classe compte le nombre de personnes créées
dans chaque catégorie.
 Une méthode static du même nom que la variable fournit la valeur de cette variable
static (nbSecretaires, nbEnseignants, nbEtudiants).
25
class Personne { public String toString () {

protected String nom; return nom + “ “ + prenom + “ “+ rue + “ “+ville;

protected String prenom; }

static void nbpersonnes () {
protected String rue;
[Link] (“\n Nombre d’employés :“ +
protected String ville;
nbPersonnes + “\n Nombre de secretaires : “ +
protected static int nbPersonnes = 0; [Link]() + “\n Nombre d’enseignants : “ +
Personne (String nom, String prenom, String rue, [Link]() + “\n Nombre d’étudiants : “ +
String ville) { [Link]() );

[Link]=nom; }

[Link]=prenom; void modifierPersonne (String rue, String ville) {

[Link]=rue;
[Link]=rue;
[Link]=ville;
[Link]=ville;
}
nbpersonnes++;
} // fin Personne
}

26
class Secretaire extends Personne {
private String numBureau;
private static int nbSecretaires;
Secretaire (String nom, String prenom, String rue, String ville, String numBureau) {
super(nom,prenom,rue,ville);
[Link]=numBureau;
nbSecretaires++;
}
public String toString () {
return [Link]()+ “\n Numero de bureau : “ + numBureau;
}
static int nbSecretaire () {
return nbSecretaires;
}
} // fin Secretaire

27
class Enseignant extends Personne {
private String specialite;
private static int nbEnseignants;
Enseignant (String nom, String prenom, String rue, String ville, String specialite) {
super (nom,prenom,rue,ville);
this. specialite = specialite;
nbEnseignants++;
}
String toString () {
return [Link]()+ “\n Specialité : “ + specialite;
}

static int nbEnseignant () {

return nbEnseignants;
}
} // fin Enseignant
28
class Etudiant extends Personne {
private String diplomeEncours;
private static int nbEtudiants;
Etudiant (String nom, String prenom, String rue, String ville, String
diplomeEncours) { super (nom,prenom,rue,ville);
this. diplomeEncours = diplomeEncours;
nbEtudiants++;
}
String toString () {
return [Link]()+ “\n diplôme En cours : “ + diplômeEncours;
}
static int nbEtudiant () {
return nbEtudiants;
}
} // fin Etudiant 29
class TestPersonne {

public static void main (String [] args) {

Secretaire sec1= new Secretaire (“Tounsi“, “Alia“, “Gambatta“, “tunis“, “B128“);

Enseignant ens1= new Enseignant (“Abidi“, “Hedi“, “Montfleury“, “tunis“, “BD“);

Etudiant etud1= new Etudiant (“Samet“, “Ali“, “Manar“, “tunis“, “Ingenieur“);

String S = [Link]();

[Link]();

[Link](“Menzah“, “Tunis2“);

[Link](“Rades“, “Ben Arous“);

} // fin TestPersonne

30
 Surclassement (super-type = sous-type) :

 À une référence déclarée de type A, il est possible d’affecter une valeur qui est une référence

vers un objet de type B

 Plus généralement à une référence d’un type donné, il est possible d’affecter une valeur qui

correspond à une référence vers un objet dont le type effectif est n’importe quelle sous-classe

directe ou indirecte du type de la référence (upcasting)

 Notez que la classe Object joue un rôle particulier car toute instance de Object peut référer

n’importe quel objet

31
 Lorsqu’un objet est « sur-classé » il est vu comme un objet du type de
la référence utilisée pour le désigner

 Ses fonctionnalités sont alors restreintes à celles proposées par la

classe du type de la référence

32
EtudiantSportif es ;
Etudiant
es = new EtudiantSportif (“Tounsi”,“Ali”, 20,..,”Bodybuilding”,..);
String nom ;
es String prénom ;
Etudiant e;
int age ;

e = es ; // surclassement e
public Etudiant(String n,
String p,int a)
[Link]() ;
public void affiche() {…}
isa public int nbInscriptions()
[Link]() ;
Tounsi
[Link]();
Ali EtudiantSportif
[Link]();
20 String sportPratiqué;
[Link](); …

Body... public EtudiantSportif(String n,

[Link](); String p,int a, String s)

((EtudiantSportif) e).bonusSportif();//Substituer e par (EtudiantSportif) e public void affiche() {…}

public double bonusSportif() 33
 Polymorphisme : possibilité d’affecter à une référence d’un type donné

(i.e. une classe) une valeur qui désigne un objet du type de la référence ou d’une

sous classe de ce type

Etudiant e = new EtudiantSportif(“Tounsi”,“Ali”, 20, “Bodybuilding”);

34
 Etudiant
Question : La méthode affiche() de Etudiant est redéfinie dans
String nom ;
EtudiantSportif; Quelle méthode affiche() sera exécutée dans le code String prénom ;
int age ;
suivant? celle de Etudiant ou celle de EtudiantSportif ?
public Etudiant(String n,
Etudiant e = new EtudiantSportif String p,int a)
(“Tounsi”,“Ali”, 20, “Bodybuilding”); public void affiche() {…}
//e est un objet de la classe EtudiantSportif public int nbInscriptions()
mais il est déclaré de la classe Etudiant
?
[Link](); EtudiantSportif
String sportPratiqué;
…
Réponse: c’est la méthode de la classe ?
public EtudiantSportif(String n,
EtudiantSportif qui sera exécutée String p,int a, String s)

Lorsqu’une méthode d’un objet est accédée au travers d’une public void affiche() {…}
référence “surclassée”, c’est la méthode définie au niveau de public double bonusSportif()
la classe réelle de l’objet qui est invoquée et exécutée 35
 Polymorphisme : possibilité d’affecter à une référence d’un type donné

(i.e. une classe) une valeur qui désigne un objet du type de la référence ou d’une sous

classe de ce type

Etudiant e = new EtudiantSportif(“Tounsi”,“Ali”, 20, “Bodybuilding”);

 À l’exécution, la référence peut désigner un objet qui prend des « formes » différentes

selon sa classe effective (dans ce cas EtudiantSportif)

36
Nom[] noms = new Nom [4];
noms[0] = new NomComplet(“Ali”, “Tounsi”);
noms[1] = new Nom(“Salhi”);
noms[2] = new NomComplet(“Hamza”, “Gharbi”);
noms[3] = new NomComplet(“Ines”, “Gharbi”);
…
for (int i=0; i<4; i++){
[Link](noms[i].getNom());
} Tounsi
Ali
String getNom(){
Salhi
Gharbi
Quelle
return ([Link]()”\n”+prenom);
Hamza méthode?
Gharbi }
Ines
37
 Même code d’invocation de getNom() toujours sur un objet déclaré de type Nom appliqué aux objets de types
différents…

 on a un effet différent selon l’objet qui reçoit le message, et plus précisément selon sa classe effective.

38
 Dans le cas d’un lien statique (static binding), le type de l’objet
est connu à la compilation.
 Dans le cas d’un lien dynamique (dynamic binding, late-binding
ou run-time binding), le type de l’objet est connu à l’exécution.

 Le compilateur ne connaît pas le type exact de l’objet récepteur d’un message

 Le compilateur n’effectue que les vérifications statiques qui permettent de

garantir que le message pourra être résolu au moment de l’exécution

39
 Liens statiques (static binding)  Liens dynamiques (dynamic binding)

class Personne { class Personne {

public void travailler ( ){ public void travailler ( ){
[Link] (“La personne travaille”); [Link] (“La personne travaille”);

}} }}
class Enseignant extends Personne { class Enseignant extends Personne {
public void travailler ( ) { public void travailler ( ) {
[Link] (“L’enseignant explique le cours”); [Link] (“L’enseignant explique le cours”);
} }
public static void main (String [ ] args) { public static void main (String [ ] args) {
Personne p = new Personne ( ); Personne p = new Enseignant ( );
[Link](); [Link]();
}} 40
}}
 A a;
for (int i=0 ; i<10; i++) {
A
double hasard = [Link]();
public void affiche() {
if (hasard < 0.33)
[Link](“Je suis un A”);
} a=new A ( );
else if (hasard < 0.66)
a = new B ( );
B else

public void affiche() { a = new C ( );

[Link](“Je suis un B”); [Link]() ;
}

On peut afficher le type de a par :

C [Link](“Classe de a : ”+
public void affiche() { [Link]().getName());
[Link](“Je suis un C”);
} On peut aussi tester le type par :
(a instanceof C) -> true si a est
instance de C
41
“Once you know that all method binding in Java happens
polymorphically via late binding, you can always write your code to
talk to the base class, and know that all the derived-class cases will
work correctly using the same code. Or put it another way, you
send a message to an object and let the object figure out the right
thing to do”

Bruce Eckel « Thinking in Java»

42
Le polymorphisme offre :

 Une plus grande simplicité du code

 Plus besoin de distinguer différents cas en fonction de la classe de l’objet

 Une plus grande facilité d’évolution du code

 Les programmes sont plus facilement extensibles car il est possible de définir
de nouvelles fonctionnalités en héritant de nouveaux types de données à
partir d’une classe de base commune sans avoir besoin de modifier le code
qui manipule l’interface de la classe de base
 On peut écrire des programmes capables de travailler avec du code (classes)
qui n’existent pas encore !

43
PLAN DU CHAPITRE 5
1. Héritage
2. Polymorphisme
3. Classes Abstraites

44
 Une classe abstraite est une classe pouvant avoir une ou plusieurs
méthodes abstraites.
 Une méthode est abstraite si on ne donne pas sa définition.
 Conséquences:
 On ne peut pas instancier une classe abstraite
 pour utiliser les méthodes d’une classe abstraite, on doit passer par l’héritage
 dans ce cas, on doit fournir le code de toutes les méthodes abstraites de la
super-classe abstraite

45
 Exemple

abstract class A {
public void f(){
..... // f est définie
}
abstract void g(); // g n'est pas définie
}

46
Intérêt :

 Permet d’imposer des fonctionnalités qu’on voudrait

disposer pour toutes les sous classes.

 On impose aux développeurs des sous classes de suivre

les signatures des méthodes abstraites et de proposer
leurs implémentations

47
 Méthode abstraite

Une méthode sans implémentation est obligatoirement abstraite et elle est définie
par le mot clé abstract
public abstract void draw();

 Classe abstraite
Une classe dont une méthode est abstraite est obligatoirement abstraite et est
donc définie par le mot clé abstract
public abstract class Shape {
public abstract void draw();
}

48
 abstract personne

#String nom
#String prénom
#String rue
#String ville
#static int nbpersonnes
+Personne( String nom, String prenom, String rue, String ville)
+String toString()
+abstract void ecrirePersonne()
+static void nbPersonne()
+void modifierPersonne (String rue, String ville)

Enseignant Etudiant
Secretaire
- String specialite - String diplomeEncours
- String numbureau - static int nbEnseignants - static int nbEtudiants
- static int nbSeceratires
+Enseignant( String nom, +Enseignant( String nom,
+Secretaire( String nom, String String prénom, String rue, String prénom, String rue,
prénom, String rue, String ville, String ville, String String ville, String
String numbureau) specialite) diplomeEncours)
+String toString() +String toString() +String toString()
+void ecrirePersonne() +void ecrirePersonne() +void ecrirePersonne()
49+static int nbsecretaire() +static int nbenseignant() +static int nbetudiants()
49
// class abstraite, non instanciable public String toString () {
abstract class Personne { return nom + “ “ + prenom + “ “+ rue + “ “+ville;

protected String nom; }

protected String prenom; abstract void ecrirePersonne ( ); // méthode abstraite

protected String rue; static int nbpersonnes () {

protected String ville; [Link] (“\n Nombre d’employés :“ +

nbPersonnes + “\n Nombre de secretaires : “ +
protected static int nbPersonnes = 0;
[Link]() + “\n Nombre d’enseignants : “ +
Personne (String nom, String prenom, String rue,
[Link]() + “\n Nombre d’étudiants : “ +
String ville) {
[Link]() );
[Link]=nom;
}
[Link]=prenom;
void modifierPersonne (String rue, String ville) {
[Link]=ville; [Link]=rue;
[Link]=ville; [Link]=ville;
nbpersonnes++; ecrirePersonne();
} }
} // fin Personne

50
class Secretaire extends Personne {
private String numBureau;
private static int nbSecretaires;
Secretaire (String nom, String prenom, String rue, String ville, String numBureau) {
super(nom,prenom,rue,ville);
[Link]=numBureau;
nbSecretaires++;
}
public String toString () {
return [Link]()+ “\n Numero de bureau : “ + numBureau;
}
void ecrirePersonne() {
[Link](“Secretaire : “+toString());
}
static int nbSecretaire () {
return nbSecretaires;
}
} // fin Secretaire

51
class Enseignant extends Personne {
private String specialite;
private static int nbEnseignants;
Enseignant (String nom, String prenom, String rue, String ville, String specialite) {
super (nom,prenom,rue,ville);
this. specialite = specialite;
nbEnseignants++;
}
String toString () {
return [Link]()+ “\n Specialité : “ + specialite;
}
void ecrirePersonne() {
[Link](“Enseignant : “+toString());
}
static int nbEnseignant () {
return nbEnseignants;
}
} // fin Enseignant
52
class Etudiant extends Personne {
private String diplomeEncours;
private static int nbEtudiants;
Etudiant (String nom, String prenom, String rue, String ville, String diplomeEncours) {
super (nom,prenom,rue,ville);
this. diplomeEncours = diplomeEncours;
nbEtudiants++;
}
String toString () {
return [Link]()+ “\n diplôme En cours : “ + diplomeEncours;
}
void ecrirePersonne() {
[Link](“Etudiant : “+toString());
}
static int nbEtudiant () {
return nbEtudiants;
}
} // fin Etudiant

53
class TestPersonne {

public static void main (String [] args) {

Secretaire sec1= new Secretaire (“Tounsi“, “Alia“, “Gambatta“, “tunis“, “B128“);

[Link]();

Enseignant ens1= new Enseignant (“Abidi“, “Hedi“, “Montfleury“, “tunis“, “BD“);

[Link]();

Personne p = new Etudiant (“Samet“, “Ali“, “Manar“, “tunis“, “Ingenieur“);

[Link]();

[Link]();

[Link](“Menzah“, “Tunis2“);

[Link](“Rades“, “Ben Arous“);

} // fin TestPersonne

54
Merci pour votre attention !

Dr. Sana Hamdi

Maitre Assistante en Informatique à l’INSAT

Membre du Laboratoire LIPAH (FST-Tunisie)

et du Laboratoire SAMOVAR (Telecom SudParis-France)