1. Concepts OO Héritage
1

2. Plan
1. Héritage
2. Polymorphisme
3. Surcharge
4. this & super
5. Final
6. Variables & méthodes statiques
7. cast
2

3. 2.Héritage et polymorphisme
 L’héritage permet de créer des classes
par combinaison de classes déjà
existantes
3

4. 4

5. Héritage et polymorphisme
Définition de l’héritage
 Lorsqu’une classe hérite d’une autre classe,
elle bénéficie automatiquement de ses
définitions d’attributs et de méthodes.
 Elle peut y ajouter ses propres définitions, ce
qui permet facilement de constituer un
ensemble fonctionnellement plus riche.
 Les liens d’héritage spécifient une hiérarchie
de classe qui peut être constituée par une
démarche de spécialisation, ou au contraire
de généralisation.
5

6.  Il est courant en programmation de créer un modèle
de quelque chose, par exemple, un employé
(Employee), puis de s’apercevoir qu’on a besoin
d’un modèle de quelque chose qui est une version
spécialisée de ce modèle d’origine.
 Dans ce cas précis, nous pourrions vouloir un
modèle de manager (Manager). Il est clair qu’un
manager est un employé, mais un employé
présentant des caractéristiques supplémentaires.
Considérez les exemples de déclarations de classes
suivants :
6

7. public class Employee { public class Manager {
String name; String name;
Date hireDate; Date hireDate;
Date dateOfBirth; Date dateOfBirth;
String jobTitle; String jobTitle;
int grade; int grade;
} String department;
Employee [] subordinates;
}
7

8.  On s’aperçoit qu’il y a des partie
redondantes.
 En réalité, plusieurs champs sont applicables
à Employee et sont aussi requis par la classe
Manager .
8

9.  Note – L’utilisation du copier-coller dans un
éditeur ne résoud pas le problème car les
soucis de mise à jour subsistent.
 Si la classe Employee est modifiée, vous
devrez probablement aussi mettre à jour
Manager.
9

10.  Dans les langages orientés-objet, des
mécanismes spéciaux sont fournis pour
permettre au programmeur de définir une
classe en fonction d’une classe déjà définie :
c’est l’héritage.
 Dans Java, cette opération s’effectue à l’aide
du mot-clé extends de la façon suivante :
10

11. public class Manager
public class Employee extends Employee {
{ String department;
String name; Employee []
Date hireDate; subordinates;
Date dateOfBirth; }
String jobTitle;
int grade;
}
11

12. 12

13.  La classe Manager est définie maintenant
pour comporter toutes les variables et
méthodes qu’un employé possède.
 Toutes ces variables et méthodes sont
héritées de la définition de la classe parent.
 Le programmeur n’a plus qu’à définir des
fonctions supplémentaires, ou, comme nous
le verrons bientôt, indiquer les modifications
à appliquer.
13

14.  Note – Cette approche marque un grand
progrès en matière de mise à jour et donc de
fiabilité.
 Lors d’une correction dans la classe
Employee, la classe Manager est corrigée
sans intervention du programmeurt.
14

15.  Héritage simple
 Java permet à une classe de s’élargir
(extend) relativement à une seule autre
classe.
 Cette restriction est appelée héritage simple.
 Certains langages permettent de définir une
classe à partir de plusieurs autres, c’est
l’héritage multiple qui n’existe pas dans Java.
15

16.  La classe Object est la classe mère de toutes
les classes
 Par défaut
class Personne extends Object {
……
}
16

17. 17

18. Spécialisation des méthodes
 On considère deux classes liées par
l'héritage. Par exemple :
class Employee {
…
}
class Manager extends Employee {
…
}
18

19.  Souvent une méthode est définie dans la
classe de base, mais a besoin d'être "affinée"
dans la classe dérivée. On a par exemple :
class Employee {
void calculPrime() {
// une prime pour un employe
…
}
}
19

