COURS 5

L. KADDOURI
NIT
2024
 Langage JAVA

- l’operateur « instanceof »
- Polymorphisme

L. KADDOURI
NIT
2024
Rappel sur l’héritage et la
redéfinition
 Héritage et Redéfinition classe :
public class Personne { Personne
String nom, prenom;
int age;
public Personne (String nom, String prenom, int age) {
[Link]=nom; Hérite de Hérite de
[Link]=prenom;
[Link]=age; classe : classe :
} Etudiant Employe
public sePresenter() {
[Link]("Je suis " + [Link] + " " + [Link]);
[Link](" J’ai " + [Link] + " ans"); }
}
 Héritage et Redéfinition classe :
public class Etudiant extends Personne { Personne
int matricule;
String specialite;
public Etudiant (String nom, String prenom, int age,
int matricule, String specialite) { Hérite de Hérite de
[Link]=nom;
[Link]=prenom;
classe : classe :
[Link]=age; Etudiant Employe
[Link]=matricule;
[Link]=specialite; }

}
 Héritage et Redéfinition classe :
public class Etudiant extends Personne { Personne
int matricule;
String specialite;
public Etudiant (String nom, String prenom, int age,
int matricule, String specialite) { Hérite de Hérite de
super(nom, prenom, age);
classe : classe :
[Link]=matricule;
[Link]=specialite; } Etudiant Employe

}
 Héritage et Redéfinition classe :
public class Etudiant extends Personne {
int matricule; Personne
String specialite;
public Etudiant (String nom, String prenom, int age,
int matricule, String specialite) {
super(nom, prenom, age); Hérite de Hérite de
[Link]=matricule;
classe : classe :
[Link]=specialite; }
Etudiant
public sePresenter() { //Redefinition (Overriding) Employe
[Link]("Je suis " + [Link] + " " + [Link]);
[Link](" J’ai " + [Link] + " ans");
[Link]("Je suis Etudiant en " + [Link]);
[Link](" Mon Matricule est " + [Link]); } }
 Héritage et Redéfinition classe :
public class Etudiant extends Personne {
int matricule; Personne
String specialite;
public Etudiant (String nom, String prenom, int age,
int matricule, String specialite) {
super(nom, prenom, age); Hérite de Hérite de
[Link]=matricule;
classe : classe :
[Link]=specialite; }
Etudiant Employe
public sePresenter() {
[Link]();
[Link]("Je suis Etudiant en " + [Link]);
[Link](" Mon Matricule est " + [Link]); } }
 Héritage et Redéfinition classe :
public class Employe extends Personne {
String poste; Personne
double salaire;
public Employe (String nom, String prenom, int age,
String poste, double salaire) {
super(nom, prenom, age); Hérite de Hérite de
[Link]=poste;
classe : classe :
[Link]=salaire; }
Etudiant Employe
public sePresenter() {
[Link]();
[Link]("J’ai le poste de " + [Link] );
[Link](" Mon Salaire est de " + [Link] + " DA" ); } }
 Héritage et Redéfinition
public class Test {
public static void main (String [ ] args) {
Personne personne = new Personne ("MOHAMED", "Ali", 55);
Etudiant etudiant = new Etudiant ("AKLI", "Kadi", 19, 12345, "Informatique");
Employe employe= new Employe ("BENALI", "Brahim", 48, “Prof”, 100000);
[Link]();
[Link]();
[Link]();
} Je suis MOHAMED ALI J’ai 55 ans
} Je suis AKLI Kadi J’ai 19 ans
Je suis Etudiant en Informatique Mon Matricule est 12345
Je suis BENALI Brahim J’ai 48 ans
J’ai le poste de Prof Mon Salaire est de 100000 DA
L’operateur « instanceof »
 L’operateur « instanceof »
