U.F.R Mathématiques de la Décision. Programmation objet. Partie II. André Casadevall

U.F.R Mathématiques de la Décision Programmation objet Partie II André Casadevall Mai 2001

p. 2 AJ.C 12 juin 2001

Table des matières 3 Héritage 5 3.1 Introduction - L héritage, qu est-ce que c est?...................... 5 3.2 Retour sur les constructeurs et sur l utilisation de this................ 6 3.2.1 Les constructeurs.................................. 6 3.2.2 Une autre utilisation de this........................... 10 3.3 Méthodes et héritage.................................... 11 3.3.1 Méthodes héritées - méthodes propres...................... 11 3.3.2 Sur-classes, sous-classes.............................. 12 3.3.3 Redéfinition des méthodes d instance....................... 13 3.3.4 Appel d une méthode d instance héritée et/ou redéfinie............ 16 3.3.5 Redéfinition des méthodes de classe....................... 18 3.3.6 Utilisation de super................................ 19 3.4 Surcharge des méthodes.................................. 22 3.4.1 Surcharge v.s redéfinition............................. 22 3.4.2 Sélection et exécution d une méthode...................... 25 3.5 Variables d instance et héritage.............................. 28 3.5.1 Accès aux variables d instance.......................... 28 3.5.2 Des constructeurs pour les classes-fille - super( )............... 32 4 Packages et règles d accès 33 4.1 Introduction........................................ 33 4.2 Utilisation et création de packages............................ 35 4.2.1 Un peu de vocabulaire............................... 35 4.2.2 Accès aux classes d un package.......................... 36 4.2.3 La variable d environnement CLASSPATH..................... 38 4.2.4 Créer un package - Ajouter une classe à un package.............. 39 4.3 Accès aux éléments d une classe.............................. 39 4.3.1 Modificateurs usuels................................ 40 4.4 Contrôle de la redéfinition et de l héritage : final et abstract............ 40 4.4.1 Utilisation de final................................ 40 4.4.2 Classes et méthodes abstraites.......................... 41 5 Exceptions 43 5.1 Des exceptions, pourquoi faire?............................. 43 5.1.1 Objectif des exceptions.............................. 43 5.1.2 Cadre général de l utilisation des exceptions................... 45 5.2 Les classes d exception de java.............................. 46 5.3 Exceptions et héritage................................... 47

TABLE DES MATIÈRES 5.3.1 Erreurs multiples.................................. 47 5.3.2 Méthodes redéfinies................................ 48 6 Flux et fichiers 49 6.1 Introduction......................................... 49 6.1.1 Flux de données.................................. 49 6.1.2 Fichiers....................................... 50 6.2 Quelques classes de java.io................................ 52 6.3 Exemples d utilisation des classes de java.io...................... 53 6.3.1 Fichiers de caractères............................... 53 6.3.2 Fichiers d octets.................................. 54 6.3.3 Utilisation de IOException............................ 55 6.3.4 Les flux in et out................................. 56 6.3.5 Fichiers d objets.................................. 57 p. 4 AJ.C 12 juin 2001

3 Héritage Sommaire 3.1 Introduction - L héritage, qu est-ce que c est?............... 5 3.2 Retour sur les constructeurs et sur l utilisation de this......... 6 3.2.1 Les constructeurs................................. 6 3.2.2 Une autre utilisation de this.......................... 10 3.3 Méthodes et héritage.............................. 11 3.3.1 Méthodes héritées - méthodes propres..................... 11 3.3.2 Sur-classes, sous-classes............................. 12 3.3.3 Redéfinition des méthodes d instance...................... 13 3.3.4 Appel d une méthode d instance héritée et/ou redéfinie........... 16 3.3.5 Redéfinition des méthodes de classe...................... 18 3.3.6 Utilisation de super............................... 19 3.4 Surcharge des méthodes............................ 22 3.4.1 Surcharge v.s redéfinition............................ 22 3.4.2 Sélection et exécution d une méthode..................... 25 3.5 Variables d instance et héritage........................ 28 3.5.1 Accès aux variables d instance......................... 28 3.5.2 Des constructeurs pour les classes-fille - super( ).............. 32 3.1 Introduction - L héritage, qu est-ce que c est? L héritage est la propriété permet à une classe d utiliser des ressources, des méthodes en particulier, qui sont définies dans une classe existante. La nouvelle classe est appelée classe-fille de la classe existante (on dit aussi qu elle hérite, qu elle étends ou encore qu elle dérive de cette dernière). La classe initiale est naturellement appelée classe-mère de la nouvelle classe. Nous avons rencontré dans les chapitres précédents des méthodes,equals ou tostring par exemple, qu il est possible d utiliser dans une classe alors même qu elles n y sont pas explicitement définies. Ces deux méthodes sont en fait définies dans la classe Object : en java toutes les classes dérivent de la classe Object. L héritage ne se limite pas à la seule réutilisation de méthodes. L héritage est aussi un moyen pour étendre le comportement d une classe donnée en lui associant des classes-filles plus spécialisées : soit en ajoutant de nouvelles méthodes ; soit en modifiant certaines méthodes de la classe-mère ;

CHAPITRE 3. HÉRITAGE soit en ajoutant de nouvelles variables d instance (ce qui aura une incidence sur les constructeurs de ces classes) ; soit enfin en combinant ces trois approches. L héritage est enfin, on le verra plus loin, un moyen de mettre en oeuvre la notion de type et de la compléter : une classe-fille qui hérite d une classe-mère partage avec celle-ci ses méthodes (donc son interface) et ainsi que ses variables d instance. Ce chapitre sera également l occasion d approfondir la notion de surcharge qui bien qu indépendante de la notion d héritage, intervient lorsqu on met en oeuvre ce concept. 3.2 Retour sur les constructeurs et sur l utilisation de this 3.2.1 Les constructeurs Examinons la classe suivante : Exemple 3.2.1 : 1 public class Personne { 2 private int age ; 3 private String nom ; 4 5 public String tostring() { 6 return nom + " - " + age + " ans" ; 7 } 8 } 1 public class Test { 2 public static void main(string[] args) { 3 Personne a = new Personne() ; 4 System.out.println(a) ; 5 } 6 } Remarquons tout d abord que la classe Personne ne possède pas de constructeur. L exécution de Test produit l affichage : null - 0 ans Commentons ce résultat : À la ligne 3 on a créé un objet Personne. La ligne 4 affiche les valeur des des variables variables d instance de l objet créé : age est affectée de la valeur 0 ; non est affectée de la valeur null. Règle : En l absence de constructeur explicite, java utilise un constructeur générique qui affecte des valeurs par défaut aux variables d instance de l objet créé : types numériques 0 boolean f alse char caractère u\0000 référence à des objets null p. 6 AJ.C 12 juin 2001