20.  Les deux méthodes de ces deux classes ont
même signature.
 On dit que la méthode calculPrime() de la
classe Manager spécialise la méthode
calculPrime() de la classe Employee.
20

21. Polymorphisme
 Le nom de la méthode calculPrime()
dénote alors 2 codes distincts.
 Autrement dit l'identificateur calculPrime
représente "plusieurs formes" de code
distinct.
 On parle de polymorphisme.
21

22.  On utilise le polymorphisme à l'aide d'une
référence d'objet de classe de base. Par
exemple on écrit en Java :
Employee e = new Employee();
e.calculPrime(); // lance la methode
calculPrime() de la classe Employee
22

23.  mais aussi
Employee e = new Manager();
e.calculPrime(); // lance la methode
calculPrime() de la classe Manager
23

24.  Un des avantages de ceci est de pouvoir
utiliser une seule référence e de la classe
Employee pour référencer un Employee ou
un Manager.
 C'est possible car un Manager (classe
dérivée de la classe Employee) est un
Employee : sémantique de l'héritage. Mais …
24

25.  … le gros avantage du polymorphisme est de
pouvoir référencer des objets sans connaître
à la compilation véritablement leur classe, et
de pouvoir par la suite, à l’exécution lancer le
code approprié à cet objet.
 Tout ceci au moment de l'exécution du
programme (et non pas à la compilation).
25

26.  Polymorphisme = liaison dynamique
 Au moment de la compilation, le compilateur ne sait
pas si c'est la méthode calculPrime() de la classe
Employee ou celui de la classe Manager qui sera
lancé.
 Autrement dit, la liaison entre l'identificateur
calculPrime() et le code à lancer est déterminé à
l'exécution du programme (suivant le choix de
l'utilisateur du programme).
 On dit alors que la liaison est dynamique.
26

27.  Remarquer que si e réfère un Manager,
l'appel de la méthode calculPrime() de la
classe Employee n'est pas fait (sauf si
mentionner explicitement par le programmeur
dans le code de la méthode calculPrime() de
la classe Manager).
 Le code à lancer est déterminé suivant la
classe de l'objet et non pas la classe de la
référence à cet objet.
27

28.  Comment cela fonctionne ?
 Java est dit un langage objet pur (comme Smalltalk et
contrairement à C++) car le mécanisme de recherche de la
méthode à lancer est automatique et systématique sans que le
programmeur ait à le préciser.
 En Java un appel comme :
e.calculPrime();
 recherche, au moment de l'exécution l'objet référencé par e.
 Connaissant alors l'objet, l'interpréteur cherche, si dans la classe
de cet objet, cette méthode existe. Si c'est le cas, cette méthode
est lancée et le processus est terminé. Si ce n'est pas le cas,
l'interpréteur refait cette recherche dans la classe de base et le
processus est relancé sur cette classe de base, jusqu'à trouver
une telle méthode.
 Si une telle méthode n'est pas trouvée, une exception est levée.
28

29.  Ce mécanisme qui a le mérite d'être simple
pour le programmeur, a l'inconvénient d'être
indéterministe en temps de recherche et de
pouvoir être lent à l'exécution (d'où un autre
mécanisme déterministe proposé dans des
langages comme C++).
29

30.  En conclusion
 Il est fondamental de voir que pour utiliser le
polymorphisme, il faut :
 exploiter le mécanisme d'héritage sur les classes
ou utiliser des interfaces.
 référencer les objets par la classe de base ou par
l’interface.
30

31. public class Manager
public class Employee extends Employee {
{ String department;
String name; Employee []
Date hireDate; subordinates;
Date dateOfBirth; }
String jobTitle;
int grade;
}
31

32. class Societe public void affichePrime(){
{ for (int i=0;i<compteur;i++){
Employe [] tabEmpl; System.out.println
int compteur=0; (tabEmpl[i].calculPrime());
Societe(int taille)
}
{
tabEmpl = new Employe[taille]; }
} public static void main(String []
public void recuter(Employe e){ args){
tabEmpl[compteur]=e; Societe s = new Societe();
compteur++; s.recruter(new Employe());
} s.recruter(new Manager());
s.affichePrime();
}
}
32

