Cours: Programmation Java

Filière: 2 ème LSI

Enseignante: Dr. Majdoub Manel

2023-2024 Programmation JAVA 2eme SI 1

 Plan du cours

Chapitre 1 Introduction
Chapitre 2 Objets et Classes
Chapitre 3 Encapsulation et Surcharge
Chapitre 4 Héritage et Polymorphisme
Chapitre 5 Classes abstraites et Interfaces
Chapi
Chapitre 6 Les collections
tre 5
Chapitre 7 Les exceptions

18/09/2023 POO 2eme SI 2

Chapitre IV: Héritage et Polymorphisme
 Objectifs

I. La notion d’héritage
 L'intérêt de l'héritage
 Le concept de l’héritage
 Maîtriser la notion de redéfinition

II. La notion de polymorphisme

 Les méthodes polymorphes
 Les tableaux polymorphes
 Les arguments polymorphes
 Le mécanisme de la liaison retardée
 Le transtypages

18/09/2023 POO 2eme SI 4

 Introduction

Etudiant Personne Enseignant

Nom Nom Nom

Prenomn Prenomn Prenomn
Anneenais Anneenais Anneenais
Note1 , Note2 salaire

Age() Age() Age()

Moyenne() Salaire()

Problèmes:
 Duplication du code
 Une modification faite sur un attribut (ou méthode) commun doit être
refaite dans les autres classes.

18/09/2023 POO 2eme SI 5

 Concept d’héritage

Solution : Héritage Personne

Nom
Prenomn
Classe mère Anneenais
Age() Relation
d’héritage

Etudiant Enseignant
Note1 , Note2
Classe dérivée salaire Classe dérivée

Moyenne() Salaire()

18/09/2023 POO 2eme SI 6

 Concept d’héritage

•La classe mère contient tous les attributs et toutes les méthodes communs
à toutes les classes.
•La classe fille (classe dérivée ) hérite des méthodes et des attributs de sa
classe mère
•Les classes filles ne comportent que les attributs ou méthodes plus
spécifiques.

class Personne {
String nom; class Etudiant extends Personne {
int cin, anneeNaiss; float note1,note2;
int age() public float moyenne ()
{ { return ((note1+note2)/2);
return 2023- Anneenais; }
} }

18/09/2023 POO 2eme SI 7

 Concept d’héritage

• Java ne supporte pas l'héritage multiple

• Une classe fille ne peut hériter que d'une seule classe mère
Employe
Personne
Nom
Matricule
Prenomn
Anneenais Grade()
Age()

Enseignant

salaire

Salaire()
18/09/2023 POO 2eme SI 8
 Concept d’héritage

• L’héritage en cascade Personne

Nom
La classe Etudiant hérite de la classe Personne Prenomn
La classe EtudiantTerminal hérite de la classe Etudiant Anneenais
La classe EtudiantTerminal hérite de la classe Personne Age()

Etudiant E =new Etudiant();

E.Age(): Etudiant
E.moyenn();
E.moyennefinale(); note1, note2
moyenne()

EtudiantTerminal ET =new EtudiantTerminal();

ET.Age(): EtudiantTerminal
ET.moyenn();
ET.moyennefinale(); Notepfe

moyennefinale()
18/09/2023 POO 2eme SI 9
 Héritage et encapsulation

class B extends A class C extends A

La classe B peut accéder directement à: La classe C peut accéder directement à:
L’attribut x L’attribut x
L’attribut z L’attribut w
L’attribut w

18/09/2023 POO 2eme SI 10

 Constructeur et héritage

•Constructeur par défaut

class Personne { class Etudiant extends Personne {
String nom; float note1,note2;
int cin, anneeNaiss; Public Etudiant()
public Personne() { super fait appel
{ super(); au constructeur
this.nom=“Ali”; note1=0; par défaut de la
this.cin=0; note2=0; classe mère
this. anneeNaiss=2000; }
} public float moyenne ()
int age() { return ((note1+note2)/2);
{ }
return 2023- Anneenais; }
}

18/09/2023 POO 2eme SI 11

 Constructeur et héritage

•Constructeur paramétré
class Personne { String nom; class Etudiant extends Personne {
int cin, anneeNaiss; float note1,note2;
public Personne(String n, int c , int a) Public Etudiant(String n, int c , int a, float
{ n1, float n2)
this.nom=n; {
this.cin=c; super(n, c, a);
this. anneeNaiss=a; note1=n1; super fait appel
} note2=n2; au constructeur
int age() } paramétré de la
{ public float moyenne () classe mère
return 2023- Anneenais; { return ((note1+note2)/2);
} }}

Si un constructeur d’une classe dérivée appelle un constructeur d’une

classe mère, il doit obligatoirement s’agir de la première instruction du
constructeur
18/09/2023 POO 2eme SI 12
 Redéfinition des méthodes

• La redéfinition (override): on garde la même signature de la méthode et on

change le corps
Ne pas confondre la redéfinition et la surcharge des méthodes

Classe Personne { class Etudiant extends Personne

public void afficher() { {
System.out.println(“Je suis personne”); public void afficher()
}} { System.out.println(“Je suis un etudiant”);
super.afficher();
}}

Possibilité de réutiliser le code de la méthode héritée (super)

18/09/2023 POO 2eme SI 13