L’operateur « instanceof » vérifie si un objet est une instance d'une
classe particulière : objet instanceof Classe
class Animal { ‘b1' aura la valeur : « VRAIE »
…
}
class TestAnimal {
public static void main(String [] args) {
…
Animal animal = new Animal ( );
boolean b1 = animal instanceof Animal ;
}
 L’operateur « instanceof »
Cet opérateur tient également compte de l'héritage : classe :
class Animal { Animal
…
Hérite de
}
class Tigre extends Animal { classe :
… Tigre
}
class Chat extends Tigre { Hérite de
…
} classe :
Chat
 L’operateur « instanceof »
class TestAnimal {
public static void main(String [] args) {
… ‘b2' aura la valeur : « VRAIE »
Tigre tigre = new Tigre ( ); classe :
Animal
boolean b2 = tigre instanceof Tigre ;
Hérite de
boolean b3 = tigre instanceof Animal ;
classe :
‘b3' aura la valeur : « VRAIE » Tigre

boolean b4 = tigre instanceof Chat ; Hérite de

‘b4' aura la valeur : « FAUSSE » classe :

} Chat
Polymorphisme
 Références aux objets
Tigre tigre = new Tigre ( );
L’objet créé en mémoire
Variable «tigre» : Référence a l’objet
de la classe Tigre en mémoire. tigre =@
Le type de la variable est : Tigre
C’est une adresse mémoire
tg1

tg tg2
2 variables de référence distinctes
peuvent référencer un même objet
Une variable de référence ne peut pas en mémoire
référencer 2 objets distincts en mémoire
 Références aux objets
Comment 2 variables de référence (ou plus) peuvent référencer un même objet en
mémoire ?

Tigre tg1 = new Tigre ( ); Tigre tg1 = new Tigre ( );

Tigre tg2 = new Tigre ( ); Tigre tg2 = tg1; //même @

tg1 tg1

tg2 tg2
 Polymorphisme (1)
Tigre tigre = new Tigre ( ); classe :
Animal
La variable de référence «tigre» est a la
fois une instance de «Tigre» et une Hérite de
instance de «Animal» (Relation : is-a)
Is-a classe :
Classe = Type tigre
Tigre
On dit aussi que la variable de référence « tigre » a :
- Le type “Tigre” Hérite de
- Le type “Animal”
classe :
La variable « tigre » est Polymorphe Chat
 Polymorphisme (1)
classe :
Animal x = new Tigre ( );
Animal
Hérite de

classe :
Tigre y = new Tigre ( ); new Tigre ( )
Tigre
Hérite de

classe :
Chat z = new Tigre ( );
Chat
 Polymorphisme (2)
Animal animal = new Animal();
Dans quel tableau on peut mettre
Tigre tigre = new Tigre();
ensemble les variables de référence
Chat chat = new Chat(); de ces 3 objets ?

Tableau de type Tableau de type Tableau de type

« Animal » « Tigre » « Chat »
 Polymorphisme (2)

animal animal animal

tigre tigre tigre

chat chat chat

Tableau de type Tableau de type Tableau de type

« Animal » « Tigre » « Chat »

Les 03 objets sont L’objet «animal» Les objets «tigre»

des Animaux n’est pas un Tigre et «animal» ne
sont pas des Chats
Le Tableau de type « Animal » est Polymorphe
 Polymorphisme (3) classe :
public class Animal {
Animal
public void marcher() {
[Link]("Cet Animal marche"); }
}
Hérite de Hérite de
public class Chat extends Animal {
classe : classe :
}
Chien Chat
public class Chien extends Animal {
}
 Polymorphisme (3) classe :
Les deux classes «Chien» et «Chat» sont une
spécialisation de la classe «Animal». Donc, elles Animal
peuvent redéfinir (override) la méthode «marcher».
public class Chat extends Animal {
public void marcher() { Hérite de Hérite de

[Link]("Ce Chat marche"); } } classe : classe :

Chien Chat
public class Chien extends Animal {
public void marcher() {
[Link]("Ce Chien marche"); }
}
 Polymorphisme (3)
public static void main (String [ ] args) {
Animal animal = new Animal();
[Link](); // affiche : Cet Animal marche

Chat chat = new Chat();

[Link](); // affiche : Ce Chat marche

Chien chien = new Chien();

[Link](); // affiche : Ce Chien marche
}
import [Link]; Importation de la classe du package
public class Test {
public static void main (String [ ] args) {
Animal animal = new Animal(); Création d’une instance par classe
Chat chat = new Chat(); Création d’un tableau dynamique
Chien chien = new Chien(); «listeAnimaux» de type «Animal»
ArrayList <Animal> listeAnimaux = new ArrayList <> ();
[Link](animal); Initialisation des éléments du
[Link](chat); tableau par les 3 instances créées
[Link](chien); avec la méthode « add »
for (Animal an : listeAnimaux) { [Link]() }
}}
 animal [Link](animal);
chat [Link](chat);
chien [Link](chien);
listeAnimaux
Tableau
dynamique de
type « Animal »

Cet Animal marche

Ce Chat marche
Ce Chien marche