33. • Définition du polymorphisme
 Lorsqu’un objet est instancié d’une classe, il peut
être vu comme instance de n’importe laquelle des
classes héritées par la classe dont il est instancié.
 En fait l’instance d’un tel objet est toutes les
classes à la fois.
 Le rectangle r1 est à la fois un objet de la classe
Rect et un objet de la classe ObjetGraphique.
 Le polymorphisme permet donc d’écrire :
ObjectGraphique r = new Rect();
33

34. Définition de la redéfinition
(redéfinir une méthode héritée)
 Lorsqu’un attribut ou une méthode ont été définis dans une
classe et sont redéfinis dans une classe dérivée (qui en
hérite), les éléments visibles sont ceux redéfinis dans la
classe dérivée. Les éléments de la classe de base (héritée)
sont alors masqués.
Class Rect extends ObjetGraphique {
void move(int dx, int dy);
...
}
Class Cercle extends ObjetGraphique{
void move(int dx, int dy);
...
}
34

35. Méthode toString
35

36.  Returns a string representation of the object. In general,
the toString method returns a string that "textually
represents" this object. The result should be a concise but
informative representation that is easy for a person to read.
It is recommended that all subclasses override this method.
The toString method for class Object returns a string
consisting of the name of the class of which the object is an
instance, the at-sign character `@', and the unsigned
hexadecimal representation of the hash code of the object.
In other words, this method returns a string equal to the
value of:
 getClass().getName() + '@' +
Integer.toHexString(hashCode())
 Returns:
 a string representation of the object.
36

37. public class Personne {
String nom,prenom;
public static void main(String
args[]){
Personne p = new Personne();
System.out.println(p);
}
}
37

38. Personne@de6ced
38

39. public class Personne {
String nom,prenom;
public static void main(String
args[]){
Personne p = new Personne();
//System.out.println(p);
System.out.println(p.toString());
}
}
39

40.  Afficher une référence c’est faire appel à la
méthode toString()
40

41. public class Personne extends Object{
String nom,prenom;
public String toString(){return « nom=«
+nom+ « prenom=»+prenom;}
public static void main(String args[]){
Personne p = new Personne();
p.nom=«a »,p.prenom=« b »;
System.out.println(p);
//System.out.println(p.toString());
}
}
41

42. nom=jo prenom=ji
42

43. Surcharge de méthodes
 Une classe peut contenir plusieurs méthodes de même
fonctionalité mais d’arguments différents.
 Par exemple une méthode conçue pour sortir une représentation
textuelle de son argument.
 Cette méthode sera nommée print().
 La méthode d’impression pour imprimer différents types de
données tels que int, float et String nécessitent une mise en
forme différente et probablement un traitement différent.
 Vous pourriez créer ces méthodes baptisées respectivement
printint(int arg),
printfloat(float arg) et printString(String arg). Cette
solution est néanmoins fastidieuse.
43

44.  Java permet de réutiliser un même nom de méthode pour
plusieurs fonctionalités.
 Cette solution ne fonctionne que si le compilateur peut distinguer
quelle méthode est effectivement requise.
 Dans le cas des trois méthodes d’impression, il est possible de
faire cette distinction sur la base des types des arguments.
 En réutilisant le nom de la méthode, nous obtenons les trois
méthodes ci-après :
public void print(int i)
public void print(float f)
public void print(String s)
 Lorsque vous écrivez du code pour appeler l’une de ces
méthodes, la méthode appropriée est choisie en fonction du type
des arguments que vous fournissez.
44

45.  Les méthodes surchargées sont soumises à
certaines règles :
 La liste d’arguments de l’instruction appelante doit être
suffisamment différente pour que la méthode à appeler
puisse être déterminée sans ambiguïté. Des promotions
d’élargissement normales (par exemple, float -> double)
pourraient être appliquées, qui risqueraient de créer la
confusion dans certains cas.
 Le type de retour des méthodes peut être différent, mais
cette différence seule ne suffit pas. Les types de la liste
d’argument des différentes méthodes surchargées doivent
impérativement différer.
 La surcharge est aussi appelé parfois la
surdéfinition.
45

46.  Il ne faut pas confondre les notions de
surcharge (ou surdéfinition) et
polymorphisme (ou liaison dynamique) qui
ont finalement peu de point commun.
 Voici un tableau qui résume les différences :
46

47. 47

48. Référence this
 En Java, lors de l’écriture d’une méthode
vous pouvez faire référence à l’objet courant
(qui a lancé cette méthode) à l’aide de
l´identificateur this. On utilise cette référence
dans les cas:
48

49. Premier cas
 Passage de la référence de l´objet courant à la
méthode :
 // les méthodes drawImage() de la classe Graphics
 drawImage( . . . , this);
 ....
 // doivent informer régulièrement l’objet courant
 // de l’état d’avancement du chargement de l’image.
49

50.  Supposons qu’un Cercle possède une
référence sur la Fenêtre graphique à laquelle
il est attaché
50

51. 51

52.  Association et usage de this
 - Le this permet à un objet d’obtenir une référence sur lui-même. Ceci est
très utile lorsqu’un objet a besoin de laisser “une carte de visite” à un autre
objet pour lui dire “c’est moi qui t’ai contacté, voici par quelle référence tu
peux m’utiliser”.
 Avec l’exemple, voici ce qui se produit :
 1. Cercle définit un attribut fenetre qui va permettre à chaque instance de
référencer sa fenêtre (celle où il est affiché).
 2. Dans ce cas, un Cercle n’est pas propriétaire de la fenêtre dans laquelle il se
trouve. Le constructeur de Cercle n’est pas responsable de la création de la
fenêtre. Celle-ci est créée indépendamment en dehors de la classe Cercle.
 3. L’attribut fenetre de Cercle est mis à jour par la méthode placer()
 4. Fenetre possède une liste de Cercles. La méthode placer() gère la
suppression du cercle dans l’ancienne fenêtre et l’ajout dans la nouvelle, en
invoquant ajouter() et enlever() de la classe Fenetre. Ces méthodes prennent en
paramètre un Cercle. Celui-ci n’est autre que le receveur de la méthode placer(),
référenc par this.
52

53. Levée d’une ambiguité :
class Client {
String nom ;
String clientID ;
....
Client(String nom, String ID) {
this.nom = nom ;
clientID = ID ; // this implicite
}
....
}
53

54.  Exemple de this explicite
54

55.  Appel d'un constructeur de la même classe :
public MaClasse(int a, int b) {
...
}
public MaClasse(int c) {
this(c, 0);
}
public MaClasse() {
this(10);
}
55

56. public class Personne {
String nom,prenom;
Public void affiche(){
System.out.println(this);
//System.out.println(this.toString());
//System.out.println(toString());
}
public String toString(){return « nom=« +nom+ «
prenom=»+prenom;}
public static void main(String args[]){
Personne p = new Personne();
//System.out.println(p);
System.out.println(p.toString());
}
}
56

57. Référence super
 En Java, lors d’un héritage vous pouvez dans
une méthode de la classe dérivée référencer
la partie provenant de la classe de base à
l’aide de l´identificateur super.
57

58. Premier cas :
class ClientRegulier extends Client {
double ristourne;
public String toString() {
return super.toString() + "ristourne=" +
ristourne;
. . .
}
}
class Client {
String nom ;
String clientID ;
public String toString() {
return "nom=" + nom + " id=" + clientID;
}
}
58

59.  Deuxième cas :
 Appel d'un constructeur de classe de base :
class ClientRegulier extends Client {
ClientRegulier( String leNom, String id,double ris) {
super ( leNom, id);
...
}
}
59

60.  L’instruction super( . . . ) est un appel au
constructeur approprié de la classe de base.
 Une telle instruction ne peut se trouver que
comme première instruction d’un
constructeur.
 Si un constructeur ne possède pas un tel
appel, le compilateur Java en créé
automatiquement un qui est super().
 La classe de base doit alors posséder un
constructeur sans argument.
60

61. Classes finales
 Java permet d’appliquer le mot-clé final aux classes et, si tel est
le cas, la classe ne peut pas être sous-classée.
 La classe java.lang.String, par exemple, est une classe finale.
 Cette opération peut être effectuée pour des raisons de sécurité
car elle garantit que si une méthode comporte une référence à
une chaîne (String), il s’agit effectivement d’une vraie chaîne
(String) et non pas d’une sous-classe quelconque qui aurait pu
être ajoutée de façon pernicieuse avec un comportement
modifié.
 Exemple :
public final class Integer extends Number {
. . .
}
61

62. public class personne{ // accesseurs
private String prenom; public String getPrenom(){
private String nom; return prenom;
private int age; }
public personne(String P, String public String getNom(){
N, int age){
return nom;
this.prenom=P;
}
this.nom=N;
public int getAge(){
this.age=age;
return age;
}
}
public personne(personne P){
//modifieurs
this.prenom=P.prenom;
public void setPrenom(String P){
this.nom=P.nom;
this.prenom=P;
this.age=P.age;
}
}
public void setNom(String N){
public String identite(){
this.nom=N;
return
"personne("+prenom+","+nom+", }
"+age+")"; public void setAge(int age){
} this.age=age;
}
}
62

63. class enseignant extends personne{
// attributs
private int section;
// constructeur
public enseignant(String P, String N, int
age,int section){
super(P,N,age);
this.section=section;
}
}
63

64. Méthodes final
 Des méthodes individuelles peuvent aussi être
marquées avec le motclé final. Si tel est le cas, la
méthode ne peut pas être redéfinie dans
 une classe dérivée. Il s’agit là-encore de raisons de
sécurité de façon à
 ce que celui qui appelle une méthode puisse savoir
que le
 comportement qui en résulte est le comportement
d’origine, et non
 pas un comportement subversif de remplacement.
64

65.  Les méthodes finales sont parfois utilisées aux fins
d’optimisation d’accès lors de l’exécution puisque le
compilateur peut générer du code provoquant un
appel direct de la méthode plutôt que de devoir
utiliser l’appel traditionnel de la méthode qui
implique une recherche à l’exécution pour décider
de la méthode à appeler (polymorphisme).
 Les méthodes marquées comme privées sont
automatiquement finales.
 La liaison dynamique n’est appliquée (optimisation)
ni aux méthodes finales, ni aux méthodes
statiques.*
65

66. Exemple :
public final String getWarningString()
{
....
}
66

67. Champ de données final
 Une variable préfixé par le modificateur final est une
constante.
 Toute tentative pour modifier la valeur d’un champs
de donnée final génère une erreur de compilation.
 Note – Si vous marquez une variable de type de
référence, c’est-à-dire tout type de classe, avec le
mot-clé final, vous rendez impossible toute
référence de la variable à un autre objet, mais la
modification du contenu de l’objet reste possible.
 Souvent associé à static ce qui en fait un champ
d’une classe ( et non d’un objet).
67

68. Exemple :
// dans java.lang.Math
public static final double PI =
3.14159265358979323846;
// dans java.awt.Color
public static final Color white
= new Color(255, 255, 255);
// dans un champ d'instance
private final Date
dateCreationInstance = new Date();
68

69.  // java 1.1 "final" comme contrôle d'initialisation
unique
public class Client {
public final String clientID;
...
public Client( String nom, String ID) {
clientID = ID ;
....
}
}
69

70. Contrôle d’accès évolué
 Outre private et public, deux niveaux de contrôle d’accès
supplémentaires sont définis dans Java pour être utilisés sur des
variables et des méthodes membres.
 Il s’agit des niveaux de contrôle protected et du niveau "par
défaut" (noté sans modificateur).
 Une variable ou méthode possède un niveau d’accès "par
défaut" si elle ne comporte pas de modificateur explicite dans sa
déclaration.
 Ce niveau implique que l’accès soit autorisé depuis toute
méthode d’une classe quelconque membre du même package
que la cible.
 On le nomme aussi accès friendly.
70

71.  Une méthode ou une variable protégée
(protected) est accessible depuis toute
méthode d’une classe quelconque membre
du même package.
 Elle est également accessible dans d’autres
packages dans toute méthode d’une sous-
classe qu’en cas de manipulation d’un
membre de l’instance courante.
71

72. class A{ //extends java.lang.Object
void method( A autreinstance ) {
A autre = autreinstance.clone();
// refusé par le compilateur . . .
// methode clone protected.
class B{ //extends java.lang.Object
protected Object clone() ...{
return super.clone();
// accepté par le compilateur.
. . .
}
72

73. 73

74. 74

75. 75

76.  Contrôle d’accès : conclusion
 Une interface peut être : public, "pas de
modificateur", abstract.
 Une classe peut être : public, "pas de modificateur",
abstract, final, static (en Java1.1).
 Une méthode peut être : public, protected, "pas de
modificateur", private, abstract, final, native,
static,synchronized.
 Une donnée membre peut être : public, protected,
"pas de modificateur", private, final, static,transient,
volatile.
76

77. Passage par valeur
 Java ne transmet les arguments que par
valeur, ce qui signifie que l’argument ne peut
pas être modifié par la méthode appelée.
Lorsqu’une instance d’objet est transmise
comme argument à une méthode, la valeur
de l’argument est une référence à l’objet. Le
contenu de l’objet peut être modifié dans la
méthode appelée, mais la référence de l’objet
n’est jamais changée.
77

78. public class PassTest {
float Value;
public static void main (String args[]) {
String str;
int val;
// Créer une instance de la classe
PassTest pt = new PassTest ();
// Affecter l’entier
val = 11;
// Tenter de le modifier
pt.changedInt ( val );
// Quelle est la valeur actuelle ?
System.out.println ("Int value is:"+val);
// Affecter la chaîne
str = new String ("hello");
// Tenter de la modifier
pt.changeStr (str);
// Quelle est la valeur actuelle ?
System.out.println ("Str value is:"+str);
78

79. // Maintenant définir value
pt.value = 101f;
// Changer la valeur du flottant
// via la référence à l’objet
pt.changeObjValue (pt);
// Quelle est la valeur actuelle ?
System.out.println ( "Valeur actuelle :
" + pt.value);
}
// Méthode pour changer les valeurs actuelles
public void changeInt (int value) {
value = 55;
}
public void changeStr (String value) {
value = new String ("differente");
}
public void changeObjValue (PassTest ref) {
ref.value = 99f;
}
}
79

80. Le résultat est :
% java PassTest
Int value is: 11
Str value is: hello
Current value is: 99.0
80

81. Variable de classe
 Il est parfois souhaitable d’avoir une variable
partagée par toutes les instances d’une classe.
 Cette dernière peut par exemple servir de base pour
la communication entre les instances ou pour
conserver une trace du nombre d’instances qui ont
été créées.
 Vous pouvez obtenir cet effet en marquant la
variable avec le mot-clé static.
 Une telle variable est parfois appelée variable de
classe pour la distinguer d’une variable de membre
ou d’une variable d’instance.
81

82. public class Count {
private int serialNumber;
private static int counter = 0;
public Count () {
counter++;
serialNumber = counter;
}
}
 Dans cet exemple, chaque objet créé reçoit un numéro de série
unique commençant à un, puis incrémenté.
 Le compteur de variables est partagé par toutes les instances.
82

83.  Une variable statique est une variable unique
accessible via une instance quelconque de la
classe.
 Le plus souvent on y accède à l’aide du nom
de la classe
83

84. public class StaticVar {
public static int number;
}
public class OtherClass {
public void method() {
int x = StaticVar.number;
}
}
84

85. Méthode de classe
 On a parfois besoin d’une fonctionnalité sans
pour cela devoir utiliser un objet.
 Une méthode marquée avec le mot-clé static
peut être utilisée de cette façon et est parfois
appelée méthode de classe.
85

86. public class GeneralFunction {
public static int addUp( int x, int y) {
return x + y;
}
}
public class UseGeneral {
public void method() {
int a = 9;
int b = 10;
int c = GeneralFunction.addUp(a , b);
System.out.println("addUp() gives" + c);
}
}
86

87.  Une méthode statique pouvant être appelée
sans instance de la classe à laquelle elle
appartient, n’ a pas de valeur référence this.
 Par conséquent, une méthode statique ne
peut accéder à aucune variable hormis ses
propres arguments et variables statiques.
 Toute tentative d’accès à des variables non
statiques génère une erreur de compilation.
87

88. public class Wrong {
int x;
public static void main(String args[]) {
x = 9; // ERREUR DE COMPILATION !
}
}
 Il existe en Java beaucoup de telles méthodes par
exemple:
int Integer.parseInt( String );
String String.valueOf( int );
88

89. Opérateurinstanceof
 Etant donné que vous pouvez accéder aux objets
en utilisant les références de leurs classes parents,
vous souhaiterez parfois savoir ce que vous avez
réellement.
 C’est le rôle de cet opérateur instanceof. Supposons
que notre hiérarchie de classes soit étendue de
façon à ce que nous ayons :
public class Employee extends Object
public class Manager extends Employee
public class Contractor extends Employee
89

90.  Maintenant, si vous recevez un objet par
l’intermédiaire d’une référence de type
Employee, il peut être en réalité un Manager
ou un (’Contractor’).
 Si vous le souhaitez, vous pouvez tester
l’utilisation de sa classe à l’aide d’instanceof
de la façon suivante :
90

91. public void method(Employee e) {
if (e instanceof Manager) {
// l’appeler ‘Monsieur’
}
else if (e instanceof Contractor) {
// garder les secrets de la société
}
else {
// employé de plein droit, parler librement
}
}
91

92. Contrainte temporaire de type : Cast
 Dans les situations où vous avez reçu une
référence à une classe parent et où vous
avez déterminé que l’objet est en fait une
sous-classe particulière en utilisant
instanceof, vous pouvez restaurer la
fonctionnalité complète de l’objet en forçant
la référence.
92

93. public class Employee {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
}
public class Manager extends Employee {
String department;
Employee [] subordinates;
}
93

94. public void method(Employee e) {
if (e instanceof Manager) {
Manager m = (Manager)e;
System.out.println(“C’est le manager
de ” +
m.department);
}
// reste de l’opération
}
94

95.  Si vous omettez de faire le cast, toute
tentative pour référencer e.department
échoue, car le compilateur ne connaît aucun
membre appelé department dans la classe
Employee.
 Si vous n’effectuez pas le test avec
instanceof, vous courrez le risque que le cast
échoue.
95

96.  En général, toute tentative de forçage d’une
référence d’objet est soumise à plusieurs contrôles :
 Les élévations de types de données dans la hiérarchie de
classes sont toujours autorisées et, en fait, ne nécessitent
pas l’opérateur de cast, mais peuvent être effectuées par
simple affectation.
 Pour les dégradations de types de données, le compilateur
doit vérifier que le cast est possible. A titre d’exemple, toute
tentative de cast d’une référence Manager vers une
référence Contractor est strictement interdite puisque un
Contractor n’est pas un Manager. L’objet sur lequel le cast
a lieu doit être un objet d’une sous-classe du type de
référence en cours.
96

97. 97