Upload
amel-morchdi
View
610
Download
2
Embed Size (px)
Citation preview
1
Concepts OO Héritage
2
Plan
1. Héritage
2. Polymorphisme
3. Surcharge
4. this & super
5. Final
6. Variables & méthodes statiques
7. cast
3
2.Héritage et polymorphisme
L’héritage permet de créer des classes
par combinaison de classes déjà
existantes
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.
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 :
7
public class Employee {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
}
public class Manager {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
String department;
Employee [] subordinates;
}
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 .
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.
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 :
11
public class Employee {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
}
public class Manager extends Employee {
String department;
Employee [] subordinates;
}
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.
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.
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.
16
La classe Object est la classe mère de toutes
les classes
Par défaut
class Personne extends Object {
……
}
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 {
…
}
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
…
}
}
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.
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.
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
23
mais aussi
Employee e = new Manager();
e.calculPrime(); // lance la methode calculPrime() de la classe Manager
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 …
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).
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.
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.
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.
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++).
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.
31
public class Employee {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
}
public class Manager extends Employee {
String department;
Employee [] subordinates;
}
32
class Societe
{
Employe [] tabEmpl;
int compteur=0;
Societe(int taille)
{
tabEmpl = new Employe[taille];
}
public void recuter(Employe e){
tabEmpl[compteur]=e;
compteur++;
}
public void affichePrime(){
for (int i=0;i<compteur;i++){
System.out.println
(tabEmpl[i].calculPrime());
}
}
public static void main(String [] args){
Societe s = new Societe();
s.recruter(new Employe());
s.recruter(new Manager());
s.affichePrime();
}
}
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();
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); ... }
35
Méthode toString
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.
37
public class Personne {
String nom,prenom;
public static void main(String args[]){
Personne p = new Personne();
System.out.println(p);
}
}
38
Personne@de6ced
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());
}
}
40
Afficher une référence c’est faire appel à la
méthode toString()
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()); } }
42
nom=jo prenom=ji
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.
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.
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.
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 :
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:
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.
50
Supposons qu’un Cercle possède une
référence sur la Fenêtre graphique à laquelle
il est attaché
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.
53
Levée d’une ambiguité :
class Client {
String nom ;
String clientID ;
....
Client(String nom, String ID) {
this.nom = nom ;
clientID = ID ; // this implicite
}
....
}
54
Exemple de this explicite
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);
}
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()); } }
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.
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; } }
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);
. . .
}
}
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.
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 {
. . .
}
62
public class personne{ private String prenom; private String nom; private int age; public personne(String P, String
N, int age){ this.prenom=P; this.nom=N; this.age=age; } public personne(personne P){ this.prenom=P.prenom; this.nom=P.nom; this.age=P.age; } public String identite(){ return
"personne("+prenom+","+nom+","+age+")";
}
// accesseurs public String getPrenom(){ return prenom; } public String getNom(){ return nom; } public int getAge(){ return age; } //modifieurs public void setPrenom(String P){ this.prenom=P; } public void setNom(String N){ this.nom=N; } public void setAge(int age){ this.age=age; } }
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;
}
}
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.
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.*
66
Exemple :
public final String getWarningString() {
....
}
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).
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();
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 ;
....
}
}
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.
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.
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.
. . .
}
73
74
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.
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.
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);
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; } }
80
Le résultat est :
% java PassTest
Int value is: 11
Str value is: hello
Current value is: 99.0
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.
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.
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
84
public class StaticVar {
public static int number;
}
public class OtherClass {
public void method() {
int x = StaticVar.number;
}
}
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.
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);
}
}
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.
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 );
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
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 :
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 } }
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.
93
public class Employee { String name; Date hireDate; Date dateOfBirth; String jobTitle; int grade; } public class Manager extends Employee { String department; Employee [] subordinates; }
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
}
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.
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.
97