Java uik-chap6-poo heritage v2 java

  • 687 views
Uploaded on

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
687
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
26
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Concepts OO Héritage
  • 2. Plan
    • Héritage
    • Polymorphisme
    • Surcharge
    • this & super
    • Final
    • Variables & méthodes statiques
    • 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 &quot;textually represents&quot; 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.
    • [email_address]
  • 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() + &quot;ristourne=&quot; +
    • ristourne;
    • . . .
    • }
    • }
    • class Client {
    • String nom ;
    • String clientID ;
    • public String toString() {
    • return &quot;nom=&quot; + nom + &quot; id=&quot; + clientID;
    • }
    • }
  • 59.
    • Deuxième cas :
    • A ppel 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 &quot;personne(&quot;+prenom+&quot;,&quot;+nom+&quot;,&quot;+age+&quot;)&quot;;
    • }
    • // 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 &quot;final&quot; 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 &quot;par défaut&quot; (noté sans modificateur).
    • Une variable ou méthode possède un niveau d’accès &quot;par défaut&quot; 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, &quot;pas de modificateur&quot;, abstract.
    • Une classe peut être : public, &quot;pas de modificateur&quot;, abstract, final, static (en Java1.1).
    • Une méthode peut être : public, protected, &quot;pas de modificateur&quot;, private, abstract, final, native, static,synchronized.
    • Une donnée membre peut être : public, protected, &quot;pas de modificateur&quot;, private, final, static,transient, volatile.
  • 77. Passage par valeur
    • Java ne transmet les arguments que par valeur, ce qui signifie que l’argument n e 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 (&quot;Int value is:&quot;+val);
    • // Affecter la chaîne
    • str = new String (&quot;hello&quot;);
    • // Tenter de la modifier
    • pt.changeStr (str);
    • // Quelle est la valeur actuelle ?
    • System.out.println (&quot;Str value is:&quot;+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 ( &quot;Valeur actuelle :
    • &quot; + pt.value);
    • }
    • // Méthode pour changer les valeurs actuelles
    • public void changeInt (int value) {
    • value = 55;
    • }
    • public void changeStr (String value) {
    • value = new String (&quot;differente&quot;);
    • }
    • 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(&quot;addUp() gives&quot; + 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érateur instanceof
    • 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.