3.2. RETOUR SUR LES CONSTRUCTEURS ET SUR L UTILISATION DE THIS Exemple 3.2.2 : Modifions le constructeur à la classe Personne : 1 public class Personne { 2 private int age ; 3 private String nom ; 4 5 public Personne(int n, String s) { 6 age = n ; 7 nom = s ; 8 } 9 public String tostring() { 10 return nom + " - " + age + " ans" ; 11 } 12 } Exécutons à nouveau Test : une erreur est alors signalée à la ligne 3 : No constructor matching Personne() found in class Personne Règle : Dès qu un constructeur explicite est défini, le mécanisme du constructeur générique est supprimé. Exemple 3.2.3 : Remplaçons les lignes 3 et 4 de Test par : 3 Personne b = new Personne(7,"Bozo") ; 4 System.out.println(b) ; Exécutons Test à nouveau : on obtient alors le résultat attendu : Bozo - 7 ans. Réintroduisons dans la classe Personne le constructeur non paramétré défini précédemment : 1 public class Personne { 2 private int age ; 3 private String nom ; 4 5 public Personne() { 6 } 7 public Personne(int n, String s) { 8 age = n ; 9 nom = s ; 10 } 11 public String tostring() { 12 return nom + " - " + age + " ans" ; 13 } 14 } AJ.C 12 juin 2001 p.7

CHAPITRE 3. HÉRITAGE Exécutons la classe Test modifiée : 1 public class Test { 2 public static void main(string[] args) { 3 Personne a = new Personne() ; 4 System.out.println(a) ; 5 6 Personne b = new Personne(7,"Bozo") ; 7 System.out.println(b) ; 8 } 9 } On obtient : null - 0 ans Bozo - 7 ans Signature d un constructeur, d une méthode Ainsi que le montrent les exemples précédents, une classe peut comporter plusieurs constructeurs. Ils se distinguent alors par la liste des type des paramètres utilisés lors de la définition du constructeur ou paramètres formels. Cette liste est la signature du constructeur. Plus précisément, la signature d une méthode (et en particulier celle d un constructeur) est constituée du nom de la méthode suivie de la liste ordonnée des types des paramètres formels utilisés lors de sa définition. La signature des deux constructeurs de la classe Personne est respectivement Personne () et Personne (int, String). On ne peut avoir simultanément deux constructeurs non-paramétrés puisqu ils auraient la même signature. Par contre les deux constructeurs suivants : public Personne(int n, String s) { age = n ; nom = s ; } public Personne(String s, int n) { age = n ; nom = s ; } peuvent coexister puisque la signature du premier est Personne (int, String), alors que la signature du second est Personne (String, int). Remarquons de plus que le constructeur non-paramétré Personne() tel qu il a été défini à la ligne 5, joue un rôle semblable à celui du constructeur générique : les variables nom et age ont été affectées des valeurs null et 0. Ce comportement était parfaitement prévisible, le corps de ce constructeur ne comportant aucune affectation (explicite ou implicite) de valeur aux variables nom ou age. Règle : Les constructeurs d une classe doivent différer par leur signature. Lorsqu il n y a pas d affectation de valeur (explicite ou implicite) à une variable d instance, celle-ci est initialisée avec pour valeur par défaut : p. 8 AJ.C 12 juin 2001

3.2. RETOUR SUR LES CONSTRUCTEURS ET SUR L UTILISATION DE THIS Exemple 3.2.4 : types numériques 0 boolean f alse char caractère u\0000 référence à des objets null Dans le contexte de la classe Personne voici des exemples qui illustrent l ensemble des situations possibles : Pas de paramètre, pas d affectation (donc valeurs par défaut) : public Personne() { System.out.println("pouic") ; } La séquence Personne a = new Personne() ; System.out.println(a) ; affiche alors : pouic null - 0 ans Pas de paramètre, mais affectation d une valeur (nécessairement) constante : public Personne() { nom = "Bozo" ; } La séquence Personne a = new Personne() ; System.out.println(a) ; affiche alors : Bozo - 0 ans La valeur par défaut null a été remplacée par Bozo qui devient la valeur d initialisation de la variable nom. Un paramètre ou des paramètres : public Personne(String s) { nom = s ; } La séquence Personne a = new Personne("Toto") ; System.out.println(a) ; affiche alors : Toto - 0 ans La variable age n est pas initialisée, elle prend donc la valeur null. Le cas où le constructeur serait paramétré, mais où il n y aurait pas d affectation de valeur aux variables d instances n a pas beaucoup d intérêt... AJ.C 12 juin 2001 p.9

CHAPITRE 3. HÉRITAGE 3.2.2 Une autre utilisation de this On a déjà vu que this remplace l objet appelant pour lever une ambiguïté qui pourrait conduire à une erreur. En voici un exemple : Exemple 3.2.5 : Le constructeur Personne(int n, String s) défini ci-dessus aurait pu être écrit sous la forme : public Personne(int age, String nom) { this.age = age ; this.nom = nom ; } pour distinguer la variable locale nom ou age de la variable d instance homonyme. Une autre utilisation de this est liée à la définition des constructeurs comme le montre l exemple suivant : Exemple 3.2.6 : 1 public class Personne { 2 private int age ; 3 private String nom ; 4 5 public Personne() { 6 } 7 public Personne(String s) { 8 nom = s ; 9 } 10 public Personne(int n, String s) { 11 this(s) ; 12 age = n ; 13 } 14 public String tostring() { 15 return nom + " - " + age + " ans" ; 16 } 17 } Commentons l utilisation de this dans Personne(int n, String s) (ligne 11) ; this(s) cherche à appliquer un constructeur (s il l en existe un) de la classe Personne qui soit paramétré par un String (autrement dit, un constructeur de signature Personne (String)). Cette propriété est celle du constructeur Personne(String s) ; this(s) crée donc un objet Personne dont la variable nom est initialisée avec la valeur de s et dont la variable age vaut 0. Dans ce contexte, this(s) est en quelque sorte équivalent à : this = new Personne(s) (this ne peut bien sur être utilisé ainsi). Cette équivalence a pour conséquence qu il n est pas possible d inverser l ordre des deux lignes 11 et 12 ; en effet this(s) recréerait un nouvel objet qui écraserait l objet en cours de création. De même, this() appliquerait à l objet appelant le constructeur de la classe Personne de la forme Personne(), créant ainsi un objet Personne dont la variable nom serait initialisée à null et la variable age à 0. Règle : p. 10 AJ.C 12 juin 2001

