Java : éléments syntaxiques

Transcription

1 Java : éléments syntaxiques Sylvain Sauvage 1 er avril 2001 Ce polycopié est largement inspiré des polycopiés Éléments de Java et Éléments de C++ de Jacques Madelaine et du document The Java Language Specification de James Gosling, Bill Joy & Guy Steele (disponible en livre et en version html sur le site de Sun Microsystems, Inc.). Ce n est pas un manuel de référence, il s agit juste de fournir au lecteur une petite référence syntaxique sur Java. Pour obtenir un tel manuel, le lecteur pourra se référer aux nombreuses annonces faites sur le site de Sun Microsystems, Inc. Remerciements : Mes remerciements vont donc naturellement à Jacques Madelaine, pour avoir fourni les bases et pour m avoir relu et corrigé. Ils vont aussi aux autres lecteurscorrecteurs : Jean-Marie Le Bars et Vincent Perlerin. Notes typographiques : Les exemples de code Java sont écrits en linéal. Lorsqu il s agit de paragraphes, ils sont marqués par un filet à droite. Les points délicats ou très importants sont signalés par un petit Duke 1 ( ) dans la marge (i.e. à gauche si le texte se trouve dans la colonne de gauche, à droite sinon). Comme l auront remarqué les lecteurs avertis, ce document a été composé avec L A TEX 2ε. Il est d ailleurs aussi disponible en PostScript et en pdf à l adresse suivante : sauvage/java/ 1. Duke est le nom du petit personnage mascotte de Java. Table des matières 1 Éléments lexicaux Types, constantes, variables Expressions Expressions simples & composites Expressions postfixées Opérateurs unaires (expressions préfixés) Création et conversion Opérateurs de multiplication Opérateurs d addition Opérateurs de décalage Opérateurs relationnels Opérateurs d égalité Opérateurs bit-à-bit Opérateurs logiques Opérateur conditionnel ternaire Opérateurs d assignation Résumé Instructions Instruction expression Instruction composée ou bloc Instruction étiquetée Instruction de sélection if Instructions d itération Boucle while Boucle do... while

2 Table des matières Boucle for Instruction de saut Instruction break Instruction continue Instruction return Instruction throw Instruction de sélection switch Instruction de gestion des exceptions Instruction synchronisée Instruction de déclaration Noms et déclarations Paquetages ou paquets (package) Membres d un paquet Stockage Unités de compilation Déclaration de paquet Déclarations d importation Déclarations de types Déclarations de fonctions (méthodes) Classes Notion d objet Membres données ou champs Contrôle d accès aux membres Fonctions membres ou méthodes Constructeurs Destructeurs Fonctions synchronisées Membres constants Membres statiques Classes finales Classes abstraites Interfaces Déclarations d interface Super-interfaces Déclarations des membres Membres données Méthodes Tableaux Variables tableau Accès aux éléments de tableau Un exemple simple Initialisation Membres d un tableau Objets classe pour les tableaux ArrayStoreException Exceptions Les causes des exceptions Vérification des exceptions pendant la compilation Pourquoi les erreurs ne sont pas déclarées Pourquoi les exceptions d exécution ne sont pas déclarées Gestion d une exception Un exemple Un autre exemple La hiérarchie des exceptions Conclusion page 2 sur 26

3 2 Types, constantes, variables 1 Éléments lexicaux Identificateurs Un identificateur est une suite de lettres (minuscules ou majuscules, y compris les lettres accentuées), de chiffres ou du caractère souligné ( ). Il doit commencer par une lettre ou le souligné. Le nombre de caractères est illimité (autant en profiter pour utiliser des noms ayant une signification claire). Mots-clefs Ces mots ne sont pas redéfinissables par le programmeur : abstract boolean break byte case catch char class continue default do double else extends final finally float for if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw Deux autres mots-clefs existent mais ne sont pas (encore) utilisés : goto const throws transient try void volatile while Opérateurs Ce sont des jetons 2 qui désignent des opérations s exécutant sur des arguments de types variés et qui permettent de construire des expressions. Exemples : +, == ou *=. Commentaires Tous les caractères compris entre /* et */ ou entre // et la fin de la ligne sont des commentaires, c est-à-dire qu ils ne sont pas pris en compte dans la compilation. Par contre, ces caractères sont pris en compte et fort appréciés par le lecteur. Si le commentaire commence par /**, il peut alors permettre de générer automatiquement la documentation du code (cf. le programme javadoc). 2 Types, constantes, variables Types primitifs Ce sont les types de données prédéfinis dans toutes les machines virtuelles Java. Ils sont donc identiques sur toutes les machines. Type Taille Description byte 1 octet =128 à 127 short 2 octets = à int 4 octets = à long 8 octets = à float 4 octets 1, e-45 à 3, e+38 double 8 octets 4, e-324 à 1, e+308 char 2 octets caractère Unicode boolean true ou false Constantes littérales Les entiers sont considérés comme des int, à moins qu ils ne soient marqués d un l ou d un L (e.g. 123L). Les flottants sont considérés comme des double, à moins qu ils ne soient marqués d un f ou d un F (e.g. 1.23f, -12.3e-17f). Les expressions telles que 1f/0f ou -1d/0d peuvent servir à représenter + et sans générer d erreur à la compilation (il est toutefois préférable d utiliser les constantes POSITIVE INFINITY et NEGATIVE INFINITY). Les caractères non disponibles directement peuvent être entrés sous forme de séquences d échappement : \n (retour chariot), \" (dans une chaîne de caractères), \011 (tabulation en code octal ascii), \t (tabulation), \u0009 (tabulation en hexadécimal Unicode), etc. Classes Les classes sont des types qui combinent des données et des fonctions qui opèrent sur ces données. Ces classes permettent de constituer des types abstraits de données et également ce qu il est convenu d appeler des objets. Note : les tableaux sont des objets, y compris les tableaux contenant des valeurs d un type primitif (i.e. int[12] est d un type objet, pas d un type primitif). 2. Un jeton est une suite de caractères représentant une seule entité (e.g. un mot : coucou, un symbole : +, une suite de symboles : >= ). Méthodes Les méthodes sont les membres fonctions des classes. Toutes les méthodes doivent être définies, c est-à-dire qu il faut spécifier le type de chaque paramètre ainsi que le type de la valeur renvoyée (void s il n y en a pas). page 3 sur 26