 Exemple

//classe mère //classe dérivée

class Forme{ class Cercle extends Forme {
Private int x, y ; double rayon ;
public String couleur ; Cercle(int x, int y, double r)
Forme(int x,int y) {
{ super(x,y);
this.x=x; this.rayon=r; }
this.y=y; public double surface ( ) {
} return (rayon * 2* 3.14) ;}
public void affiche () { //redéfinition de « surface »
System.out.println (‘’ Le centre de l’objet = ( ‘’ public void affiche ()
+ x + ‘’ , ‘’ + y + ‘’ ) ‘’ ) ; } //redéfinition de la méthode « affiche »
public double surface ( ) { {super.affiche () ;
return (0) ; // appel de affiche de la super-classe
}} System.out.println (‘’ Le rayon = ‘’ +
//fin de la classe Forme rayon + ‘’La couleur = ‘’ + couleur ) ;}}

18/09/2023 POO 2eme SI 14

 Le mot clé final

Empêcher la redéfinition
• Une classe peut protéger une méthode afin d'éviter qu'elle ne soit
redéfinie dans ses sous-classes.
• En Java, on va simplement ajouter le modificateur final dans la
signature de la méthode.
public final void affiche()

Empêcher l’héritage
• Une classe déclarée final ne peut pas être dérivée
– Permet d’interdire tout héritage pour cette classe qui ne pourra pas
être une classe mère.
– Toutes les méthodes à l’intérieur de la classe final seront
implicitement finales.
final class Personne
18/09/2023 POO 2eme SI 15
 La classe Object

• les classes java héritent implicitement de la classe Object.

• La classe Object est l’ancêtre de toutes les classes
• Les méthodes de la classe Object:
– public String toString() { ... }
– public boolean equals(Object o) { ... }
– .....

18/09/2023 POO 2eme SI 16

 La méthode equals()

• La méthode equals détermine si deux objets sont égaux ou non

• Son implémentation dans la classe Object vérifie que les références
d’objets sont identiques.
• On aura souvent besoin de redéfinir la méthode equals : deux objets
seront égaux quand ils auront le même état.

public boolean equals(Object obj)

{
if(obj instanceof Point)
{
Point p = (Point) obj;
if((this.abs==p.abs) && (this.ord==p.ord) )
return true;
}}
return false; }

18/09/2023 POO 2eme SI 17

Le polymorphisme

• Poly = plusieurs, morphisme = forme

• Il s'agit d'invoquer (appeler) des méthodes sans connaître la nature de l'objet
correspondant
• Il explique comment une méthode peut se comporter différemment suivant
l’objet sur lequel elle s’applique
• Plus précisément, quand une même méthode est définie à la fois dans la
classe mère et dans la classe fille, son exécution est réalisée en fonction de
l’objet associé à l’appel et non plus suivant le nombre de paramètres, comme
c’est le cas lors de la surcharge de méthodes

18/09/2023 POO 2eme SI 18

Les méthode polymorphes

•Une méthode polymorphe doit :