3.3. MÉTHODES ET HÉRITAGE Utilisation de this : this, sans paramètre, remplace une variable faisant référence à l objet appelant ; lorsqu il apparaît toujours à la premiere ligne d un constructeur d une classe Cc, this(liste de paramètres) applique (s il existe) le constructeur Cc(liste de paramètres) 3.3 Méthodes et héritage 3.3.1 Méthodes héritées - méthodes propres Exemple 3.3.1 : Dans cet exemple on définit les classes Nom, NomPlus qui se déduit de Nom en utilisant l héritage, et une classe TestNom qui met en oeuvre les deux premières. 1 public class Nom { 2 public String affiche() { 3 return "Bozo" ; 4 } 5 } 6 7 public class NomPlus extends Nom { 8 public String afficheplus() { 9 return "Oum" ; 10 } 11 } Dans l en-tête de la classe NomPlus, extends Nom indique que la classe NomPlus est une classe-fille de Nom. Exécutons la classe TestNom : 1 public class TestNom { 2 3 public static void main(string[] args) { 4 Nom n = new Nom() ; 5 System.out.println(n.affiche()) ; 6 NomPlus m = new NomPlus() ; 7 System.out.println(m.affichePlus()) ; 8 System.out.println(m.affiche()) ; 9 // System.out.println(n.affichePlus()) ; provoque une erreur 10 n = m ; 11 // m = n ; provoque une erreur 12 } 13 } AJ.C 12 juin 2001 p.11

CHAPITRE 3. HÉRITAGE On obtient l affichage : Bozo Oum Bozo Cet exemple montre que les objets NomPlus peuvent utiliser la méthode affiche de la classe Nom. Cette méthodes est une méthode héritée de la classe-mère Nom. Par contre les objets de la classe Nom ne peuvent utiliser la méthode afficheplus (ligne 9) qui est une méthode propre de la classe NomPlus. On constate également que la référence à des objets NomPlus peut être affectée à des objets Nom la réciproque (ligne 11) conduisant à une erreur. C est une situation que nous avons déjà rencontrée : Nomplus définit un sous-type de Nom. Mais contrairement à ce qui se passe pour les interfaces, une classe ne peut être la classe-fille que d une seule classe. Règles : extends Cc dans l en-tête d une classe indique que cette classe est une classe-fille de la classe Cc. Une classe ne peut ne peut être la classe-fille que d une seule classe (classe-mère). Les méthodes de la classe-mère sont accessibles aux objets de la classe-fille (méthodes héritées). Les méthodes de la classe-fille ne sont pas accessibles aux objets de la classe-mère (méthodes propres à la classe-fille). Une classe-fille définit un sous-type de la classe-mère. On peut affecter la référence d un objet de la classe-fille, à une variable dont le type est celui de la classe-mère. Lorsque Bb est une classe-fille de Aa on dit que Bb étend Aa, que Bb dérive de Aa ou encore que Bb hérite de Aa. 3.3.2 Sur-classes, sous-classes Créons une nouvelle classe NomPlusPlus qui hérite de NomPlus Exemple 3.3.2 : 1 public class NomPlusPlus extends NomPlus { 2 public String afficheplusplus() { 3 return "Gus" ; 4 } 5 } et complétons TestNom : 1 public class TestNom { 2 3 public static void main(string[] args) { 4 Nom n = new Nom() ; 5 System.out.println(n.affiche()) ; 6 7 NomPlus m = new NomPlus() ; p. 12 AJ.C 12 juin 2001

3.3. MÉTHODES ET HÉRITAGE 8 System.out.println(m.affichePlus()) ; 9 System.out.println(m.affiche()) ; 10 11 NomPlusPlus p = new NomPlusPlus() ; 12 System.out.println(p.affichePlusPlus()) ; 13 System.out.println(p.affichePlus()) ; 14 System.out.println(p.affiche()) ; 15 m = p ; 16 n = p ; Cette nouvelle version de TestNom affiche : Bozo Oum Bozo Gus Oum Bozo Tout ceci montre que la classe NomPlusPlus peut utiliser les méthodes de la classe NomPlus mais aussi les méthodes de la classe Nom. De même la référence à des objets NomPlusPlus peut être affectée à des objets Nom et NomPlus. Règle : La relation Bb dérive de Aa est une une relation transitive. Les classes-filles des classes-filles... des classes-filles d une classe Cc constituent les sousclasses de Cc. Les classes-mères des classe-mères... des classes-mères de Cc constituent les sur-classes de Cc. Puisqu une classe ne peut avoir qu une seule classe-mère, l ensemble des sur-classes et des sousclasses d une classe Cc donnée possède une structure d arbre Les règles suivantes étendent par transitivité les propriétés des classes-mères et des classes-filles aux sur-classes et aux sous-classes d une classe donnée. Règle : Soit Cc une classe : Les méthodes de toute sur-classe de Cc sont accessibles aux objets de Cc (méthodes héritées). Les objets de Cc ne peuvent accéder à aucune des méthodes des sous-classes de Cc. Les sous-classes de Cc définissent des sous-types du type défini par Cc. 3.3.3 Redéfinition des méthodes d instance Nous allons voir qu il est possible de redéfinir dans une classe Cc une méthode déjà définie dans une sur-classe de Cc, les deux versions ayant la même signature. Ceci est en fait parfaitement légal puisque Cc et sa sur-classe sont deux classes distinctes. AJ.C 12 juin 2001 p.13

CHAPITRE 3. HÉRITAGE sur-classe sous-classe Object Cc Fig. 3.1: Arbre des classes Exemple 3.3.3 : Créons une nouvelle version de NomPlusPlus dans laquelle la méthode affiche est redéfinie c est à dire que la méthodeaffiche déjà définie dans la classe Nom est définie à nouveau dans la sous-classe NomPlusPlus : 1 public class Nom { 2 public String affiche() { 3 return "Bozo" ; 4 } 5 } 6 7 public class NomPlus extends Nom { 8 public String afficheplus() { 9 return "Oum" ; 10 } 11 } 12 public class NomPlusPlus extends NomPlus { 13 public String affiche() { 14 return "Toto" ; 15 } 16 } p. 14 AJ.C 12 juin 2001

3.3. MÉTHODES ET HÉRITAGE Exécutons TestNom : 1 public class TestNom { 2 public static void main(string[] args) { 3 Nom n = new Nom() ; 4 System.out.println(n.affiche()) ; 5 NomPlus m = new NomPlus() ; 6 System.out.println(m.affichePlus()) ; 7 System.out.println(m.affiche()) ; 8 NomPlusPlus p = new NomPlusPlus() ; 9 System.out.println(p.affichePlus()) ; 10 System.out.println(p.affiche()) ; 11 n = p ; 12 // System.out.println(n.affichePlus()) ; 13 System.out.println(n.affiche()) ; 14 System.out.println(((Nom)p).affiche()) ; 15 } 16 } On obtient l affichage suivant : Bozo Oum Bozo Oum Toto Toto Toto Commentons cet affichage : À la ligne 3 on crée un objet Nom. La méthode affiche utilisée à la ligne 4 est celle de la classe Nom, d où l affichage de Bozo. À la ligne 5 on crée un objet NomPlus. La méthode afficheplus utilisée ligne 6 est celle de la classe NomPlus, d où l affichage de Oum. À la ligne 7 la méthode affiche est la méthode héritée de la classe Nom, d où l affichage de Bozo. À la ligne 8 on crée un objet NomPlusPlus. La méthode afficheplus utilisée ligne 9 est la méthode héritée de la classe NomPlus, d où l affichage de Oum. À la ligne 10 la méthode affiche est la méthode redéfinie dans NomPlusPLus, d où l affichage de Toto. La ligne 12 provoque une erreur de compilation : Error : Method afficheplus() not found in class Nom. TestNom.java line 12 System.out.println(n.affichePlus()) ; En effet n est une variable de type Nom alors que afficheplus d finie dans NomPlus n est pas une méthode accessible aux variables de la classe Nom. La ligne 13 est syntaxiquement exacte puisquenest une variable de typenom et que la méthode affiche est définie dans cette classe. Cependant n fait référence à un objet NomPlusPlus et c est alors la méthode affiche redéfinie dans NomPlusPlus qui est utilisée, d où l affichage de Toto. AJ.C 12 juin 2001 p.15

CHAPITRE 3. HÉRITAGE La ligne 14 est un essai infructueux pour forcer l utilisation de la méthode affiche de Nom par un objet de la classe NomPlusPlus. La méthode utilisée dépend bien de l objet appelant et non pas du type de la variable qui référence cet objet. L utilisation d un cast dans ce contexte provoque un message d attention : Warning : The cast from NomPlusPlus to Nom is possibly unnecessary. TestNom.java line 14 System.out.println(((Nom)p).affiche()) ; On vera plus loin que la bonne méthode consiste en l utilisation de super. Méthodes d instance accessibles En java toute variable et plus généralement toute expression, possède un type qui est un type fondamental ou celui d une classe ou d une interface. Nous ne nous intéresserons qu aux variables (ou aux expressions) dont le type est celui d une classe ou d une interface puisque ce sont celles qui peuvent apparaître comme préfixe dans l appel d une méthode d instance. On dira qu une méthode d instance est accessible à une variable (ou une expression) lorsque le type de la variable (ou de l expression) est : le type de la classe ou de l interface où est définie la méthode d instance ; un sous-type de ce dernier. Réciproquement on dira qu une variable (ou une expression) et une méthode sont compatibles lorsque la méthode est accessible à cette variable (ou à cette expression). Par abus de langage on dira parfois méthode accessible à un objet o,... au lieu de méthode accessible à la variable qui fait référence à o,.... Exemple 3.3.4 : Reprenons les classes de l exemple précédent. Elles définissent trois types : Nom - la seule méthode accessible est affiche() NomPlus qui est un sous-type de Nom - les méthodes accessibles sont affiche() héritée de Nom afficheplus() NomPlusPlus qui est un sous-type de NomPlus - les méthodes accessibles sont afficheplus() héritée de NomPlus afficheplus() redéfinie dans NomPlusPlus(). A la ligne 12 on définit n comme variable de type Nom et seule affiche() est accessible, d où l erreur provoquée par la ligne 13. A la ligne 14 (Nom)p est une expression de type Nom et ((Nom)p).affiche() ne provoque pas d erreur, il en serait de même pour l appel de méthode (new NomPlus()).affiche() (qui retourne Bozo). 3.3.4 Appel d une méthode d instance héritée et/ou redéfinie Avant de voir comment java sélectionne la méthode qui sera effectivement utilisée, précisons le mécanisme utilisé par java lors de l appel d une méthode. Paramètres-effectifs Appeler une méthode c est fournir aux paramètres-formels (les paramètres qui ont servi à la définition de la méthode) les valeurs nécessaires à l exécution des instructions qui forment le corps de la méthode. Ces valeurs sont appelées paramètres-effectifs ou arguments de l appel. p. 16 AJ.C 12 juin 2001

3.3. MÉTHODES ET HÉRITAGE Exemple 3.3.5 : Complétons la classe Nom par la méthode printn : 1 public void printn(int n, String s) { 2 String result = s ; 3 for (int i = 0 ; i<n ; i++) 4 result += s ; 5 return result ; 6 System.out.println(result) ; 7 } Dans la classe TestNom on ajoutera la ligne : 8 n.printn(3, "abc") les paramètres formels de printn sont n et s, sa signature est printn(int, String). lors de l appel de cette méthode (ligne 8) les paramètres-effectifs ou arguments de l appel sont 3 et "abc". Appel de méthode Un appel de méthode est le texte constitué par le nom de la méthode suivi de la liste des paramètres effectifs : printn(3, "abc") dans l exemple ci-dessus. La signature d un appel de méthode est formée du nom de la méthode suivi par la liste des types des paramètres-effectifs : printn(int, String) dans le même exemple. Compatibilité d un appel de méthode Lorsqu une méthode est appelée (supposons pour l instant que cette méthode existe), le compilateur effectue les taches suivantes : il vérifie que le nombre des arguments de l appel est identique au nombre des paramètresformels ; ensuite, si ce nombre est strictement positif, il cherche à associer à chaque argument un (et un seul) paramètre-formel : le mode d association est simplement fondé sur l ordre d apparition des paramètres : le premier argument est associé au premier paramètre-formel, le deuxième argument est associé au deuxième paramètre-formel,... (dans l exemple, 3 est associé à i, "abc" est associé à s) ; la valeur de chaque argument est alors transmise au paramètre-formel correspondant par une opération (implicite à l appel de la méthode) qui en java est l affectation de valeur : paramètre-formel = argument Sous-typage et promotion numérique étendent la validité de cette affectation aussi il est nécessaire de préciser les conditions suivant lesquelles un appel de méthode est compatible avec une méthode, plus précisément avec la signature d une méthode. Un appel de méthode est compatible avec la signature d une une méthode lorsque : le nom figurant dans l appel est identique au le nom apparaissant dans la signature de la méthode ; le nombre des arguments est égal au nombre des types de paramètres apparaissant dans la signature ; AJ.C 12 juin 2001 p.17

CHAPITRE 3. HÉRITAGE lorsque ce nombre est strictement positif, chaque argument doit être compatible pour l affectation avec le paramètre-formel auquel il est associé : si les paramètres appartiennent à des types numériques, la promotion est possible (dans l exemple, la méthode printn de signature printn (int, String) peut être appelée avec un argument byte) ; si les paramètres sont des références à des objets, le type de l argument doit être un sous-type du type du paramètre-formel. Sélection d une méthode d instance héritée et/ou redéfinie Considérons une suite de classes C 0, C 1,, C N telles que pour tout i (1 i N), C i dérive de C i 1. Supposons qu une méthode d instance soit définie dans C 0 et soit éventuellement redéfinie dans certaines des classes C i. La exécution et le résultat de l appel de cette méthode dépend des deux étapes successives suivantes : 1. typage statique : Le compilateur détermine le type de la variable (ou de l expression) préfixant l appel de méthode : il existe parmi les méthodes accessibles par cette variable (ou cette expression) une méthode dont la signature est compatible avec l appel de méthode, alors le processus se continue à l étape 2 ; sinon la compilation s arrête avec un message d erreur. 2. exécution dynamique : La variable (ou l expression) préfixant l appel de méthode fat référence à un objet (objet appelant) dont le compilateur détermine la classe : si la méthode appelée est définie dans cette classe, elle est exécutée, sinon java cherche dans la classe-mère de la classe, puis éventuellement dans la classemère de la classe-mère... en remontant dans l arbre des classes jusqu à trouver la méthode qui sera exécutée ; cette méthode est la méthode la plus proche parmi les méthodes de même signature définies dans l ensemble des sur-classes de la classe de l objet appelant. 3.3.5 Redéfinition des méthodes de classe Examinons maintenant le cas des méthodes de classe (caractérisées par le mot static). Modifions les classesnom, NomPlus et TestNom en remplaçant les méthodes d instance affiche et afficheplus par des méthodes de classe : Exemple 3.3.6 : 1 public class Nom { 2 public static String msg() { 3 return "Bozo" ; 4 } 5 } 6 7 public class NomPlus extends Nom { 8 public static String msg() { 9 return "Oum" ; 10 } p. 18 AJ.C 12 juin 2001

3.3. MÉTHODES ET HÉRITAGE Exécutons la classe TestNom : 1 public class TestNom { 2 public static void main(string[] args) { 3 System.out.println(Nom.msg()) ; 4 System.out.println(NomPlus.msg()) ; 5 } 6 } On obtient l affichage : Bozo Oum Le processus de sélection des méthodes de classe est particulièrement simple : le compilateur cherche dans la classe dont le nom préfixe l appel de méthode une méthode de classe dont la signature est compatible avec l appel de méthode : si cette méthode existe elle est exécutée ; sinon la compilation s arrête avec un message d erreur. 3.3.6 Utilisation de super La sélection de la méthode à utiliser est plus simple pour les méthodes de classe que pour les méthodes d instance ; nom de la classe dans laquelle est définie la méthode apparaît explicitement dans l appel d une méthode de classe. Pour les méthodes d instance super permet d orienter le choix du compilateur afin utiliser la méthode définie dans une sur-classe à la place de celle définie dans la classe considérée. super s utilise d une façon assez proche de celle de this. Modifions une fois encore les classes Nom, NomPlus et NomPlusPlus. Exemple 3.3.7 : 1 public class Nom { 2 public String affiche() { 3 return "Bozo" ; 4 } 5 public String printn() { 6 return "BOZO" ; 7 } 8 } 9 10 public class NomPlus extends Nom { 11 public String affiche() { 12 return "Oum" ; 13 } 14 public String affiche1() { 15 return super.affiche() ; 16 } 17 } 18 19 public class NomPlusPlus extends NomPlus { 20 public String printn() { AJ.C 12 juin 2001 p.19

CHAPITRE 3. HÉRITAGE 21 return "GUS" ; 22 } 23 public String affiche2() { 24 return super.printn() ; 25 } 26 } Exécutions la classe TestNom : 1 public class TestNom { 2 3 public static void main(string[] args) { 4 Nom n = new Nom() ; 5 System.out.println(n.affiche()) ; 6 System.out.println(n.printN()) ; 7 8 NomPlus m = new NomPlus(); 9 System.out.println(m.affiche1()) ; 10 11 NomPlusPlus p = new NomPlusPlus(); 12 System.out.println(p.affiche2()) ; 13 } 14 } on obtient : Bozo BOZO Bozo BOZO Commentons ces résultats : Le premier Bozo résulte de println(n.affiche()) de la ligne 5. Le deuxième BOZO résulte de println(n.printn()) de la ligne 6. Le Bozo suivant résulte de println(m.affiche1()) de la ligne 9. Dans affiche1, le résultat montre que super.affiche() (ligne 15 de NomPlus) fait référence à la méthode affiche() de la classe Nom et non à celle de la classe NomPlus. Tout se passe donc comme si la ligne 15 avait été écrite : Nom n = transformeennom(this); return n.affiche(); en forçant le compilateur à considérer l objet appelant comme un objet de la classe Nom et non pas comme un objet de la classe NomPlus. Bien évidemment, la méthode transformeennom n existe pas sous cette forme ; c est super qui réalise cette transformation. Remarquons enfin que si on avait remplacé cette ligne 15 par : Nom n = (Nom)this; return n.affiche(); le résultat aurait été Oum en raison de l aspect dynamique de l exécution d une méthode (c.f. Règles de sélection des méthodes d instance). Le dernier affichage résulte de println(p.affiche2()) et p est un objet NomPlusPlus. super.printn() (ligne 24 de NomPlusPlus) fait référence à la méthode printn() de la classe Nom et non à celle de la classe NomPlusPlus et retourne BOZO p. 20 AJ.C 12 juin 2001

3.3. MÉTHODES ET HÉRITAGE Dans la suite nous verrons une autre utilisation de super en relation avec les constructeurs. Règle : Utilisation de super dans le corps d une méthode d instance : Lorsqu une classe Cc contient une méthode m(... ) qui redéfinit une méthode de la classemère de Cc, super.m(... ) applique à l objet appelant la méthode m(... ) définie dans la classe-mère et non la méthode redéfinie dans Cc. Si la méthodem(... ) n existe pas dans la classe-mère,java chercher à appliquer la méthode de même signature la plus proche définie dans l ensemble des sur-classes de Cc Remarque : Méthodes utilisant des méthodes héritées Modifions très légèrement la classe Nom, les autres classes restant inchangées.!!! Exemple 3.3.8 : 1 public class Nom { 2 public String affiche() { 3 return "Bozo" ; 4 } 5 public String printn() { 6 return this.affiche().touppercase() ; 7 // en remplacement de return "BOZO" ; 8 } 9 } 10 11 public class NomPlus extends Nom { 12 public String affiche() { 13 return "Oum" ; 14 } 15 public String affiche1() { 16 return super.affiche() ; 17 } 18 } 19 20 public class NomPlusPlus extends NomPlus { 21 public String printn() { 22 return "GUS" ; 23 } 24 public String affiche2() { 25 return super.printn() ; 26 } 27 } Exécutons la même classe testnom : AJ.C 12 juin 2001 p.21

CHAPITRE 3. HÉRITAGE 1 public class TestNom { 2 public static void main(string[] args) { 3 Nom n = new Nom() ; 4 System.out.println(n.affiche()) ; 5 System.out.println(n.printN()) ; 6 7 NomPlus m = new NomPlus(); 8 System.out.println(m.affiche1()) ; 9 10 NomPlusPlus p = new NomPlusPlus(); 11 System.out.println(p.affiche2()) ; 12 } 13 } On obtient : Bozo BOZO Bozo GUS Commentons ces résultats : Le premiers et troisième affichages sont identiques à ceux obtenus dans l exemple précédent ; ceci est bien normal puisque nous n avons pas modifié la méthode affiche() de la classe Nom. Le second affichage, BOZO, résulte de this.affiche().touppercase() La chaîne de caractères Bozo retournée par this.affiche() est transformée en majuscules par touppercase(). Arrêtons nous sur le dernier affichage qui lui est modifié : on obtient GUS au lieu du BOZO obtenu dans l exemple précédent bien que la classe NomPlusPlus n(ait pas été modifiée : p.affiche2() fait référence à la méthode printn() de la classe Nom puisque printn n est pas définie dans NomPlus. Java exécute donc (p.affiche()).touppercase(). Mais puisque p fait référence à un objet de la classe NomPlusPlus, c est la méthode affiche définie dans NomPlusPlus qui est exécutée ; p.affiche() retourne GUS. Finalement p.affiche2() retourne GUS. 3.4 Surcharge des méthodes 3.4.1 Surcharge v.s redéfinition On parle de surcharge lorsque deux méthodes portant le même nom (méthodes homonymes), sont définies dans la même classe et ne diffèrent que par leur signature (nom de la méthode suivi de la liste ordonnée des types des paramètres utilisés pour sa définition). On parle de redéfinition lorsque deux méthodes portant le même nom sont définies dans deux classes distinctes dont l une est une sur-classe de l autre, et ont la même liste de paramètres formels. () Remarquons que nous avons déjà rencontré ce problème à propos des constructeurs qui pour une classe donnée portent nécessairement le même nom et ne se distinguent que par leur signature. p. 22 AJ.C 12 juin 2001

3.4. SURCHARGE DES MÉTHODES Exemple 3.4.1 : Modifions les classes Nom et NomPlus de la section précédente : 1 public class Nom { 2 public void affiche() { 3 System.out.println( "Bozo") ; 4 } 5 } 6 7 public class NomPlus extends Nom { 8 // la méthode affiche est redéfinie 9 public void affiche() { 10 System.out.println( "Oum"); 11 } 12 13 // les méthodes print sont surchargées 14 public void print() { 15 System.out.println( "Gus") ; 16 } 17 public String print(string s) { 18 return ("String : "+s) ; 19 } 20 public void print(double i, String s) { 21 System.out.println( "double first : " + i) ; 22 } 23 public void print(string s, double i) { 24 System.out.println("String first : "+s) ; 25 } 26 } Exécutons la classe Test suivante : 1 public class Test { 2 public static void main(string[] args) { 3 NomPlus p = new NomPlus() ; 4 p.affiche() ; 5 p.print() ; 6 System.out.println(p.print( "Toto")) ; 7 p.print("aa", 1) ; 8 p.print(2, "bb") ; 9 } 10 } On obtient : Oum Gus String : Toto String first : aa double first : 2 AJ.C 12 juin 2001 p.23

CHAPITRE 3. HÉRITAGE Commentons : p est un objet NomPlus, p.affiche() utilise donc la méthode redéfinie affiche de la classe NomPlus. Les affichages suivants sont le résultat de l appel des différentes versions de la méthode surchargée print. Elles diffèrent par leur signature qui dans l ordre de définition des méthodes, sont : print() print(string) print(double, String) print(string, double) On notera que le type de la valeur renvoyée par la méthode n intervient pas dans le processus de sélection de la méthode print utilisée ; seuls sont intervenu le type, le nombre et l ordre des paramètres. Surcharge simple - Surcharge implicite Le phénomène de surcharge peut apparaître de façon implicite (cachée) en conjonction avec l héritage comme dans l exemple suivant : Exemple 3.4.2 : Ajoutons une méthode print à la classe Nom de la section précédente : 1 public class Nom { 2 public void affiche() { 3 System.out.println( "Bozo") ; 4 } 5 public String print(int i) { 6 return String.valueOf(i) ; 7 } 8 } Complétons la classe Test pour pouvoir appeler cette nouvelle version de print par : System.out.println(p.print(123)) ; A l exécution on obtient l affichage d une ligne supplémentaire : 123 En effet, les méthodes print accessibles pour les variables de type NomPlus sont maintenant les suivantes : print() print(string) print(double, String) print(string, double) print(int) héritée de la classe Nom L appel p.print(123) a sélectionné la signature print(int) et la méthode correspondante a été utilisée. p. 24 AJ.C 12 juin 2001

3.4. SURCHARGE DES MÉTHODES On dira qu il y a : surcharge simple lorsque les différentes méthodes surchargées sont définies dans la même classe ; surcharge implicite lorsque certaines méthodes accessibles sont définies dans les sur-classes de la classe considérée. Le processus de sélection de la méthode exécutée dans le cas de la surcharge simple : 3.4.2 Sélection et exécution d une méthode Lors d un appel de méthode la sélection puis l exécution d une méthode constituent un problème délicat dans la mesure ou il est nécessaire de tenir en compte de trois facteurs : l héritage, la surcharge, les conséquences du sous-typage ou de la promotion des arguments. Sélection d une signature Cette étape est fondée sur la notion de type. En présence d un appel de méthode : (expr).nomdemethode(liste d arguments) java va analyser la signature de l appel et la comparer à la signature des méthodes dont le nom est nomdemethode. En fait java va sélectionner une signature de méthode et non pas une méthode. Rappelons ici que toutes les méthodes définies dans une même classe différent par leur signature. Si l appel est ambiguë et que java ne parvient pas à dégager une signature unique la compilation s arrête avec un message d erreur du type : Error : Reference to \textit{nomdemethode} is ambiguous. It is defined in... and... Les étapes principales de ce processus de sélection sont les suivantes : Méthode d instance ou méthode de classe java analyse la variable ou l expression préfixant l appel de méthode : si elle ne fait pas référence à un objet, seules les signatures des méthodes de classe (déclarées static) accessibles seront candidates, sinon la recherche se poursuit parmi les signatures des méthodes d instance accessibles à la variable (ou à l expression) préfixant l appel de méthode. Ceci ne fait intervenir que le type de la variable (ou de l expression) préfixant l appel de méthode (cf. 3.3.3) L accessibilité générale des classes et des méthodes sera étudié au prochain chapitre, mais on peut retenir dès à présent que les classes et les méthodes publiques i.e. précédées du mot public sont accessibles depuis toute classe. Compatibilité des paramètres Parmi les signatures sélectionnée par le premier test, java ne va considérer que les signatures compatibles avec les arguments de l appel (cf. 3.3.4). En raison du sous-typage et de la promotion numérique, il se peut qu à ce stade il reste encore plusieurs signatures concurrentes. Choix de la signature la plus spécifique Une signature S 1 est plus spécifique pour un appel de méthode donné, qu une signature S 2 lorsque : les signatures S 1 et S 2 sont toutes deux valide pour cet appel de méthode ; la classe dans laquelle la méthode correspondant à S 1 est définie est le même ou est une sous-classe de celle dans laquelle est S 2 définie ; AJ.C 12 juin 2001 p.25

CHAPITRE 3. HÉRITAGE Chaque type de paramètre de S 1 est le même type ou un sous-type du type de paramètre correspondant de S 2. Exemple 3.4.3 : On a deja défini dans la classe NomPlus une méthode de signature print(string, double) Supposons que l on définisse également les méthodes de signature : print(string, float) print(double, float) print(float, double) Pour l appel de signature print(string, int), la signature print(string, float) est plus spécifique que print(string, double). Par contre, pour l appel de signature print(float, float) aucune des deux signatures print(double, float) et print(float, double) n est plus spécifique que l autre. Il en résultera un message d erreur lors de la compilation. Sauf dans le cas d une méthode de classe, la méthode effectivement exécutée dépend de l objet auquel la variable (ou l expression) préfixant l appel de méthode fait référence cet objet est appelé objet appelant. Ce type est défini dynamiquement lors de l exécution. Exécution de la méthode correspondant à la signature sélectionnée Supposons qu une signature ait été sélectionnée ; l étape qui suit et que nous allons détailler intervient lors de l exécution de la classe qui contient l appel de méthode. Si la signature sélectionnée est celle d une méthode de classe, la méthode correspondante est exécutée.. Si c est celle d une méthode d instance, java détermine la classe de l objet appelant et cherche une méthode dont la signature correspond à la signature sélectionnée : dans cette classe si une telle méthode n existe pas, la recherche continue dans la classe-mère de la classe de l objet appelant, puis éventuellement dans les sur-classes de celle-ci. Une exception à cette règle est le cas où la méthode a été préfixée parsuper : la recherche commence alors par la classe-mère de la classe de l objet appelant et se poursuit éventuellement dans les sur-classes de celle-ci. Exemple 3.4.4 : Modifions les classes Nom et NomPlus de la section précédente : 1 public class Nom { 2 public void print(string s) { 3 System.out.println("String : "+s) ; 4 } 5 } 6 7 public class NomPlus extends Nom { 8 public void print(string s) { 9 System.out.println ("String : "+s.touppercase()) ; 10 } 11 public void print(int i, String s) { p. 26 AJ.C 12 juin 2001

3.4. SURCHARGE DES MÉTHODES 12 System.out.println( i + " + "+ s) ; 13 } 14 public void print(double i, String s) { 15 System.out.println( i + " - "+ s) ; 16 } 17 public void print(double i, StringBuffer s) { 18 System.out.println( i + " * "+ s) ; 19 } 20 public void print(int i, Object o) { 21 System.out.println( i + " + "+ o) ; 22 } 23 } Exécutons la séquence d instruction : 1 NomPlus p = new NomPlus() ; 2 p.print("bozo") ; 3 p.print(2, "Oum") ; 4 p.print(2.0, "Gus") ; 5 StringBuffer sb = new StringBuffer("Toto") ; 6 p.print(2.5, sb) ; 7 // p.print(2, sb) ; // conduit à une erreur On obtient : String : BOZO 2 + Oum 2.0 - Gus 2.5 * Toto String : BOZO est le résultat de l appel de la méthode print(string s) de la classe NomPlus. NomPlus est plus spécifique que la méthode de même signature de Nom (point 3) ; 2 + Oum est le résultat de l appel de la méthode print(int i, String s) ; deux méthodes sont compatibles avec l appel print(2, "Oum") : print(int i, String s) et print(doublet i, String s), mais print(int i, String s) est plus spécifique que print(int i, String s) (point 2) ; 2.0 - Gus est le résultat de l appel de la méthode print(double i, String s), seule méthode compatibles avec l appel print(2.0, "Gus") ; 2.5 * Toto est le résultat de l appel de la méthode print(int i, StringBuffer s), seule méthode compatibles avec l appel print(2.5, sb) ; enfin, lorsqu on exécute la dernière instruction on obtient une erreur : Error : Reference to print is ambiguous. It is defined in void print(int, java.lang.object) and void print(double, java.lang.stringbuffer). qui montre que java ne peut pas choisir entre les deux méthodes print(int i, Object o) et print(double i, StringBuffer s). L appel p.print(2, sb) est valide pour les deux méthodes, mais aucune d elles n est plus spécifique que l autre. AJ.C 12 juin 2001 p.27

CHAPITRE 3. HÉRITAGE Exemple 3.4.5 : Un autre exemple, plus surprenant, extrait de l ouvrage JAVA Language Reference - Mark Grand - O REILLY ed. est le suivant : 1 class A {} 2 class B extends A {} 3 class C extends B {} 4 class D extends C {} 5 6 class W { 7 void foo(d d) {System.out.println("D");} 8 } 9 class X extends W { 10 void foo(a a) {System.out.println("A");} 11 void foo(b b) {System.out.println("X.B");} 12 } 13 class Y extends X { 14 void foo(b b) {System.out.println("Y.B");} 15 } 16 class Z extends Y { 17 void foo(c c) {System.out.println("C");} 18 } 19 20 public class CallSelection { 21 public static void main(string [] argv) { 22 Z z = new Z() ; 23 ((X)z).foo(new C()); 24 } 25 } La méthode foo est appelée avec une expression ((X)z) de type X. La sélection de signature se fait donc parmi les méthodes foo accessibles pour les variables de ce type : foo(d) héritée de W foo(a) définie dans X foo(b) définie dans X La signature de l appel foo(c) exclu la signature foo(d), un objet de la classe C ne pouvant être assigné à une variable de type D. java doit donc choisir entre les signatures foo(a) et foo(b). Cette dernière est plus spécifique puisque B est un sous-type de A. La signature sélectionnée est donc foo(b). Lors de l exécution, l objet appelant estzde la classez. La recherche de la méthodefoo de signature foo(b) commence dans Z. Une telle méthode n existe pas dans Z. La recherche se poursuit dans la classe Y, classe-mère de Z. Il existe dans Y une méthode de signature foo(b) ; c est celle-ci qui est exécutée. 3.5 Variables d instance et héritage 3.5.1 Accès aux variables d instance Reprenons la classe Personne définie au début de cee chapitre. Elle est complétée par une classe Eleve qui ajoute une variable d instance cursus. p. 28 AJ.C 12 juin 2001

3.5. VARIABLES D INSTANCE ET HÉRITAGE Exemple 3.5.1 : 1 public class Personne { 2 private int age ; 3 private String nom ; 4 5 public Personne() { 6 nom = "???" ; 7 } 8 public Personne(int n, String s) { 9 age = n ; 10 nom = s ; 11 } 12 public String tostring() { 13 return nom + " - " + age + " ans" ; 14 } 15 } 16 17 public class Eleve extends Personne { 18 private String cursus ; 19 20 public void setcursus(string c) { 21 cursus = c ; 22 } 23 public String tostring() { 24 return nom + " - " + age +" ans" + " - " + cursus ; 25 } 26 } A la compilation on obtient un message d erreur pour return nom + " - " + age + " ans" : Error : variable nom in class Personne not accessible for class Eleve variable age in class Personne not accessible for class Eleve Le statut privé des variables nom et age n est donc pas modifié par l héritage. L utilisation de super va nous permettre d écrire proprement la méthode tostring de la classe Eleve. Remplaçons les lignes 23 à 25 par : 23 public String tostring() { 24 return super.tostring() + " - " + cursus ; 25 } Ainsi que nous l avons déjà vu, super.tostring() applique à l objet appelant le méthode tostring() de la classe-mère Personne. Exécutons la classe Test : 1 public class Test { 2 public static void main(string[] args) { 3 Eleve e = new Eleve() ; 4 System.out.println(e) ; 5 e.setcursus("ne sait pas") ; 6 System.out.println(e) ; AJ.C 12 juin 2001 p.29

CHAPITRE 3. HÉRITAGE 7 // Eleve f = new Eleve(5,"Mimi") ; 8 // System.out.println(f) ; 9 } 10 } On obtient l affichage??? - 0 ans - null??? - 0 ans - ne sait pas Commentons ce résultat A la ligne 3 on crée un objet Eleve. En l absence de constructeur explicite, java utilise un constructeur générique : java cherche d abord s il existe un constructeur non paramétré dans la classe-mère. C est donc Personne() qui est utilisé ce qui est cohérent avec le premier affichage. Le second affichage est la conséquence de e.setcursus("ne sait pas") qui permet de modifier la variable cursus de l objet e. Les lignes 7 et 8 si elles étaient exécutées conduirait à une erreur wrong number of parameters in.... Ceci montre bien que le mécanisme du constructeur générique est limité aux constructeurs non paramétrés. Règles : Accès aux variables d instance Considérons une classe Bb sous-classe d une classe Aa. les variables d instance (private) définies dans Aa ne sont pas accessibles depuis Bb ; il faut donc prévoir lors de la construction de la classe-mère des méthodes d accès du type getx... (... ) ou setx... (... )!!! Remarque : Variables d instance redéfinies - On peut se poser la question suivante : que se passe-t-il si on définit dans une classe Cc une variable d instance déjà définie dans une sur-classe Aa de la classe Cc considérée? java accepte de genre de redéfinition. Dans la classe Cc on accède normalement à la variable. Si dans Cc on veut accéder à la variable primitive, il faut que lors de sa définition (dans la surclasse Aa de Cc) cette variable ne soit pas déclarée private et si c désigne un objet de Cc, on utilisera la notation ((Aa)c).nom de la variable. On reviendra plus complètement sur le rôle des modificateurs d accès (private, public,... dans le prochain chapitre. Exemple 3.5.2 : On ajoute des méthodes d accès à la classe Nom : 1 public class Personne { 2 private int age ; 3 private String nom ; 4 p. 30 AJ.C 12 juin 2001

3.5. VARIABLES D INSTANCE ET HÉRITAGE 5 public Personne() { 6 nom = "???" ; 7 } 8 public Personne(int n, String s) { 9 age = n ; 10 nom = s ; 11 } 12 public int getage() { 13 return age ; 14 } 15 public void setage(int n) { 16 age = n ; 17 } 18 public String getnom() { 19 return nom ; 20 } 21 public void setnom(string n) { 22 nom = n ; 23 } 24 public String tostring() { 25 return nom + " - " + age + " ans" ; 26 } 27 } On est alors en mesure d écrire des constructeurs pour la classe Eleve : 1 public Eleve() { 2 } 3 public Eleve(int n, String s, String c) { 4 this() ; 5 setage(n) ; 6 setnom(s) ; 7 setcursus(c) ; 8 } Le constructeur Eleve() est indispensable pour pouvoir utiliser this(), qui on l a vu est symboliquement équivalent à this = new Eleve(). On fixe ensuite la valeur des variables age, nom et cursus. Exécutons à nouveau la classe Test : 1 public class Test { 2 public static void main(string[] args) { 3 Eleve e = new Eleve() ; 4 System.out.println(e) ; 5 Eleve f = new Eleve(7,"Bozo","Clown") ; 6 System.out.println(f) ; 7 } 8 } AJ.C 12 juin 2001 p.31