4 3 Expressions Variables Les variables doivent être déclarées avant toute utilisation. Les déclarations des attributs d une classe se font dans le corps de la classe. Pour les variables utilisées localement dans les fonctions, la déclaration peut se faire n importe où. Voici quelques exemples de déclarations : int i ; int j = 0, k, l = 1; Point p = new Point (1, 2); char c, tab [ ] ; char [] tab2; int [ ] [ ] matrice ; int [] matrice2 [ ] ; int tabinit [][] = { {1, 2, null ; Point [] segment = { new Point (0,0), p ; À noter : un tableau de char n est pas une chaîne de caractères (String). Un nom de variable doit être différent d un mot-clef et bien sûr différent du nom d une variable définie au même niveau de portée. La valeur initiale d un attribut est de 0 pour les variables de type primitif arithmétique, false pour les boolean et null pour les variables de type référence (objets). Par contre, une variable doit obligatoirement être fixée explicitement avant toute utilisation ; soit par initialisation (lors de la déclaration de la variable), soit par assignation. Portée d une variable Il y a quatre niveaux de portée pour une variable : donnée membre, variable locale à un bloc, paramètre de méthode et paramètre de gestionnaire d exception. La donnée membre est visible dans la classe, et par les autres classes suivant les modificateurs de portée (public, protected et private). La variable a une portée s étendant de sa déclaration jusqu à la fin du bloc contenant cette déclaration. Le paramètre de méthode a une portée limitée au bloc formant le corps de la méthode. Le paramètre de gestionnaire d exception a une portée limitée au bloc formant le corps de la clause catch correspondant à son type (voir section 4.8 page 11). 3 Expressions Une expression est une suite d opérateurs et d opérandes spécifiant un calcul. L ordre d évaluation des sous-expressions est déterminé par la précédence et le regroupement des opérateurs. Attention, il existe des opérateurs qui ont des effets de bord sur la valeur des opérandes et comme l ordre d évaluation des opérateurs individuels est indéfini, il est fortement recommandé de ne pas avoir plusieurs effets de bord dans une expression. 3.1 Expressions simples & composites Une expression simple ou primaire est constituée d une constante, d une variable, d une expression composite entre parenthèses () ou des mots-clefs this et super. Les expressions composites sont constituées à l aide des opérateurs que l on va regrouper par groupes d égale précédence. Nous ne saurons trop conseiller de parenthéser suffisamment de telles expressions pour qu elles ne soient pas ambiguës à la lecture (même si elles ne sont jamais ambiguës pour le compilateur). 3.2 Expressions postfixées Opérateurs [], (),., ++,. Indexation Pour accéder aux éléments d un tableau, on met l expression représentant l indice entre crochets. Les indices commencent à zéro. Accès à un membre d une classe Cet accès se fait par une expression désignant un objet, suivie d un point (.), suivi du nom du membre (attribut ou méthode) : nom objet. nom membre. Si le membre est une méthode, il sera suivi de la liste de ses arguments (liste entre parenthèses, les éléments sont séparés par des virgules) : nom objet. nom de méthode ( arg1, arg2,...). Pour accéder à un membre statique, on préfèrera utiliser une expression désignant la classe plutôt qu un objet : nom classe. nom membre. La hiérarchie des paquetages (package) qui mène au paquetage auquel appartient l objet (ou la classe) peut être spécifiée dans le nom de l objet (ou de la classe) ; exemple : java.lang.math.sin(12). page 4 sur 26

5 3 Expressions Incrémentation (++) et décrémentation ( ) postfixes L opérande doit avoir une valeur modifiable 3 qui est incrémentée (décrémentée) mais la valeur de cette expression dans l expression qui l utilise est celle de l opérande avant la modification. Exemple : après a = 3; b = 4; c = a++ + b;, a vaut 4, b 4 et c Opérateurs unaires (expressions préfixés) Les expressions avec des opérateurs unaires s associent de droite à gauche (i.e. - a == -( a)). Incrémentation (++) et décrémentation ( ) préfixes Fonctionnent comme leurs pendants postfixes sauf que la valeur de l expression est celle de l opérande après la modification. Exemple : après a = 3; b = 4; c = ++a + b;, a vaut 4, b 4 et c 8. + Le plus unaire (le pendant du moins unaire). - Le moins unaire : change le signe de l expression.! Le non booléen ou logique qui ne s applique qu à des expressions de type boolean ; voir les opérateurs binaires logiques en section 3.11 page suivante. Le non bit-à-bit (prononcé tilde); voir les opérateurs binaires bit-à-bit en section 3.10 page suivante. 3.4 Création et conversion new La création d objet (instanciation) se fait toujours par l intermédiaire de l opérateur new. new Point(1, 2) crée un Point par l intermédiaire du constructeur Point(int, int) ; new int[12] crée un tableau de 12 int. La durée de vie d un objet peut dépasser le bloc dans lequel il a été créé si cet objet est encore accessible par une référence (i.e. une variable la contient encore). Si la machine virtuelle manque de mémoire, elle détruira les objets qui ne sont plus référencés par le mécanisme de ramasse-miettes (garbage collector). 3. On dit que c est une lvalue (pour left-value) car elle peut se trouver à gauche dans une assignation. Transtypage La coercition (cast) permet d exprimer un conversion explicite de type. L expression est alors précédée par un nom de type entre parenthèses : ( nom de type ) expression, exemples : (int) 0.4, (T) a. byte short char int long float double Les transtypages des types numériques primitifs sont automatiques dans le sens des flêches ; si vous prenez le sens inverse, faites attention aux troncatures (perte de données). Pour les expressions dénotant des objets, le transtypage n est possible que si l on reste dans la même branche de la hiérarchie d héritage. 3.5 Opérateurs de multiplication Les opérateurs * pour la multiplication, / pour la division et % pour le reste de la division entière, s associent 4 de gauche à droite (i.e. a*b*c == (a*b)*c). Les opérandes doivent être de type arithmétique. Nous conseillons fortement de n utiliser que des entiers positifs avec %, l opérateur peut fonctionner avec des flottants (i.e. 5.5 % ). 3.6 Opérateurs d addition Les opérateurs + pour l addition et pour la soustraction s associent 4 de gauche à doite et s appliquent à des opérandes de type arithmétique. L opérateur + sert aussi à dénoter la concaténation de chaînes (String). Dans une expression de concaténation de chaînes, toutes les opérandes qui ne sont pas déjà de type String sont d abord transformées en objet (boolean en Boolean, int en Integer, etc.) puis en String par l utilisation de leur méthode tostring(). 3.7 Opérateurs de décalage Ce sont les opérateurs << pour le décalage à gauche, >> pour le décalage à droite signé et >>> pour le décalage à droite non signé. Les opérandes sont de type entier. Les bits de l opérande gauche sont décalés du nombre de rangs représenté par l opérande droit (ce nombre est le modulo de la valeur de l opérande par la division par le nombre total de rangs du type de l opérande gauche, donc, pour un int le nombre de rangs est la valeur de l opérande droit modulo 32). 4. Les opérations ne sont pas toujours associatives, surtout en ce qui concerne les flottants : ε > 0 : 1 + ε = 1 et 1 + 2ε > 1 donc (1 + ε) + ε 1 + (ε + ε). page 5 sur 26

6 3 Expressions << introduit des zéros à droite et correspond à une multiplication par 2 pour chaque rang de décalage n << s correspond à n 2 s. n >> s correspond à n/2 s. n >>> s est équivalent à n >> s si n est positif ; mais correspond à (n >> s) + (2 << s) si n est un int négatif et à (n >> s) + (2L << s) si n est un long négatif. En bref, il vaut mieux réfléchir avant de s en servir. 3.8 Opérateurs relationnels Les opérateurs relationnels permettent d effectuer des comparaisons et renvoient un booléen (boolean) : <, >, >=, <= et instanceof. Les quatre premiers opèrent sur des expressions de type arithmétique ; le dernier vérifie que l opérande gauche est bien du type représenté par l opérande droit : a instanceof Object est toujours vrai (toutes les classes héritent de Object). Attention : a < b < c ne veut rien dire du tout! Il faut utiliser a < b && b < c. 3.9 Opérateurs d égalité Les opérateurs d égalité (qui ne sont pas des assignations, 3.13) expriment les relations égal à (==) et différent de (!=). Note : il existe aussi une méthode equals(object) qui elle représente une relation d équivalence. À ne pas confondre, donc. Note : ne jamais tester l égalité de deux flottants car ils ont toutes les chances d être différents. Donc, ne jamais faire x == 0 mais plutôt x < ε Opérateurs bit-à-bit Il existe trois opérations binaires bit-à-bit, (par ordre de priorité) : le et (&), le ou exclusif (ˆ) et le ou ( ). Ces opérateurs (comme l opérateurs unaire, 3.3 page précédente) traitent chacune de leurs opérandes comme une configuration de bits indépendants ; les opérandes doivent cependant être de type entier ou booléen (dans ce dernier cas, l on préférera les opérateurs logiques, 3.3 page précédente & 3.11). Les tables de ces opérations se comprennent bien si on sait que, par convention, 0 est faux et 1 vrai. & ˆ Opérateurs logiques et logique (&&) L opérateur && est associatif 4 de gauche à droite. Il évalue d abord le premier opérande, si celui-ci vaut false, il n évalue pas le second, sinon le résultat est la valeur du second opérande. ou logique ( ) L opérateur est associociatif 4 de gauche à droite. Comme le &&, il évalue d abord son premier opérande, renvoie true s il est vrai et la valeur du second opérande sinon Opérateur conditionnel ternaire C est le seul opérateur ternaire de Java, sa syntaxe est : <condition>? <expr si vrai > : <expr si faux> La première expression doit être de type booléen. Si elle est évaluée à true, le résultat est la valeur de la deuxième expression, sinon le résultat est la valeur de la troisième expression. Seule une des deux dernières expressions est évaluée (ceci est à savoir si elles contiennent des effets de bord). Ces deux expressions doivent être de même type ou en tout cas transtypables vers un même type Opérateurs d assignation Les opérateurs d assignation demandent tous une lvalue modifiable en opérande gauche ; le type de l expression d assignation est celui de son opérande gauche. Le résultat est la valeur de l opérande gauche après l assignation. Les opérateurs sont associatifs 4 de droite à gauche : a = b = c équivaut à a = (b = c). L assignation simple s écrit avec le signe égal (=). Il existe aussi les assignations suivantes : *=, /=, %=, +=, -=, <<=, >>=, >>>=, &=, ˆ=, =. De façon générale, E 1 θ = E 2 est équivalent à E 1 = E 1 θe 2 excepté que E 1 n est évalué qu une seule fois Ce qui a très peu d importance en Java où, contrairement au C ++, les seules expressions qui renvoient des lvalues sont les identificateurs (noms de variables et d attributs). page 6 sur 26

7 4 Instructions 3.14 Résumé Le tableau suivant donne les opérateurs par niveau de précédence : postfixés []. (params) expr++ expr unaires ++expr expr +expr expr! de création ou de conversion new (type)expr multiplicatif * / % additifs + de décalage << >> >>> relationnels < > <= >= instanceof d égalité ==!= bit à bit et & bit à bit ou exclusif ˆ bit à bit ou inclusif et logique && ou logique ternaire? : d affectation = += = *= /= %= ˆ= &= <<= >>= >>>= 4 Instructions 4.1 Instruction expression Une expression suivi d un point-virgule (;) constitue une instruction. 4.2 Instruction composée ou bloc Une instruction composée ou bloc est une suite d instructions ou de déclarations entre accolades. Elle a donc la forme générale suivante : { <déclaration ou instruction> La définition du corps d une méthode se fait avec un bloc. 4.3 Instruction étiquetée Une instruction étiquetée est une instruction précédée d un identificateur et d un deux-points (:), elle a la forme suivante : <identificateur >: <instruction> Deux instructions étiquetées peuvent porter la même étiquette si et seulement si aucune d entre elles ne contient l autre. toto : for ( int i = 0; i < n; i ++) { //... toto : while ( true ) { //... Est incorrect! Alors que toto : for ( int i = 0; i < n; i ++) { //... toto : while ( true ) { //... est correct. page 7 sur 26

8 4 Instructions L identificateur d étiquette ne cache aucun autre type d identificateur (nom de variable, de paquetage, de fonction, etc.), c est-à-dire que vous pouvez utiliser le nom d une variable locale, d un attribut, d un paquetage, etc., sans aucune ambiguïté pour le compilateur. 4.4 Instruction de sélection if ou L instruction if définit une alternative : if ( < condition> ) <instruction> if ( < condition> ) <instruction > else <instruction> La condition est une expression qui doit s évaluer comme un booléen. Si elle s évalue à true, c est la première instruction qui est exécutée. S il y a un else et que la condition est false, c est la seconde instruction qui est exécutée. Faites attention dans le cas d une cascade de if else : le else est toujours rattaché au if le plus proche (ne pas hésiter à utiliser des accolades). 4.5 Instructions d itération La répétition d actions dans un programme Java se fait : par la récursivité (appel de la fonction dans son corps) ; par les instructions de boucle (while, do... while et for). Nous ne dirons rien de plus sur la récursivité ici, sinon que contrairement à des interprètes comme scheme ou lisp, le compilateur Java ne peut pas éviter des empilements d appels, même en cas de récursivité terminale, ce qui nous fera préférer l itération dans ces cas. Boucle while La forme générale de l instruction while est : while ( <condition> ) <instruction> Tant que la condition est évaluée à true, l instruction constituant le corps de la boucle est exécutée. Le corps de la boucle peut très bien être un bloc. Notez que les parenthèses autour de la condition sont obligatoires. En général, l exécution des instructions composant ce corps de boucle modifie la valeur de la condition, mais on peut aussi faire des répétitions à l infini : while ( true) System. out. println ( Une petite idée de l infini ); Une utilisation plus classique : boolean encore = true ; while ( encore ) { encore = faireuntraitement (); que l on peut simplement écrire en se servant d un corps de boucle constitué de l instruction vide (i.e. le ;) : while (faireuntraitement()); Boucle do... while Cette boucle permet d évaluer le corps de boucle au moins une fois, car la condition d itération est évaluée en fin de corps. Cette forme d instruction est d un emploi rare, car moins générale que le simple while et peut être souvent remplacée avantageusement par ce dernier. do <instruction> while ( <condition> ) Boucle for Ce type de boucles permet d initialiser des indices (initialisation), de tester une condition de continuation, d exécuter un groupe d instructions (corps de la boucle), puis d exécuter une instruction en fin de corps de boucle (incrément). Cela donne la forme générale suivante : for (< i nitialisation >; <condition de continuation>; <incrément>) <corps de boucle> Cette instruction va faire que initialisation est exécutée une fois, 6 ensuite tant que l évaluation de la condition de continuation donne true, le corps de boucle est 6. Notons que cette instruction d initialisation permet de déclarer des variables qui seront locales à l instruction for. page 8 sur 26

9 4 Instructions exécuté ainsi que l instruction incrément. Le for précédent peut s écrire avec un while comme suit : <i n i t i a l i s a t i on >; while (<condition de continuation >) { <corps de boucle> <incrément>; On réservera toujours l emploi du for à une boucle qui est une itération qui incrémente un index d une valeur initiale à une valeur finale. Exemples : // Écrit 100 fois Je relirai le manuel for ( int n = 0; n < 100; n++) System. out. println ( Je r e l i r a i // Calcule n! (factorielle n) int f = 1; for ( int i = 2; i <= n; i++) f *= i ; le manuel ); On préférera l emploi du while vu dans les exemples précédents aux écritures suivantes bien qu elles soient correctes. for ( boolean encore = true ; encore ; ) encore = faireuntraitement (); for ( ; faireuntraitement (); ); Notons que les exemples précédents montrent que l on peut laisser vides un ou plusieurs des initialisation, condition de continuation ou incrément ; une condition de continuation vide s évalue toujours à vrai et permet de faire une boucle infinie, exemple : for (;;) System. out. println ( Une autre idée de l infini ); Lorsque, par exemple, on doit modifier plusieurs variables à chaque tour de boucle, l incrément peut être composé de plusieurs expressions séparées par une virgule (,) ; exemple : for ( int i = 0, j = n 1; i < n; i ++, j ) //... Note : on peut certes définir plusieurs variables, mais elles ont toutes le même type (ici des int). 4.6 Instruction de saut Les instructions de saut déroutent de façon inconditionnelle le flux de contrôle. Il y a quatre instructions de saut : break, continue, return et throw. Instruction break L instruction break non suivie d une étiquette essaie 7 de donner le contrôle à l instruction d itération (section 4.5 page précédente) ou de sélection (section 4.7 page suivante) qui la contient le plus directement (innermost en anglais) pour la terminer, c est-à-dire en sortir. Cette instruction d itération ou de sélection est appelée cible. Si l instruction break est suivie de l identificateur d une instruction étiquetée, la cible est l instruction étiquetée portant cette étiquette (pas besoin ici d être une instruction d itération ou de sélection). S il n y pas d instruction cible, il y a erreur de compilation. L instruction break permet de sortir immédiatement d une boucle ou d un switch. toto : for ( int i = 0; ; i ++) { System. out. println ( Une idée du fini. ); if ( i > 12) break toto ; La boucle s arrêtera dès que i vaudra 13. Instruction continue L instruction continue non suivie d une étiquette essaie 7 de donner le contrôle à l instruction d itération (section 4.5 page précédente) qui la contient le plus directement (innermost en anglais) pour la relancer, c est-à-dire sortir du corps pour commencer une nouvelle itération. Si l instruction continue est suivie de l identificateur d une instruction étiquetée, la cible est l instruction étiquetée portant cette étiquette (pas besoin ici d être une instruction d itération ou de sélection). S il n y pas d instruction cible, il y a erreur de compilation. 7. Le contrôle n est pas donné directement s il y a un bloc try qui englobe l instruction et qui contient une clause finally. page 9 sur 26

10 4 Instructions L instruction continue permet de passer immédiatement à l itération suivante d une boucle. Instruction return L instruction return non suivie d une valeur permet de terminer une fonction dont le type de retour est void. L instruction return suivie d une valeur permet de terminer une fonction dont le type de retour est compatible avec celui de la valeur. Instruction throw L instruction throw permet de lancer une exception qui sera immédiatement attrapée par le premier gestionnaire d exceptions englobant, s il existe (bloc try, section 4.8 page suivante). 4.7 Instruction de sélection switch switch ( < expression > ) <instruction> Cette instruction réalise un aiguillage de contrôle directement à un groupe d instructions désigné par la valeur que prend l expression. Cette expression doit être de type convertissable en int : int, byte, short, char. 8 Toute instruction à l intérieur du bloc peut être étiquetée avec une constante de choix convertissable en int comme suit : case <expression constante>: Il peut 9 y avoir un cas par défaut défini par l étiquette : default : Quand une instruction switch est exécutée, son expression est évaluée puis comparée à chaque constante de choix. S il y a égalité, le contrôle est transféré à l instruction étiquetée correspondante. Si aucune constante de choix n est égale à la valeur de l expression et s il existe une étiquette default, le contrôle y est transféré, sinon aucune instruction du switch n est exécutée et le contrôle passe à l instruction qui suit le switch. 8. Le type de l expression de sélection ne peut donc pas être long, encore moins float ou double, et surtout pas String. 9. Nous conseillons fortement de toujours en mettre un! En fait, il faut bien comprendre que, une fois compilé, il n y a pas comparaison successive de la valeur de l expression du switch à chacune des étiquettes (comme dans une cascade de if ou comme avec un cond en lisp), mais il y a utilisation d une instruction de base du processeur (de la machine virtuelle Java) pour réaliser le branchement direct à la bonne instruction. L ordre des étiquettes case et default n est donc pas aussi significatif (que les conditions d une cascade de if ou d un cond) mais elles n altèrent pas en elles-mêmes le flux de contrôle qui continue à travers ces étiquettes. Il faut utiliser explicitement des break (section 4.6 page précédente) pour rompre ce flux. Exemple : class Couleur { // ce sont des constantes, donc non modifiables public static final int BLEU = o ; public static final int BLANC = e ; public static final int NOIR = a ; //... void f () { int i ; //... switch ( i ) { case BLEU: System. out. println ( bleu ); break ; case BLANC: System.out. println ( blanc ); break ; case ROUGE: //... //... On peut aussi profiter du fait que le flot n est pas interrompu par un case, mais cela peut devenir difficile à lire : switch ( animal ) { default : // Je ne sais rien System. out. print (?? ); break ; case POULE: case VEAU: // Poule et veau sont à viande blanche System. out. print ( à viande blanche ); break ; case VACHE: page 10 sur 26

11 4 Instructions case MOUTON: // Vache et mouton sont des bêtes à cornes System. out. print ( bêtes à cornes ); /* pas de break! */ case CHEVAL: // ils sont à viande rouge System. out. print ( à viande rouge ); Nous vous conseillons fortement d indiquer par un commentaire que l absence de break n est pas une erreur (comme dans l exemple ci-dessus). 4.8 Instruction de gestion des exceptions Le bloc try a la syntaxe suivante : 4.10 Instruction de déclaration En Java, on a le droit de mettre des déclarations de variable un peu n importe où. On préférera néanmoins mettre des déclarations à des débuts de blocs pour des variables utilisées dans tout le bloc, ou juste avant la première expression où elle apparaît, si elle n apparaît que très peu dans le bloc. On n omettra pas d agrémenter cette déclaration par un commentaire qui décrit la signification et l utilisation de cette nouvelle variable, sauf si son nom a été choisi de façon suffisamment explicite. Si une variable est déclarée dans un bloc, elle est locale à ce bloc et pourra être utilisée après son point de déclaration dans ce bloc et dans ses blocs imbriqués. Aucun nom ne peut être déclaré en dehors de tout bloc et de toute classe. try { <instructions> catch ( <type1> <nom variable > ) { <instructions> catch ( <type2> <nom variable > ) { <instructions> //... finally { <instructions> Le nombre de clauses catch est illimité, s il n y en a pas, il faut forcément une clause finally qui, sinon, est optionnelle. Si les instructions de la clause try terminent normalement, les instructions de la clause finally sont exécutées, si cette clause est présente. Si une des instructions de la clause try termine abruptement à cause d une valeur V lancée par un throw (section 4.6 page 9), alors les instructions de la première 10 clause catch dont le type est compatible avec celui de V sont exécutées, puis ce sont celles de la clause finally qui le sont (si cette clause est présente). Donc, dans tous les cas, les instructions de la clause finally sont exécutées. 4.9 Instruction synchronisée synchronized ( < expression > ) <bloc> L instruction synchronized acquiert un cadenas d exclusion mutuelle sur l objet désigné par l expression (qui doit donc être d un type objet, pas d un type primitif), exécute le bloc puis relache le cadenas. 10. Par ordre d apparence. page 11 sur 26

12 5 Noms et déclarations 5 Noms et déclarations Les noms sont des identificateurs qui permettent de désigner une entité (i.e. une variable, un type, une méthode, un paquetage, etc.). 5.1 Paquetages ou paquets (package) Les programmes Java sont organisés en paquets. Chaque paquet possède son propre ensemble de noms pour les types ; ceci évite les conflits de noms. Un type est accessible en dehors du paquet qui le déclare si et seulement s il est déclaré public. Pour les petits programmes, le paquet peut être anonyme ou avoir un nom simple mais pour une distribution plus large, les noms de paquets doivent être choisis uniques. Membres d un paquet Les paquets ont une structure hiérarchique. Leurs membres sont des classes, des interfaces et des sous-paquets. Les membres d un paquet ont accès à tous les types du paquet. Un même nom ne peut être utilisé pour un type et un souspaquet. La structure hiérarchique est juste une facilité d organisation, elle n a aucun sens pour le langage Java lui-même. Que votre paquet averell soit ou non un sous-paquet de votre paquet dalton, l accès aux membres sera le même (i.e. les classes de averell ne seront pas plus accessibles depuis le paquet dalton que depuis n importe quel autre paquet). Stockage S ils sont stockés dans un système de fichiers, les paquets sont des répertoires qui respectent les noms et la hiérarchie ; et les unités de compilation (cf. colonne suivante) sont des fichiers. Les caractères Unicode non autorisés par le système de fichiers mais permis par Java 11 seront notés sous une forme spéciale (échappement Note : rien n est spécifié quant à la longueur des noms. Java ne limite pas la longueur des identificateurs mais les systèmes de fichiers eux le font. De la 11. Rappel : tous les caractères Unicode sont utilisable dans Java. même façon, la casse 12 est importante en Java mais pas sur tous les systèmes de fichiers. 13 Les paquets peuvent aussi être stockés dans des bases de données (nous n avons pas connaissance d exemple, les fichiers jar forment un système de fichiers archivé). Unités de compilation En pratique, une unité de compilation Java correspond à un fichier. Les types déclarés dans différentes unités de compilation peuvent dépendre les uns des autres, circulairement. C est au compilateur de s arranger pour les compiler en même temps. Donc, contrairement au C ++, une classe peut déclarer un attribut de son type, exemple : classe Nœud { Nœud suivant ; //... Une unité de compilation consiste en trois parties, chacune étant optionnelle : une déclaration de paquet, qui indique à quel paquet l unité appartient ; des déclarations d importation, qui permettent d utiliser des types d un autre paquet sans avoir à donner leur nom complet (i.e. MaClasse à la place de mon.paquet.maclasse) ; des déclarations de types : classes ou interfaces. Toutes les unités de compilation importent automatiquement tous les types du paquet java.lang. Déclaration de paquet La déclaration est de la forme : package mon. paquet. à moi; Le nom utilisé doit être complet (i.e. inclure tous les super-paquets). Si l unité de compilation n a pas de déclaration de paquet, elle appartient à un paquet anonyme ; en général, il n y en a qu un seul par répertoire, c est-à-dire que toutes les unités de compilation (fichiers) d un même répertoire et qui ne déclarent pas de paquet sont dans le même paquet anonyme. 12. Différence minuscule majuscule. 13. Notamment la famille fat. page 12 sur 26

13 5 Noms et déclarations Les noms de paquets ne cachent jamais d autres noms (i.e. vous pouvez avoir des variables dont le nom est celui d un paquet). Par convention il sont formés sur le modèle des noms de domaine de l internet 14 mais écrits dans l ordre inverse, exemples : gnu. regexp org. apache. cocoon. interpreter org. xml. sax org.omg.corba. portable com. sun. image. codec. jpeg com. jclark. xsl // exceptions, réservées à Sun java. lang java. awt. event javax. servlet. http Déclarations d importation Ces déclarations permettent d utiliser un type d un autre paquet en s y référant par son nom simple plutôt que par son nom qualifié (i.e. String au lieu de java.lang.string). Il y a deux formes possibles : 5.2 Déclarations de fonctions (méthodes) Une fonction en Java possède une signature qui l identifie en plus de son nom. On peut ainsi définir plusieurs fonctions de même nom mais de signatures différentes, c est-à-dire avec des arguments de types différents ou en nombre différent ; c est ce que l on appelle la surcharge de fonction. La bonne fonction est appelée en fonction du nombre et du type de chacun des paramètres réels de l appel. Exemple : double max ( double a, double b) { return a > b? a : b; int max ( int a, int b) { return a > b? a : b; int max ( int a, int b, int c) { return max(a, max(b, c )); Les arguments des fonctions sont passés par valeur, c est-à-dire que les valeurs des arguments dans la fonction appelante ne sont pas changées au retour de l appel. import nom. de. paquet. NomClasse; // un seul type import nom. de. paquet.*; // tous les types (pas les sous-paquets) Seuls les types déclarés public sont importables. On ne peut pas importer deux types de paquets différents mais de même nom : import mes. classes. Vector ; import java. util. Vector ; class AutreClasse { Vector v ; // laquelle utiliser?! //... Déclarations de types Ce sont les déclarations de classes et d interfaces (cf. sections 6 page suivante, même page, et 7 page 19). 14. Cf. ftp://rs.internic.net/rfc, les rfc rfc920 & rfc1032. page 13 sur 26

14 6 Classes 6 Classes Une déclaration de classe avec le mot-clef class permet d introduire un nouveau type. Ce type définit un agrégat de ses membres données (ou champs) analogue au struct en C, au record en Pascal ou au defstruct en Scheme. L originalité des classes Java 15 est de permettre de définir des fonctions membres (ou méthodes) qui permettent de manipuler cette structure de données et ainsi de pouvoir définir des objets. On parlera donc indifféremment d instance de classe ou d objet. 6.1 Notion d objet Grady Booch défini un objet comme ayant un état, un comportement et une identité ; la structure et le comportement d objets similaires sont définis dans leur classe commune. 16 L état sera représenté par les membres données de l objet. Exemple : les deux coordonnées pour un point du plan ; le nom, les prénoms, la date de naissance, les diplômes obtenus et le diplôme en cours de préparation d un étudiant. Le comportement regroupe toutes les compétences d un objet et décrit les actions et les réactions de cet objet. Il sera représenté par les fonctions membres ou méthodes. L identité caractérise l existence propre d un objet et permet de différencier deux instances d objet ayant même comportement et même état. Le concept d identité reste indépendant du concept d état et il ne faut pas confondre le concept d identité avec celui de nom, de numéro d identification ou de clef que l état de l objet conserverait. Nous réaliserons ceci dans nos programmes Java grâce à des identificateurs de variables. Nous nous efforcerons de respecter le principe d encapsulation selon lequel l état d un objet est caché à l observateur extérieur. Bien sûr, ce n est pas parce que l état interne d un objet est caché que celui ci ne peut pas changer. On peut appliquer une translation à un point, et il arrive que certains étudiants passent avec succès leur diplôme ;o). Cela sera seulement par l intermédiaire du comportement de l objet que son état changera : translation de vecteur donné pour un point, succès au diplôme préparé par l étudiant. 15. Comme celles de C ++ d ailleurs. 16. Il existe d autres caractéristiques d un objet qui ne sont pas directement accessibles en Java : la persistance des objets au delà de la durée de l exécution du programme ou la gestion d objets miroirs. 6.2 Membres données ou champs Une instance de classe est composée de l agrégat de ses champs. La déclaration du type se fait simplement en donnant la liste entre accolades des noms des champs avec leur type. Notons que le point-virgule (;) final obligatoire en C ++ est seulement toléré en Java (pour les indécrottables de C ++ ). Exemple de classes : class Point { double x, y; class Pixel { int x, y; int couleur ; Une déclaration de classe peut être imbriquée dans une autre classe, ou locale à une fonction. Une classe déclarée dans une fonction ne pourra être accessible que dans cette fonction. Une classe déclarée dans une autre classe sera visible de l extérieur selon les règles ordinaires du contrôle d accès aux membres décrits dans la section suivante. Il est aussi possible d utiliser des classes anonymes. Il existe deux membres données définis et accessibles dans toute classe Java : this et super. this this est un champ pointant sur l objet lui même. L on s en sert comme d une variable sur l objet. Il est à noter que this n a de sens que dans des méthodes non statiques. Il permet surtout de désambiguïser les noms de variable ou pour noter la symétrie de rôles. Exemples : class Point { private double x, y; public void bouge(double x, double y) { x = x ; // c est le paramètre qui est modifié! this. y = y ; // c est bien le champ qui est modifié public boolean equals ( Object autre ) { Point otre = (Point ) autre ; return this == otre ( otre!= null && (this. x == otre. x && this. y == otre. y ) ); page 14 sur 26

15 6 Classes Bien entendu, n ayant pas de sens que dans la classe elle-même, ces deux attributs sont privés et constants. super De la même façon que this, le mot-clef super permet d accéder à l objet courant mais cette fois-ci en tant qu instance de la classe mère. Il permet donc le plus souvent d accéder à un membre caché : class Mère { protected int membre; class Fille extends Mère { protected double membre; public void f () { membre = 2; // le double this.membre = 3; // toujours le double super.membre = 4; // l int de Mère 6.3 Contrôle d accès aux membres Java possède quatre niveaux de visibilité 17 : private : le champ n est visible que de la classe : tous les objets de cette classe peuvent accéder au champ pour n importe quel autre objet de la classe (par exemple, dans une méthode de la classe Point, si P est un Point, on peut utiliser directement P.x, alors qu ailleurs il faudra utiliser P.getX()) ; protected : le champ n est visible que de la classe et de ses sous-classes ; rien : le champ est visible dans le paquetage ; public : le champ est visible de toutes les classes. La visibilité n a de sens qu entre classes ; un objet a accès à tous les champs d une autre instance de la même classe (il est fait comme lui!). Il est fortement conseillé de mettre tous les champs privés par défaut, surtout les attributs, et de ne rendre publiques que les méthodes qui ont vraiment besoin de l être. Note : contrairement au C ++ qui utilise des étiquettes, en Java ce sont des 17. Le C ++ n en possède que trois : le niveau paquetage est absent. modificateurs, il faut les répéter pour chaque membre. On utilise la notation pointée pour accéder aux membres (opérateur., voir section 3.2 page 4). Exemples : class Point { private double x, y; Point p; p. x ; // Illégal : accès à un champ privé class PointNonProtégé { public double x, y; PointNonProtégé pp; pp. x ; // Ok, x est public 6.4 Fonctions membres ou méthodes Les fonctions membres ont accès à tous les membres de l objet (y compris les privés). En Java, il faut définir le corps d une fonction membre en même temps que sa déclaration. 18, 19 Dans l exemple qui suit, seules les méthodes membres sont dans la partie publique : class Point { private double x, y; public void translation (double vx, double vy) { x += vx; y += vy; public void rotation ( Point centre, double angle ) { /*... */ Si une classe définit une méthode déjà définie dans une de ses classes mères, en utilisant la même signature (mêmes nombre et types d arguments), il y a redéfinition de la méthode, c est-à-dire que la nouvelle remplace celle de la classe 18. En C ++, déclaration et définition sont séparables. 19. Sauf pour les fonctions abstraites, cf. section 6.8 page 18 et le fonctions natives (cf. jni). page 15 sur 26

16 6 Classes mère. Cette redéfinition est impossible pour les méthodes statiques ou finales (cf. sections 6.6 page suivante et 6.5 page suivante). Le type de retour des deux fonctions doit être le même et la méthode de la classe fille doit déclarer être susceptible de lancer comme exceptions un sous-ensemble de ce que la méthode mère déclare (i.e. moins de types possibles et/ou des sous-types). La section suivante décrit un type particulier de méthodes, les constructeurs. 20 Constructeurs Contrairement au C ++, en Java, un constructeur n est pas un membre de la classe (le constructeur Java ne s utilise quavec le mot-clef new). Les constructeurs servent à construire des valeurs du type de sa classe (i.e. des instances de sa classe). Les constructeurs sont définis comme des méthodes à la différence que leur nom est celui de la classe et qu ils n ont pas de type de retour. La seule et unique façon d utiliser un constructeur en Java est de passer par l opérateur new. Il peut y avoir plusieurs constructeurs pour un même type. Si aucun constructeur n est défini par le programmeur, le compilateur en génère un par défaut, qui ne prend pas d arguments et qui attribue des valeurs par défaut aux attributs de l objet : zéro pour les types arithmétiques (0 pour les int, 0L pour les long, 0f pour les float, 0d pour les double, et \0 pour les char) ; false pour les boolean ; null pour les objets (variables de type référence). this() Pour utiliser un autre constructeur de la même classe dans un constructeur, on utilise le fonction spéciale this : class Point { private double x, y; public Point(double x, double y) { this. x = x; this. y = y; public Point () { this ( 0, 0); // appèle le constructeur précédent 20. En Java, il n y a pas de destructeur ; il n y a pas non plus la possiblité de redéfinir les opérateurs. super() De la même façon que pour les variables this et super, il existe la fonction spéciale super() qui permet d utiliser, pour initialiser un objet, un constructeur de la classe mère. class PointColoré extends Point { private int couleur ; public PointColoré (double x, double y, int col ) { super(x, y ); // x, this.x ou super.x 21 sont inaccessibles! couleur = col ; Attention : L appel de this() ou de super() doit être la première instruction du constructeur. Si vous ne faites pas explicitement appel à this() ou à super(), le compilateur ajoute de lui même l appel à super(), sans paramètres, il doit donc exister un constructeur sans paramètres dans la classe mère. Vous pouvez appeler soit this(), soit super(), pas les deux. Destructeurs Il n y a pas de destructeur en Java! La seule méthode qui pourrait à première vue sembler servir de destructeur est la méthode void finalize(), qui est appelée quand le ramasse-miettes (garbage collector) détruit réellement l objet en mémoire pour récupérer son espace mémoire. Mais cette destruction n est pas assurée, par aucune machine virtuelle : votre programme Java peut arriver à son terme sans avoir eu besoin de récupérer l emplacement mémoire utilisé par l objet. En fait, finalize() ne sert à rien! À moins d appeler vous-même le ramassemiettes! Note : pour être sûr que du code soit exécuté, utilisez un bloc try et mettez ce code dans la clause finally (cf. section 4.8 page 11). Fonctions synchronisées Le modificateur synchronized s applique aux méthodes, il permet de spécifier que tout le bloc de la méthode est une instruction synchronisée (cf. section 4.9 page 11). 21. Qui correspondraient au même objet. page 16 sur 26

17 6 Classes synchronized void f () { /*... */ est l exact équivalent de : void f () { synchronized ( this ) { /*... */ Si la méthode est statique, le cadenas n agit plus sur this (qui n a pas de sens), mais sur l objet représentant la classe (cf. réflexivité). Ces cadenas permettent de réaliser des moniteurs ( cf. multi-threading). Pour définir une valeur constante partagée par toutes les instances de la classe, il faudra utiliser un membre statique (cf. section suivante). Les fonctions membres constantes sont des fonctions que les classes filles ne peuvent surcharger. Attention : les membres constants de type référence (les objets donc) ne sont pas constants dans le même sens que le C ++, seul l objet est déclaré constant, pas ses attributs, exemple : final Point ORIGINE = new Point ( 0, 0); //... ORIGINE = new Point (1, 2); // Erreur à la compilation! ORIGINE. translate ( 3, 4); // fonctionne! if (ORIGINE. getx() == 3) // c est vrai! // Membres constants Les données et fonctions membres peuvent être déclarés final. Les données membres constantes seront représentées dans chaque instance, et pourront avoir des valeurs différentes d une instance à l autre, mais leur valeur ne pourra pas être modifiée. L initialisation d une donnée membre doit se faire, une fois et une seule : soit dans la déclaration du membre ; soit dans tous les constructeurs de la classe (attention aux appels de this() qui peuvent déjà initialiser la constante). Exemple : la couleur des yeux d une personne ne change pas : class Personne { private String nom, prenom; private final CouleurYeux yeux; Personne( String n, String p, CouleurYeux c) { nom = n; prenom = p; yeux = c; //... Personne p = new Personne( Madelaine, Jacques, CouleurYeux.MARRON); 6.6 Membres statiques Les membres données statiques permettent de réaliser en Java ce que l on appelle en Smalltalk des variables de classes, c est-à-dire qu il n y a qu une seule instance de ces données, quel que soit le nombre d instances de la classe. L exemple suivant utilise le membre statique nbconstruits pour compter les instanciations de T : class T { // simple déclaration d une donnée membre statique static private int nbconstruits = 0; // contient le nombre d instanciations TypeDonnéesMembreT donnéemembre; public T() { donnéemembre = new TypeDonnéesMembreT(0); ++nbconstruits ; T unt = new T(), deuxt = new T(); L exemple précédent déclare donc le type T, initialise la donnée membre statique, puis définit deux instances de T. Le constructeur permet d initialiser les attributs de chaque nouvelle instance. Il faut bien comprendre que dans cet exemple, chaque instance de T aura une donnéemembre et que l entier nbconstruits n existe qu en un seul exemplaire ; la figure 1 page suivante tente de schématiser cette page 17 sur 26

18 6 Classes situation. Notons aussi que pour compter vraiment les instanciations du type T, il faudra ajouter l instruction ++nbconstruits; à tous les constructeurs de T. Note : on ne peut pas compter le nombre d instances de la classe T à un instant donné car, en Java, il n y a pas de destructeur qui permettrait de décrémenter le compte des instances lorsque l une d entre elles est détruite. T.nbConstruits unt donnéemembre deuxt donnéemembre Fig.1 Deux instances d une classe et une donnée membre statique Notons que les données membres statiques peuvent être constantes. Les membres données statiques sont accessibles aux méthodes invoquées sur des instances, mais on peut également utiliser des fonctions membres statiques qui diffèrent des méthodes ordinaires par le fait qu elle n ont pas d objet receveur, c est-à-dire que this n a aucun sens dans le corps d une méthode statique (cf. section 6.2 page 14). Si l initialisation d un membre statique demande plusieurs lignes de code (des variables temporaires, etc.) on peut utiliser un bloc static : class T { static private final double [] COS; static { COS = new double[360]; for ( int angle = 0; angle < 360; angle++) { double rad = angle / 180d * Math. PI; COS[ angle ] = Math. cos(rad ); 6.7 Classes finales Essayer d écrire une classe héritant d une classe finale provoque une erreur à la compilation. 6.8 Classes abstraites La déclaration d une méthode abstraite introduit la méthode comme étant un membre de la classe, cette déclaration fournit aussi la signature de la méthode (nom, nombre et types des paramètres), le type de retour et les types des exceptions qu elle est susceptible de lancer (throws), mais elle ne fournit pas d implantation de cette méthode. Cette déclaration doit apparaître dans une classe abstraite A (qui porte ellemême le modificateur abstract). Toutes les sous-classes de A qui ne sont pas abstraites doivent fournir une implantation pour la méthode déclarée abstraite dans A. De ce fait, une méthode déclarée privée (private) ne peut être aussi déclarée abstraite (abstract) car une méthode privée ne peut être surchargée dans les sousclasses (elle est totalement inaccessible des sous-classes). Les méthodes déclarées statiques (static) ou finales (final) ne peuvent non plus être abstraites (elles ne sont pas redéfinissables par les sous-classes). Une méthode abstraite peut être surchargée par une méthode abstraite ; cela permet d ajouter des commentaires (/**... */) ou de réduire les types d exception susceptibles d être lancées (clause throws). Une méthode d instance (i.e. non statique) qui n est pas abstraite peut être surchargée par une méthode abstraite. abstract class Point { private double x, y; public abstract String tostring (); Cette déclaration surcharge la déclaration de la méthode non abstraite tostring() de la class Object. class ColoredPoint extends Point { private int color ; Le modificateur final peut aussi être appliqué à une classe. Il signifie alors que l on ne peut en hériter (de nombreuses classes de l api 22 sont déclarées finales). 22. Les bibliothèques standard Java. public String tostring () { return super. tostring () + : + color ; // erreur page 18 sur 26

19 7 Interfaces Le code précédent provoque un erreur car super.tostring() fait appel à la méthode abstraite tostring() de la classe Point, qui ne peut être invoquée. Il faut écrire : abstract class Point { private double x, y; public abstract String tostring (); protected String objstring () { return super. tostring (); class ColoredPoint extends Point { private int color ; public String tostring () { return objstring () + : + color ; // correct 7 Interfaces Une déclaration d interface introduit un nouveau type référence (i.e. objet, ou non primitif) dont les membres sont des constantes et des méthodes abstraites. Ce type n a pas d implantation mais des classes peuvent l implanter en fournissant une implantation pour ses méthodes abstraites. L existence de deux formes de types références, les classes et les interfaces, permet au programmeur de différencier les types structurels (les classes) des types comportementaux ou promesses de services (les interfaces). Une classe peut être déclarée comme implantant une ou plusieurs interfaces, chacune de ses instances implante alors toutes les méthodes abstraites spécifiées par les interfaces. Une classe implante nécessairement toutes les interfaces que ses super-classes et super-interfaces directes implantent. Cet héritage (multiple) d interface permet aux objets de supporter des comportements communs (multiples) sans partager aucune implantation. class PointColoré extends Point implements Colors { /*... */ Une variable dont le type déclaré est une interface peut avoir comme valeur une référence à n importe quel objet qui est une instance d une classe déclarée comme implantant l interface spécifiée. Il ne suffit pas que la classe implante toutes les méthodes abstraites de l interface ; la classe ou une de ses super-classes doit réellement être déclarée comme implantant cette interface, sinon la classe n est pas considérée comme implantant l interface. interface Collection { /*... */ interface List extends Collection { /*... */ class LinkedList implements List { /*... */ class ArrayList implements List { /*... */ Collection lst = new LinkedList (); // correct lst = new ArrayList (); // correct aussi 7.1 Déclarations d interface Une déclaration d interface spécifie un nouveau type référence : interface MesServices { void leservice (); page 19 sur 26

20 7 Interfaces Le nom de l interface ne doit pas être le même que celui d une classe ou d une interface du même paquet, ou celui d une classe ou d une interface importée explicitement (i.e. pas par un import mon.paquet.*;). Modificateurs Une déclaration d interface peut être précédée par les modificateurs public et abstract. 23 Super-interfaces Grâce au mot-clef extends, une interface peut être déclarée comme étendant d autres interfaces et ainsi hériter des méthodes et constantes de chacune de ces interfaces. Ces autres interfaces sont les super-interfaces directes de l interface que l on déclare. Toute classe implantant l interface est aussi considérée comme implantant toutes les interfaces que celle-ci étend et qui sont accessibles à la classe. interface ServicesSupplémentaires extends Services { /*... */ Une interface ne peut s étendre elle-même (pas de cycle dans le graphe d héritage). La hiérarchie des interfaces n a pas de racine unique comme c est le cas pour les classes avec la classe Object. 7.2 Déclarations des membres Les membres sont déclarés de la même façon que pour une classe, excepté que les attributs sont tous public static final, et les méthodes public abstract. 24 Une interface hérite des interfaces qu elle étend tous les membres de ces interfaces, sauf les attributs qu elle cache et les méthodes qu elle redéfinit. Membres données Tous les membres données d une interface doivent être initialisés. Cette initialisation n est pas forcément une expression constante (i.e. cela peut être le résultat d une fonction, etc.) mais elle doit être calculable à l instanciation de 23. Ce dernier étant inutile car les interfaces sont toujours abstraites, il est d ailleurs obsolète. 24. Il est inutile de les répéter ; essayer d en mettre d autres provoque une erreur à la compilation. l objet implantant l interface. On peut utiliser la valeur d un autre champ de la même interface s il est déclaré avant. interface Test { float f = j ; int j = 1; int k = k+1; provoque une erreur car la valeur de j est utilisée dans l initialisation de f avant que j ne soit déclaré et aussi parce que l initialisation de k fait référence à k lui-même. interface BaseColors { int RED = 1, GREEN = 2, BLUE = 4; interface RainbowColors extends BaseColors { int YELLOW = 3, ORANGE = 5, INDIGO = 6, VIOLET = 7; interface PrintColors extends BaseColors { int YELLOW = 8, CYAN = 16, MAGENTA = 32; interface LotsOfColors extends RainbowColors, PrintColors { int FUCHSIA = 17, VERMILION = 43, CHARTREUSE = RED+90; L interface LotsOfColors hérite de deux champs nommés YELLOW. Tout se passe bien si aucune référence à ce champ par son simple nom n est faite (i.e. sans le faire précéder du nom de l interface). Même si la valeur des deux champs YELLOW était la même, il y aurait toujours une ambiguïté. Les champs hérités par plusieurs chemins (comme RED) ne sont en fait hérités qu une seule fois, donc leur utilisation n est pas ambiguë (comme pour CHAR- TREUSE). Note : vous remarquerez l usage des majuscules pour dénoter le fait que ces champs sont constants. Nous vous encourageons à suivre cet usage typographique qui remonte au C lui-même. Méthodes Une méthode d une interface ne peut être déclarée statique car elle est forcément abstraite et aucune méthode statique ne peut être abstraite (puisqu on ne peut en hériter). page 20 sur 26