 être déclarée dans la classe parent
 Redéfinit dans les classes enfants
public class Forme { public class Cercle extends Forme
protected int x, y, couleur ; {
public Forme(int nx, int ny) private int r ;
{ x = nx ; y = ny ; couleur = 0; } public Cercle(int xx, int yy , int ra){
public void afficher() { super(xx, yy);
System.out.println("Position en " + x + ", " + y); couleur = 10;
System.out.println("Couleur : " + couleur); } r = ra;}
public void echangerAvec(Forme autre) {
int tmp; public void afficher() {
tmp = x; x = autre.x; autre.x = tmp; super.afficher();
tmp = y; y = autre.y; autre.y = tmp; } System.out.println("Rayon : " + r); }
public void deplacer(int nx, int ny) { }
x = nx; y = ny; } } // Fin de la classe Forme // Fin de la classe Cercle

18/09/2023 POO 2eme SI 19

Les méthode polymorphes

• La méthode afficher() est décrite dans la classe Forme et dans la classe Cercle
• Cette double définition ne correspond pas à une véritable surcharge de fonction
• Les deux méthodes afficher() sont définies sans aucun paramètre
• Le choix de la méthode ne peut donc s’effectuer sur la différence de paramètres .
• Il est effectuée par rapport à l’objet sur lequel la méthode est appliquée

public class FormerDesCercles {

public static void main(String [] arg) {
Cercle A = new Cercle1(5, 5);
A.afficher(); // appliquée à A
Forme F = new Forme (10, 10);
F.afficher();
//appliquée à F } }

18/09/2023 POO 2eme SI 20

Les tableaux polymorphes

Exemple:

18/09/2023 POO 2eme SI 21

Les tableaux polymorphes

18/09/2023 POO 2eme SI 22

Les tableaux polymorphes

Exemple:
-Déclarer un tableau de type Animal.
-Le tableau contient des objets de type Animal

Animal [] animals =new Animal[3];

/*On peut mettre n’importe quelle

classe fille de la classe Animal() dans
le tableau*/

Animals[0]= new Dog();

Animals[1]= new Cat();
Animals[2]= new Wolf();

18/09/2023 POO 2eme SI 23

Les tableaux polymorphes

18/09/2023 POO 2eme SI 24

Un argument polymorphe

public class Test {

public class Veterinaire{ public static void main(String[] args) {
public void giveShot(Animal a) Veterinaire vet = new Veterinaire ();
{ a.makeNoise(); Dog dog= new Dog();
} Cat cat = new Cat();
} vet. giveShot(dog);
vet. giveShot(cat);
}}

-Le paramètre Animal a peut être n’importe quel animal

-N’importe quel animal dans le heap ayant la methode makeNoise(), Hab, Hab!!
fera son bruit Miaou, Miaou

La méthode giveShot() de la classe Veterinaire peut prendre n’importe quel Animal tant que
l’objet passé en paramètre est une classe fille de Animal.
(la méthode makeNoise() doit être implémentée dans les classes Cat et dog.

18/09/2023 POO 2eme SI 25

Mécanisme de la liaison dynamique

• Le polymorphisme est réalisable grâce à la Liaison Dynamique :

• La Liaison dynamique est un mécanisme permettant que la définition
d’une méthode soit décidée au moment de l’exécution de celle-ci (et non à
la compilation).
• La méthode qui sera exécutée est alors déterminée :
– Seulement à l’exécution, et pas dès la compilation
– Par le type réel de l’objet qui reçoit le message et pas par le type de la
référence qui le désigne (gestion d'un pointeur sur la description de la
classe de l'objet)

18/09/2023 POO 2eme SI 26

Mécanisme de la liaison dynamique

Exemple
• Soit C la classe réelle d'un objet o à qui on envoie un message "o.m()"

– Si le code de la classe C contient la définition (ou la redéfinition) d’une

méthode m(), c’est cette méthode qui sera exécutée.

– Sinon, la recherche de la méthode m() se poursuit dans la classe

mère de C, puis dans la classe mère de cette classe mère, et ainsi
de suite, jusqu’à trouver la définition d’une méthode m() qui est
alors exécutée.

18/09/2023 POO 2eme SI 27

Mécanisme de la liaison dynamique

• La machine virtuelle JVM commence tout d’abord à voir dans la classe

Wolf . Si elle ne trouve pas une correspondance de la version de la
méthode, elle commence à grimper l’hiérarchie de l’héritage jusqu’à
trouver la bonne méthode

18/09/2023 POO 2eme SI 28

Transtypage

• Le transtypage (ou cast) en java consiste à la conversion d’un type à un

autre (si c’est possible).
• Vers le haut (en anglais, upcast) = implicite .
– classe fille  classe mère
• Vers le bas (en anglais, downcast) = explicite et n'est pas toujours possible.
– classe mère classe fille

18/09/2023 POO 2eme SI 29

Transtypage

• Upcast : classe fille  classe mère

Rectangle
public class Test {
public static void main(String [] args){
Carre c = new Carre(5.0);
Rectangle r = new Rectangle(4.0,3.0);
Rectangle r2; Carre
r2 = c; //ok
Carre c2;
c2 = r; // erreur r2 est de type Rectangle mais a comme typage
}} dynamique Carre
• Carre hérite de Rectangle, alors un objet de type Carre peut être
considéré comme un Rectangle
• On peut également écrire : Rectangle r = new Carre() ;
• Le polymorphisme permet de considérer un objet d'une classe dérivée
comme un objet d'une classe base
18/09/2023 POO 2eme SI 30
Transtypage

• Exemple:

18/09/2023 POO 2eme SI 31

Transtypage

• Les fonctionnalités de Dog sont restreintes à celles de Animal. Le

chien ne pourra pas être un chien de garde (watch())
animal.eat() ok
animal.roam() ok
((Dog)animal).watch() ok

Il faut substituer animal par

((Dog)animal).watch()

18/09/2023 POO 2eme SI 32

Transtypage

• Downcast : classe mère  classe fille

Rectangle
Rectangle r = new Carre() ;
Carre c = (Carre) r ;

Carre
• On considère que r est en fait un objet Carre même s'il est dans une
variable de type Rectangle
• Il faut dans ce cas un transtypage explicite
• Il faut vérifier à l‘exécution que cette conversion est possible
• Cette conversion n'est jamais implicite (on ne transforme jamais un
Rectangle en Carre sans prendre des précautions

18/09/2023 POO 2eme SI 33

Transtypage

• Soient a et b deux objets, l’affectation a=b; est possible si :

– a et b sont de même type (appartiennent à la même classe)
ou
– La classe de b est dérive de la classe de a sinon il y a erreur de
compilation
• Soient a et b deux objets, pour que l’instruction : a=(<type>)b;
– Soit correcte à la compilation il faut que <type> soit le type de a (sa
classe) ou d’une classe dérivée de la classe de a
– Soit correcte à l’exécution il faut que b soit une instance de < type>
ou bien instance d’une classe dérivée de < type>.

18/09/2023 POO 2eme SI 34