Informatique / Programmation

Transcription

1 Java / Introduction Caractéristiques principales Informatique / Programmation Orientation Objet (C++) -- Sécurité intégrée Portabilité Programmation orientée objet avec Java 01 : Introduction / Éléments de base C o m p l é m e n t Robustesse (typage fort, gestion de la mémoire,...) Richesse des librairies de classes (plate-forme Java) Multitâche intégré au langage (Multithreading) Bonne intégration des communications réseau (Sockets, RMI, ) Jacques Bapst Évolutivité (SDK 1.0, 1.1, 1.2, 1.3, 1.4, 5.0, 6.0, 7.0, 8.0, ) [email protected] Java JavaScript C# est fortement inspiré de Java EIA-FR / Jacques Bapst PR1_01 3 Java / Introduction Java / Introduction Bref historique du langage Java Mode de déploiement [1] Le langage Java a été conçu au sein de l'entreprise Sun Microsystems (par une équipe dirigée par James Gosling). Application Se comporte comme une application native Initialement baptisé Oak (chêne), il a été officiellement lancé en 1995 sous le nom Java Lancement par une ligne de commande (lanceur natif) Nécessite la disponibilité d'une machine virtuelle Java (JVM, JRE) C o m p l é m e n t Java est synonyme de "café" en argot américain Le langage a été popularisé par : Sa portabilité (indépendance des plates-formes) Le slogan "Write Once Run Anywhere" Une syntaxe de base très proche de C/C++ Une orientation Web native Des éléments de sécurité intégrés La gratuité de son kit de développement (JDK) Son adoption dans la formation (écoles, universités) Son nom? C o m p l é m e n t Peut accéder (par défaut) aux ressources locales (fichiers, réseau, périphériques,...) Applet Lancement intégré dans des pages HTML S'exécute à l'intérieur du navigateur (IE, Firefox,...) Utilise la machine virtuelle Java du navigateur (attention aux versions de la machine virtuelle) Ne peut pas accéder (par défaut) aux ressources locales (notion de Sandbox) fi Sécurité Pratiquement plus utilisé (remplacé par Flash, HTML5, ) EIA-FR / Jacques Bapst PR1_01 2 EIA-FR / Jacques Bapst PR1_01 4

2 Java / Introduction Modes de déploiement [2] Java / Introduction Premier programme Java Applet Navigateur Un premier programme (très poli) enregistré dans le fichier "Bonjour.java" : Applet JVM Nom de la classe : il doit correspondre au nom du fichier source (sans l'extension) C o m p l é m e n t Page HTML Machine cible Java Web Start Application déployée et mise à jour par le Web Mise en mémoire cache locale (lancement plus rapide) L'application peut être lancée depuis une page HTML ou comme une application locale Technologie destinée à remplacer les Applets (mais assez peu utilisée) // // Un premier programme Java // public class Bonjour { public static void main(string[] args) { System.out.println("Bonjour à tous!"); Point d'entrée du programme EIA-FR / Jacques Bapst PR1_01 5 EIA-FR / Jacques Bapst PR1_01 7 Java / Introduction Différences par rapport à C/C++ Java / Introduction Compilation et Interprétation Syntaxe simplifiée (élimination des redondances C/C++) Tailles définies pour les types primitifs Compilation Interprétation Garbage Collector (ramasse-miettes) Java VM Éléments supprimés : Linux C o m p l é m e n t Pré processeur / #define / #include / typedef Fichiers header (.h) Structures / Unions Fonctions et variables globales Héritage multiple Pointeurs Surcharge des opérateurs Instruction goto Certains transtypages (casting) automatiques Source Compilateur Bytecode P1.java javac P1.java P1.class On utilise un éditeur pour créer et modifier les fichiers sources Interpréteur java P1 Dans un environnement de développement intégré (IDE) les commandes sont disponibles sous forme de menus et barres d'outils Java VM Windows Java VM Machines virtuelles (JVM/JRE) EIA-FR / Jacques Bapst PR1_01 6 EIA-FR / Jacques Bapst PR1_01 8

3 Java / Eléments de base Java / Eléments de base Commentaires Identificateurs Trois formes de commentaires : // Texte Commence dès // et se termine à la fin de la ligne Sur une seule ligne A utiliser de préférence pour les commentaires généraux /* Texte */ Le texte entre /* et */ est ignoré par le compilateur Peuvent s'étendre sur plusieurs lignes Ne peuvent pas être imbriqués Peuvent être utiles pour inactiver (temporairement) une zone de code /** Texte */ Commentaire de documentation (comme /* */ mais avec fonction spéciale) Interprétés par l'utilitaire javadoc pour créer une documentation au format HTML Peuvent contenir des balises de documentation ) Peuvent contenir des balises HTML (Tags) Les identificateurs sont des noms symboliques permettant de référencer les éléments des programmes Java (variables, fonctions,...). Règles pour les identificateurs : Doivent commencer par une lettre ou un souligné (ou, à éviter, un caractère monétaire) Suivi (éventuellement) d'un nombre quelconque de lettres, chiffres ou soulignés (ou, à éviter, de caractères monétaires) Distinction entre les majuscules et les minuscules (éviter de créer des identificateurs qui ne se distinguent que par la casse) Utilisent le jeu de caractères Unicode (16 bits) Selon les plates-formes, les caractères alphabétiques spéciaux (par exemple les caractères accentués, les lettres grecques, ) peuvent encore poser des problèmes => A éviter Les mots réservés du langage sont exclus (voir liste à la page suivante) EIA-FR / Jacques Bapst PR1_01 9 EIA-FR / Jacques Bapst PR1_01 11 Java / Eléments de base Exemples de commentaires /** * Somme : Calcule une somme * Marc Duchemin */ public class Somme { /* Programme principal */ public static void main(string[] params) { //--- Initialisation des variables int a = 1; int b = 2; int total; // Totalisateur total = a + b; //--- Affichage du résultat de l'addition System.out.println("Résultat = " + total); EIA-FR / Jacques Bapst PR1_01 10 Java / Eléments de base Mots réservés (Keywords) Mots réservés du langage Java (mots-clé) : abstract default goto 1) package synchronized assert 3) do if private this boolean double implements protected throw break else import public throws byte enum 4) instanceof return transient case extends int short true 2) catch false 2) interface static try char final long strictfp void class finally native super volatile const 1) float new switch while continue for null 2) 1) Mots réservés du langage mais non utilisés actuellement 2) Littéraux prédéfinis 3) Depuis la version 1.4 du JDK 4) Depuis la version 1.5 du JDK EIA-FR / Jacques Bapst PR1_01 12

4 Java / Eléments de base Notion de variable [1] En informatique, la notion de variable est une notion fondamentale (un concept essentiel). Une variable définit une case mémoire nommée et typée. Le nom est représenté par un identificateur Le type définit le genre d'informations qui sera enregistré ainsi que les opérations qui pourront être effectuées sur ces informations Il existe un certain nombre de types prédéfinis mais il est également possible de créer ses propres types Avant de pouvoir être utilisée, une variable doit préalablement être déclarée (définition de l'identificateur et du type). Java / Eléments de base Représentation en mémoire De manière interne, la zone mémoire allouée à une variable est identifiée par une adresse. Cette adresse est complètement cachée au programmeur : l'accès à la zone mémoire s'effectue en utilisant le nom de la variable. Code Java float note; Représentation interne Variable Adresse Contenu 1215 note Notation abstraite (à utiliser) note Syntaxe : Type Identificateur ; Variable Adresse Contenu float note; Polygone triangle; note 4.75 note = 5.2; 1215 note note 5.2 EIA-FR / Jacques Bapst PR1_01 13 EIA-FR / Jacques Bapst PR1_01 15 Java / Eléments de base Notion de variable [2] Java / Eléments de base Types primitifs [1] La valeur de la variable peut être définie (initialisée), consultée, modifiée en utilisant le nom de la variable. Les variables ont une visibilité et une durée de vie qui dépendent du contexte dans lequel elles sont déclarées. Le type d'une variable peut être soit un type primitif, soit un type référence (c'est-à-dire le nom d'une classe ou d'un tableau) Exemples : int unnombreentier; // Type primitif int String motdepasse; // Classe String (prédéfinie) Point position; // Classe Point char[] voyelles; // Tableau de caractères Type Contient Taille Valeurs boolean Booléen [1 bit 1) ] true, false char Caractère (entier non-signé) 16 bits \u0000..\uffff byte Entier signé 8 bits short Entier signé 16 bits int Entier signé 32 bits long Entier signé 64 bits float Nombre en virgule flottante 32 bits ±3.4*10 38 Point[] nuage; // Tableau de Point(s) double Nombre en virgule flottante 64 bits ±1.7* ) Dépend de l'implémentation de la machine virtuelle EIA-FR / Jacques Bapst PR1_01 14 EIA-FR / Jacques Bapst PR1_01 16

5 Java / Eléments de base Types primitifs [2] Java / Eléments de base Types primitifs [4] Booléen (boolean) Ne peuvent prendre que deux valeurs : Vrai ou Faux Ne peuvent pas être interprétés comme des valeurs numériques [0, 1] Valeurs littérales (valeurs qui figurent directement dans le code) true Vrai false Faux Caractère (char) Caractères Unicode (codage normalisé sur 16 bits) Site de référence de la norme : Peuvent être traités comme des entiers (non-signés!) Valeurs littérales Entre apostrophes : 'A' (attention : "A" n'est pas de type char) Séquence d'échappement pour certains caractères spéciaux (voir tabelle page suivante) Entiers signés (byte, short, int, long) Valeurs littérales (int par défaut) : notation habituelle Suffixe l ou L pour type long (L est préférable) Préfixe 0 (zéro) pour valeur octale (base 8) Préfixe 0b ou 0B pour valeur binaire (base 2) Préfixe 0x ou 0X pour valeur hexadécimale (base 16) Exemples : 0 // valeur de type int 123 // valeur de type int -56 // valeur de type int 0377 // 377 [octal] = 255 [décimal] 433L // valeur de type long 0b1011 // valeur binaire de type int 0xff // valeur hexadécimale de type int 0xA0B3L // valeur hexadécimale de type long Java 7 EIA-FR / Jacques Bapst PR1_01 17 EIA-FR / Jacques Bapst PR1_01 19 Java / Eléments de base Types primitifs [3] Séquences d'échappement (char) Code Signification \b Retour en arrière (Backspace) \t Tabulateur horizontal \n Saut de ligne (Line-feed) \f Saut de page (Form-feed) \r Retour de chariot (Carriage-Return) \" Guillemet \' Apostrophe Java / Eléments de base Types primitifs [5] Nombres en virgule flottante (float, double) Norme IEEE Précision float double : env. 6 chiffres significatifs : env. 15 chiffres significatifs Valeurs littérales (double par défaut) : notation habituelle (n.m) Suffixe f ou F pour type float Suffixe d ou D pour type double (rarement nécessaire) Notation exponentielle avec e ou E suivi de l'exposant Valeurs spéciales : infini, -infini, zéro négatif, NaN (Not a Number) \\ Barre oblique arrière (Backslash) \xxx Caractère Latin-1 (xxx : valeur octale ) \uxxxx Caractère Unicode (xxxx : valeur hexadécimale FFFF) Attention : Les nombres en virgule flottante sont des approximations de nombres réels (tous les nombres réels ne peuvent pas être représentés de manière exacte). Il faut en tenir compte dans les comparaisons et notamment dans les tests d'égalité (prendre en compte un "epsilon"). EIA-FR / Jacques Bapst PR1_01 18 EIA-FR / Jacques Bapst PR1_01 20

6 Java / Eléments de base Types primitifs [6] Nombres en virgule flottante (float, double) // valeur de type double (par défaut) 17d // valeur de type double F // valeur de type float 6.02e23 // 6.02 x de type double E-2f // x 10-2 de type float Le caractère '_' peut être inséré dans les littéraux numériques long creditcardnr = 1234_5678_9012_3456L; int tenmillions = 10_000_000; int bytepattern = 0b _ _ _ ; float pi = 3.14_15_93f; Cas particuliers (problèmes numériques) : 1.2/0.0 // Infini Double.POSITIVE_INFINITY -5.1/0.0 // Moins l'infini Double.NEGATIVE_INFINITY 0.0/0.0 // Not a Number (NaN) Double.NaN Java 7 Java / Eléments de base Conversions de types [1] Mis à part le type booléen, tous les types primitifs peuvent être convertis entre eux. L'encodage Unicode permet (si nécessaire) de considérer les caractères comme des nombres. Le type char peut donc agir comme un entier short mais il est non signé (contrairement aux autres entiers). Conversion élargissante / Promotion (automatique) (avec perte éventuelle de précision lors du passage en virgule flottante) Conversion restrictive explicite (par transtypage / casting) (sous la responsabilité du programmeur) Remarque : Certaines conversions restrictives implicites sont automatiquement effectuées lorsque le résultat d'une expression constante est assignée à une variable (byte, short ou char) pour autant que la valeur de l'expression puisse être représentée (sans perte) par la variable. short compteur = 12*34; // Conversion implicite int -> short EIA-FR / Jacques Bapst PR1_01 21 EIA-FR / Jacques Bapst PR1_01 23 Java / Eléments de base Affichage sur la console Pour afficher une valeur littérale ou le contenu d une variable sur la console de sortie, on utilise les lignes de code suivantes : System.out.print( ); // Affichage (reste sur la même ligne) System.out.println( ); Exemples : System.out.println("Résultats"); System.out.println(" "); int size = 123; char unit = 'm'; System.out.print("Longueur : "); System.out.print(size); System.out.print(" "); System.out.println(unit); Même affichage mais en utilisant l'opérateur de concaténation (+) // Affichage et retour à la ligne Résultats Longueur : 123 m int size = 123; char unit = 'm'; System.out.println("Longueur : " + size + " " + unit); Java / Eléments de base Conversions des types primitifs Conversion de Conversions de types [2] boolean byte short char int long float double boolean N N N N N N N byte N E R E E E E short N R R E E E E char N R R E E E E int N R R R E E* E long N R R R R E* E* float N R! R! R! R! R! E double N R! R! R! R! R! R* N : pas de conversion possible Conversion vers R : conversion restrictive E : conversion élargissante * : perte de précision! : valeur tronquée (promotion) EIA-FR / Jacques Bapst PR1_01 22 EIA-FR / Jacques Bapst PR1_01 24

7 Java / Eléments de base Transtypage (Casting) Conversion de type explicite (au risque du programmeur) Syntaxe : (Type_de_destination) Valeur_à_convertir Exemples : int i = 17; byte b = 4; // Conversion implicite : littéral int -> byte b = i; // Erreur à la compilation b = (byte)i; // Conversion explicite (int -> byte) float f = 23.86f; i = (int)f; // Valeur tronquée (i==23) Java / Eléments de base Chaînes de caractères Les chaînes de caractères ne font pas partie des types primitifs Les chaînes de caractères font partie des types référence (ce sont des objets de la classe String) D'usage courant fi Syntaxe particulière (simplifiée) pour les valeurs littérales : Texte entre guillemets (" ") Peuvent contenir des séquences d'échappement identiques à celles définies pour les types char Ne peuvent pas s'étendre sur plusieurs lignes Concaténation (mise bout à bout) avec l'opérateur "+" Conversions possibles : types primitifs Û String "Ceci est une chaîne de caractères" "Le caractère \" se nomme 'guillemet'" "La conca" + "ténation peut s'étendre " + "sur plusieurs lignes" EIA-FR / Jacques Bapst PR1_01 25 EIA-FR / Jacques Bapst PR1_01 27 Java / Eléments de base Types "Référence" En plus des huit types primitifs, Java définit deux autres catégories de types de données : -les classes et -les tableaux qui seront étudiés en détail plus tard. Les classes et les tableaux sont des types généralement composites (représentant des valeurs multiples). Ils sont collectivement nommés : Types "Référence" (on parle également parfois de types non-primitifs). Pour une variable de type référence, la case mémoire ne contient pas directement les valeurs de la variable mais une référence (une sorte de pointeur) vers une autre zone mémoire contenant les valeurs. String nom = "Dupont"; nom "Dupont" Java / Eléments de base Conversions types primitifs Û String Il est possible de convertir des valeurs de types primitifs en chaînes de caractères (String) et inversement en utilisant des fonctions (méthodes) disponibles dans des classes appelées Wrappers. Conversions Type primitif Wrapper en String de String byte Byte tostring(byte b) parsebyte(string s) short Short tostring(short s) parseshort(string s) int Integer tostring(int i) parseint(string s) long Long tostring(long l) parselong(string s) float Float tostring(float f) parsefloat(string s) double Double tostring(double d) parsedouble(string s) D'autres fonctions de conversion sont également disponibles dans la classe String, notamment la méthode valueof() qui permet de convertir en String les valeurs de tous les types primitifs. EIA-FR / Jacques Bapst PR1_01 26 EIA-FR / Jacques Bapst PR1_01 28

8 Java / Eléments de base Exemples de conversions int i; // Variable de type int float f; // Variable de type float double d; // Variable de type double String s; // Variable de type String s = "412"; i = Integer.parseInt(s); s = "1.234"; d = Double.parseDouble(s); f = 123.8F; s = Float.toString(f); s = String.valueOf(f); // Conversion String -> int // Conversion String -> double // Conversion float -> String // Conversion float -> String Attention : Ne pas confondre les littéraux de type caractère ou chaîne de caractères avec les littéraux numériques. Par exemple '4', "4" et 4. Le premier est un caractère (type char), le deuxième une chaîne de caractères (type String) et le troisième est une valeur numérique entière (type int). EIA-FR / Jacques Bapst PR1_01 29

9 Java / Expressions et opérateurs Expressions [2] Informatique / Programmation Programmation orientée objet avec Java 02 : Expressions et opérateurs Jacques Bapst [email protected] Les expressions complexes sont composées d'expressions primaires (opérandes) et d'opérateurs (y c. invocation de méthodes) Exemples : total = 141 Expression d'affectation Expression avec opérateur d'addition total = 7 + b r = p.min(a, b) Expression comprenant une addition et une affectation Expression comprenant une invocation de méthode La valeur et le type d'une expression complexe sont déterminés par les valeurs et types des opérandes ainsi que par les opérateurs qui interviennent dans l'expression (les règles seront vues plus tard). Certains opérateurs ont des effets de bord : ils changent par ex. la valeur des opérandes et donc modifient l'état du programme (affectation, incrémentation, décrémentation, invocation de méthodes, création d'objets) a = 2 i++ EIA-FR / Jacques Bapst PR1_02 3 Java / Expressions et opérateurs Expressions [1] Les expressions sont des entités composées de littéraux, de variables, d'invocations de méthodes et d'opérateurs. Ex : 4+a/f(x) Les expressions sont des éléments syntaxiques permettant de déterminer une valeur à partir d'autres valeurs L'évaluation d'une expression détermine une valeur et un type de retour Les expressions primaires : littéraux ou variables La valeur résultante de l'évaluation d'une expression primaire est la valeur littérale ou la valeur enregistrée dans la variable. Le type résultant est celui de la valeur littérale ou de la variable Exemples : 141 Littéral entier (type int, valeur 141) true total Littéral booléen (type boolean, valeur true) Variable (type selon déclaration de variable, valeur actuelle de total) Java / Expressions et opérateurs Opérateurs Les opérateurs sont des éléments syntaxiques qui effectuent certaines opérations en utilisant les valeurs de leurs opérandes (paramètres de l'opération). Opérateurs unaires (monadiques) -b Opérateur monadique moins a++ Opérateurs binaires (dyadiques) a * b y = z (int)y 1 opérande Opérateur monadique de post-incrémentation 2 opérandes L'opérateur de multiplication est binaire L'affectation est également binaire Transtypage (casting) Opérateurs ternaires Un seul opérateur ternaire en Java x > y? x : y Opérandes 3 opérandes Retourne la valeur maximale entre x et y Op Résultat EIA-FR / Jacques Bapst PR1_02 2 EIA-FR / Jacques Bapst PR1_02 4

10 Java / Expressions et opérateurs Liste des opérateurs [1] Java / Expressions et opérateurs Précédence et Associativité P A Opérateur Type(s) des opérandes Opération 15 G. [] ( params ) ++, D ++, -- +, - ~! 13 D new ( type ) objet, membre tableau, int méthode, liste de paramètres variable variable nombre entier booléen classe, liste de paramètres type, quelconque accès au membre d'un objet accès à l'élément d'un tableau invocation (appel) de méthode post-incrémentation, décrémentation pré-incrémentation, décrémentation plus monadique, moins monadique complément binaire NON logique création (instanciation) d'objet transtypage (conversion de type) 12 G *, /, % nombre, nombre multiplication, division, modulo 11 G +, - + nombre, nombre chaîne de caract., quelconque addition, soustraction concaténation 10 G <<, >>, >>> entier, entier décalage à gauche, droite, non-signé 9 G <, <= >, >= instanceof 8 G ==!= ==!= P : Précédence A : Associativité nombre, nombre nombre, nombre référence, type primitif, primitif primitif, primitif référence, référence référence, référence inférieur, inférieur ou égal supérieur, supérieur ou égal comparaision de types égalité (valeurs égales) non-égalité égalité (référence au même objet) non-égalité EIA-FR / Jacques Bapst PR1_02 5 Précédence (voir colonne P dans la liste des opérateurs) Définit, en l'absence de parenthèses, quelles opérandes sont liés à quels opérateurs Plus le degré de précédence est élevé et plus les opérandes sont liés à l'opérateur considéré Les parenthèses permettent de spécifier explicitement les liens entre les opérandes et les opérateurs Conseil :Sauf cas triviaux, toujours mettre des parenthèses dans les expressions complexes afin d'éviter toute ambiguïté d'interprétation Associativité (voir colonne A dans la liste des opérateurs) S'il y a plusieurs opérateurs de même précédence, l'associativité définit l'ordre dans lequel les opérations seront exécutées De la gauche vers la droite (G) De la droite vers la gauche (D) EIA-FR / Jacques Bapst PR1_02 7 Java / Expressions et opérateurs Liste des opérateurs [2] Java / Expressions et opérateurs Opérateurs arithmétiques P A Opérateur Type(s) des opérandes Opération 7 G & & 6 G ^ ^ 5 G entier, entier booléen, booléen entier, entier booléen, booléen entier, entier booléen, booléen ET binaire (bit à bit) ET logique OU exclusif binaire (bit à bit) OU exclusif logique OU binaire (bit à bit) OU logique 4 G && booléen, booléen ET logique conditionnel 1) 3 G booléen, booléen OU logique conditionnel 1) 2 D? : booléen, quelconque, quelconque opérateur conditionnel (ternaire) 1 D = *=, /=, %=, +=, -=, <<=, >>=, >>>=, &=, ^=, = P : Précédence A : Associativité variable, quelconque variable, quelconque affectation affectation avec opération 1) L'opérande de droite n'est évaluée que si c'est nécessaire Effectuent des opérations arithmétiques et retournent des résultats numériques Le type du résultat dépend du type des opérandes Si nécessaire, une conversion élargissante (automatique) des opérandes est effectuée avant l'opération + - plus, moins monadique + - addition, soustraction pré/post incrémentation, pré/post décrémentation * / % multiplication, division, modulo (reste de la division entière) -2.7 i++ --j - 2 a * x*x /3 17 % 5 ( ne pas confondre avec 17 /5) EIA-FR / Jacques Bapst PR1_02 6 EIA-FR / Jacques Bapst PR1_02 8

11 Java / Expressions et opérateurs Ordre d'évaluation Pour mettre en évidence l'ordre d'évaluation des opérations d'une expression, on peut placer des parenthèses en fonction de la précédence et de l'associativité des opérateurs impliqués : Précédence * G G G G ( ( 1 + ( 3 * 4 ) ) - 2 ) - 5 v = a - i D G D v = ( a - ( i++ ) ) Associativité Après placement des parenthèses, les opérateurs ne devraient avoir comme opérandes que des expressions entre parenthèses ou éventuellement un symbole ou une valeur littérale unique (isolé). Analyse non terminée : u = (a * b) - (c * d) + f(e); Java / Expressions et opérateurs Évaluation des opérations [1] Si l'un des opérandes est un nombre en virgule flottante, l'arithmétique décimale (arithmétique réelle) est utilisée (calcul en virgule flottante) Si les deux opérandes sont des nombres entiers, l'arithmétique entière est utilisée (important pour les divisions et pour le domaine des valeurs possibles) Les caractères (char) sont traités comme des entiers short (leur valeur Unicode est utilisée) L'arithmétique entière est circulaire et ne produit jamais de dépassement (une division par zéro lève cependant l'exception ArithmeticException) L'arithmétique décimale (en virgule flottante) peut produire des valeurs spéciales (infini, -infini, zéro négatif, NaN) mais ne lève jamais d'exceptions EIA-FR / Jacques Bapst PR1_02 9 EIA-FR / Jacques Bapst PR1_02 11 C o m p l é m e n t Java / Expressions et opérateurs Ordre d'évaluation / Ordre des opérations Dans des expressions plus complexes (et un peu tordues) il est nécessaire de bien distinguer l'ordre d'évaluation des opérandes (qui s'effectue de gauche à droite) et l'ordre des opérations (qui dépend de la précédence et de l'associativité des opérateurs). De telles expressions pièges sont à éviter (il faut impérativement écrire le code de manière moins ambiguë). int i = 10; i = i + (i=5); int i=2; i = ++i + ++i * ++i; int i=1, j=2; i = i+++j; Java / Expressions et opérateurs Évaluation des opérations [2] Le résultat d'une expression entière est de type int 1) sauf si l'un des opérandes est de type long, auquel cas l'expression est de type long (voir diagramme page suivante) Le résultat d'une expression réelle (comprenant au moins un opérande en virgule flottante) est de type float 1) sauf si l'un des opérandes est de type double, auquel cas l'expression est de type double (voir diagramme page suivante) 1) par conversion élargissante automatique (promotion) des opérandes byte b = 12; short s = 167; float f = 1.2f; int i = s - b; // Expression entière, s et b sont convertis en int // avant l'opération double d = f * 2.5; // Expression réelle, f est converti en double avant // l'opération (car 2.5 est de type double) EIA-FR / Jacques Bapst PR1_02 10 EIA-FR / Jacques Bapst PR1_02 12

12 Java / Expressions et opérateurs Évaluation des expressions arithmétiques Pour chaque opérateur arithmétique, d'éventuelles conversions préalables sont effectuées en fonction du type de ses opérandes : N Conversion év. et calcul en int long? Arithmétique entière Y N Conversion év. et calcul en long Nb à virg.? Y N Conversion év. et calcul en float double? Y Arithmétique décimale Conversion év. et calcul en double Java / Expressions et opérateurs Opérateurs et nombres en virgule flottante Les nombres en virgule flottante (float et double) ne sont que des approximations des nombres réels car ils sont codifiés (en base 2) avec un nombre limité de bits pour la mantisse et pour l'exposant (voir par ex. ou babbage.cs.qc.edu/ieee-754). Même à l'intérieur du domaine de valeurs prévu et avec un nombre de décimales inférieur à la précision maximale, une grande quantité de nombres réels ne peuvent pas être représentés exactement. C'est pourquoi il faut être très prudent lors de l'utilisation des opérateurs relationnels avec les nombres en virgule flottante et tenir compte de ces problèmes d'arrondi. float a=1.0f, b=0.1f, c=0.2f; (a+(b+c))!= ((a+b)+c) //!!! true!!! (a+(b+c)) < ((a+b)+c) //!!! true!!! Exemple : 17 / float d=2.0e7f; d == (d+1) //!!! true!!! EIA-FR / Jacques Bapst PR1_02 13 EIA-FR / Jacques Bapst PR1_02 15 Java / Expressions et opérateurs Opérateurs relationnels Java / Expressions et opérateurs Opérateurs logiques Effectuent des opérations de comparaison et retournent des résultats booléens Effectuent des opérations logiques et retournent des résultats booléens ==!= égalité, inégalité < > plus petit, plus grand <= >= plus petit ou égal, plus grand ou égal i < 5 if (age >= 18) {... while (i<100) {... if (objet1!= objet2) {... // Comparaison des références! NON logique & && ET logique OU logique ET logique conditionnel (le 2 ème opérande n'est évalué que si le 1 er est vrai) OU logique conditionnel (le 2 ème opérande n'est évalué que si le 1 er est faux) ^ OU exclusif logique Ne pas confondre avec l'élévation à la puissance! Attention : pour les types références (objets et tableaux) les opérateurs d'égalité et d'inégalité comparent les références et non les valeurs référencées. if (!found) {... if (size>1.4 age>12) {... if (t!=null && t.length>=2 && t[1]!=4) {... EIA-FR / Jacques Bapst PR1_02 14 EIA-FR / Jacques Bapst PR1_02 16

13 Java / Expressions et opérateurs Opérateurs orientés bits Java / Expressions et opérateurs Affectation avec opérateur Effectuent des opérations bit à bit et retournent des résultats entiers (signés) ~ Inversion (complément à 1) & ET (bit à bit) OU (bit à bit) ^ OU exclusif (bit à bit) Ne pas confondre avec l'élévation à la puissance! << Décalage à gauche (zéros ajoutés à droite) >> Décalage à droite signé (bit du signe ajouté à gauche) >>> Décalage à droite non-signé (zéros ajoutés à gauche) byte b = ~12 // ~ => (-13) 10 & 7 // & => ( 2) 10 7 // => ( 15) 10 ^ 7 // ^ => ( 13) 10 << 2 // => ( 40) 10 >> 2 // => ( 2) -10 >> 2 // => ( -3) -10 >>>2 // => ( 61) Combinaison de l'affectation avec un opérateur (arithmétique ou orienté bits) Le type de l'opérande de gauche (variable) doit être compatible avec le type de l'expression de droite var op= expr est équivalent à var = var op ( expr ) Opérateurs combinés : += -= *= /= %= i += 2; // i = i + 2; &= = ^= <<= >>= >>>= a *= z + 4; // a = a * (z + 4); flag = mask; // flag = flag mask; // set some bits according to a mask EIA-FR / Jacques Bapst PR1_02 17 EIA-FR / Jacques Bapst PR1_02 19 Java / Expressions et opérateurs Affectation / Assignation Java / Expressions et opérateurs Opérateur instanceof Enregistre dans l'opérande de gauche (variable) la valeur de l'opérande de droite (valeur de l'expression) Le type de la variable (opérande de gauche) doit être compatible avec le type de l'expression de droite (si nécessaire, conversion élargissante automatique) Le type et valeur de retour d'une expression d'affectation correspondent au type de la variable et, respectivement, à sa valeur après affectation Attention : Ne pas confondre l'opérateur d'affectation (=) avec celui d'égalité (==) a = b + c; "prend pour valeur" et non pas "est égal à" // La variable a prend pour valeur le résultat de la somme (b+c) a = b = c; // Associativité à droite fi a = (b = c) t[i] = circle.center(); Sera vu plus en détail dans le cadre du polymorphisme Permet de tester si une expression (de type référence) est compatible (convertible) avec un type donné. Retourne true si l'opérande de gauche (qui doit être une expression de type objet ou tableau) est une instance du type spécifié par l'opérande de droite (qui doit être un type référence) "Texte" instanceof String; "Texte" instanceof Object; // true // true null instanceof String; // false new int[] {1 instanceof Object // true new int[] {1 instanceof byte[] // false tableau d'int tableau de byte // Utile pour prévenir des erreurs de transtypage if (forme instanceof Polygone) { Polygone p1 = (Polygone)forme; EIA-FR / Jacques Bapst PR1_02 18 EIA-FR / Jacques Bapst PR1_02 20

14 Java / Expressions et opérateurs Opérateurs particuliers Ces opérateurs particuliers sont parfois considérés comme des éléments syntaxiques, parfois comme opérateurs : Accès à un membre d'un objet (.) obj.x obj.f() C o m p l é m e n t Accès à un élément d'un tableau ([]) t[2] Invocation de méthode (()) rectangle.move(x, y) Création d'un objet (new) new Point(4.0, -2.5); new ArrayList(); Conversion de type / Transtypage (()) (float)position (int)(a*1.414f) (Circle)shape EIA-FR / Jacques Bapst PR1_02 21

15 Java / Instructions Instructions [2] Informatique / Programmation Programmation orientée objet avec Java 03 : Instructions et contrôle de flux Jacques Bapst [email protected] Une instruction vide est constituée d'un simple point-virgule (;) Une instruction vide ne fait rien, mais son expression syntaxique peut parfois être utile. Une instruction peut s'étendre sur plusieurs lignes du fichier source Dans ce cas, les retours à la ligne doivent être placés entre les éléments syntaxiques. Plusieurs instructions peuvent être placées sur une même ligne du fichier source. Cette pratique est généralement à éviter et doit être réservée aux cas où les instructions sont fortement corrélées et assez courtes. Le point-virgule marque la fin d'une instruction (et non la fin d'une ligne). screen.draw(x, y); x += dx; y += dy; EIA-FR / Jacques Bapst PR1_03 3 Java / Instructions Instructions [1] Java / Instructions Bloc d'instructions Une instruction définit une opération qui sera exécutée par la machine virtuelle Java. Par défaut, les instruction sont exécutées séquentiellement (les unes après les autres), dans l'ordre dans lequel elles ont été rédigées (ordre d'apparition dans le fichier source). Cependant, certaines instructions de contrôle de flux permettent de modifier l'ordre d'exécution d'une manière bien définie (instructions exécutées conditionnellement, répétition d'instructions, etc.). Les expressions avec effets de bord (affectation, incrémentation, décrémentation et invocation de méthodes) peuvent être utilisées comme instructions; elles sont alors suivies d'un point-virgule : j = 2; count++; move(dx, dy); EIA-FR / Jacques Bapst PR1_03 2 Un bloc d'instructions (appelé également instruction composée) est constitué d'un certain nombre d'instructions quelconques placées entre accolades ( {... ). Un bloc d'instructions peut être utilisé pratiquement partout où une instruction est requise par la syntaxe Java. if (a<b) { // Début du bloc d'instructions t = b; b = a; a = t; // Fin du bloc d'instructions Pour mettre en évidence la structure du code, on indente les instructions à l'intérieur du bloc. La forme suivante est fréquemment utilisée : if (a<b) { t = b; ( Notez bien l'indentation ) b = a; a = t; EIA-FR / Jacques Bapst PR1_03 4

16 Java / Instructions Déclaration de variables locales [1] Java / Instructions Représentation en mémoire Une déclaration de variable locale (souvent simplement appelée variable) définit une zone mémoire en lui associant un nom (identificateur) et un type. La déclaration permet en outre de spécifier (optionnellement) la valeur initiale de la variable. Syntaxe : Type Identificateur [ = Expression ]; Toutes les variables locales doivent être déclarées et initialisées avant d'être utilisées. En Java, les déclarations de variables peuvent être placées n'importe où dans les blocs d'instructions. Conseil :Pour faciliter la lecture du code, groupez de préférence les déclarations de variables au début des structures (méthodes, blocs d'instructions) Une déclaration de variable locale définit (dans la mémoire vive) une zone mémoire dont la taille et le codage dépend du type de la variable. Les détails d'implémentation ne sont pas importants (mais il faut retenir le principe). { int price; price = 3; { int cost=2*price; Variable Adresse Contenu 1215 price cost Représentation abstraite usuelle (notation à utiliser) price 3 cost 6 EIA-FR / Jacques Bapst PR1_03 5 EIA-FR / Jacques Bapst PR1_03 7 Java / Instructions Déclaration de variables locales [2] Java / Instructions Portée des variables Une seule instruction de déclaration de variable permet de déclarer et d'initialiser plusieurs variables, pour autant qu'elles soient toutes du même type. Lors de déclarations multiples, les noms des variables (avec leurs éventuelles valeurs initiales) sont séparés par des virgules. int counter; Point p; int number= 0; // Déclaration et initialisation String s = getname(); // Valeur connue à l'exécution seulement int i, j, k; int i=2, j=5, k; // Déclarations multiples // i et j sont initialisés, k ne l'est pas Les variables locales ne peuvent être utilisées que dans la méthode ou le bloc d'instruction au sein duquel elles ont été déclarées On définit la portée (scope) ou portée lexicale d'une variable la zone de code où la variable est accessible (cette zone va de sa déclaration jusqu'à la fin du bloc dans lequel elle est déclarée). A la fin de leurs portées lexicales, les variables ne sont plus visibles et le système peut récupérer l'espace mémoire qui leur était alloué public static void m() { int i = 0; // i while (i<10) { // i double d = 1.2 * i; // i d System.out.println(d); // i d i++; // i d // i System.out.println(i); // i EIA-FR / Jacques Bapst PR1_03 6 EIA-FR / Jacques Bapst PR1_03 8

17 Java / Instructions conditionnelles La sélection On appelle sélection la possibilité de choisir d'exécuter une ou plusieurs instructions en fonction de la situation (exprimée sous la forme d'une condition) prévalant à l'instant considéré. On trouve trois formes de réalisation en Java : L'instruction conditionnelle (if (cond)...) qui permet d'exécuter ou non un bloc d'instructions. L'instruction d'alternative (if (cond)... else...) qui permet d'exécuter un bloc d'instructions ou, alternativement, un autre bloc d'instructions L'instruction sélective (switch (expr) case...) qui permet (dans sa variante habituelle) de choisir d'exécuter un parmi plusieurs blocs d'instructions Instruction if... else if (expression_booléenne ) instruction_a else instruction_b Une clause else peut (optionnellement) être mentionnée dans l'instruction if L'instruction qui suit la clause else est exécutée si l'expression booléenne (la condition) est fausse if (average >= 4) System.out.println("Pass"); else { Java / Instructions conditionnelles System.out.println("Fail"); repeat = true; Instruction(s) B false Expression booléenne true Instruction(s) A EIA-FR / Jacques Bapst PR1_03 9 EIA-FR / Jacques Bapst PR1_03 11 Java / Instructions conditionnelles Instruction if Exécution d'une instruction de manière conditionnelle La condition est exprimée par une expression booléenne L'instruction est exécutée si la condition est vraie if (age >= 18) status = "Adult"; if ((age<16) isstudent) { canhaveallocations = true; amount = 400; if (expression_booléenne ) instruction Expression booléenne false true Instruction(s) Java / Instructions conditionnelles Emboîtement d'instructions if... else L'instruction if / else peut contenir dans chacune de ses deux branches une autre instruction if / else qui peut elle-même contenir une autre instruction On peut ainsi avoir plusieurs niveaux d'emboîtement formant une logique plus ou moins complexe. En l'absence de blocs d'instructions ({ ), la clause else se rapporte toujours au if précédent (sans else) le plus proche (l'indentation ne change pas la logique du code!). if (x >= 2) if (x <= 20) status = 1; else if (x <= 10) status = 2; else status = 3; if (x >= 2) if (x <= 20) status = 1; else if (x <= 10) status = 2; else status = 3; L'indentation est importante pour la lisibilité du code! if (x >= 2) { if (x <= 20) status = 1; else { if (x < 0) status = 0; else status = 2; EIA-FR / Jacques Bapst PR1_03 10 EIA-FR / Jacques Bapst PR1_03 12

18 Java / Instructions conditionnelles Imbrication if... else if... [1] Lorsque l'on doit choisir une instruction (ou un bloc d'instructions) parmi plusieurs (groupes d'instructions mutuellement exclusifs) il faut imbriquer les clauses if else if sur plusieurs niveaux. if (n==1) {... // Code executed if n is 1 else { if (n==2) {... // Code executed if n is 2 else { if (n==3) {... // Code executed if n is 3 else { if (n==4) {... // Code executed if n is 4 else {... // Code executed otherwise Java / Instructions conditionnelles Instruction switch [1] switch ( expression ) { case const1 : suite_instructions_1 case const2 : suite_instructions_2... default : suite_instructions_default Instruction de sélection multiple parmi une liste d'instructions (indexées) et dont le point d'entrée est déterminé par la valeur d'une expression (constante) de type byte, short, int, char d'un type énuméré (enum) ou String Java 7 A partir du point d'entrée, l'exécution se poursuit ensuite dans les instructions suivantes (celles des autres clauses case) jusqu'à la fin de l'instruction switch ou jusqu'à l'instruction break (ou return) qui interrompt l'instruction switch EIA-FR / Jacques Bapst PR1_03 13 EIA-FR / Jacques Bapst PR1_03 15 Java / Instructions conditionnelles Imbrication if... else if... [2] Si le nombre d'alternatives est grande, l'indentation provoque un décalage du code vers la droite qui peut devenir gênant. C'est pourquoi l'on préférera, dans ce cas, la disposition suivante : if (n==1) {... // Code executed if n is 1 else if (n==2) {... // Code executed if n is 2 else if (n==3) {... // Code executed if n is 3 else {... // Code executed otherwise Remarque : Il ne s'agit pas d'une nouvelle syntaxe mais simplement d'une mise en page plus lisible (sans cumul de l'indentation). Java / Instructions conditionnelles n = Instruction switch [2] // Variable of type byte, short, int, char, enum or String switch (n) { case 1 : Instruction; // Start here if n is 1 Instruction; case 5 : case 6 : Instruction; // Start here if n is 5 or 6 Instruction; case 8 : Instruction; // Start here if n is 8 Instruction; default : Instruction; // Start here if n {1, 5, 6, 8 Instruction; Point d'entrée Java 7 A partir du point d'entrée, toutes les instructions qui suivent sont exécutées jusqu'à la fin de l'instruction switch ou jusqu'à l'instruction break (ou autre instruction d'interruption comme return, throw, ) EIA-FR / Jacques Bapst PR1_03 14 EIA-FR / Jacques Bapst PR1_03 16

19 Java / Instructions conditionnelles Instruction switch [3] Java / Instructions conditionnelles Instruction switch [5] Le mot clé default définit un point d'entrée qui est sélectionné si la valeur de l'expression ne correspond à aucune valeur dans la liste des clauses case. Le mot clé default est optionnel et est généralement placé comme dernière clause (ce n'est pas imposé par le langage mais fortement recommandé). false Case a true Instruction(s) A break; Plusieurs clauses case peuvent étiqueter la même suite d'instructions (même point d'entrée pour plusieurs valeurs différentes). Case b true Instruction(s) B break; Les valeurs associées aux clauses case doivent être des valeurs ou expressions constantes (évaluables par le compilateur). false Toutes les valeurs des clauses case doivent être différentes. L'instruction switch est une instruction de bas niveau qui peut être remplacée par un enchaînement d'instructions if else. Les instructions if else offrent, en outre, davantage de flexibilité (expressions de types quelconques, utilisation de variables et d'expressions relationnelles et logiques dans les clauses de sélection) et n'imposent pas l'utilisation quasi systématique d'instructions d'interruption (break, return, ). false Case z true Instruction(s) Z break; EIA-FR / Jacques Bapst PR1_03 17 EIA-FR / Jacques Bapst PR1_03 19 Java / Instructions conditionnelles Instruction switch [4] Java / Instructions conditionnelles Instruction switch [6] int month, nbdays; month = false false Case a Case b true true Instruction(s) A Instruction(s) B switch (month) { case 4 : case 6 : case 9 : case 11 : nbdays = 30; break; case 2 : nbdays = 28; break; // Années bissextiles non considérées default : nbdays = 31; break; false Case z true Instruction(s) Z Conseil : Sauf cas exceptionnels, placez systématiquement une instruction break (ou return) à la fin de chaque clause case car il est rare que l'on souhaite l'exécution des instructions des clauses case qui suivent celles du point d'entrée. EIA-FR / Jacques Bapst PR1_03 18 EIA-FR / Jacques Bapst PR1_03 20

20 Java / Instructions conditionnelles boolean positiveanswer = false; Instruction switch [7] char answer = readkeyboardchar(); switch (answer) { case 'y' : case 'Y' : case 'j' : case 'J' : case 'o' : case 'O' : positiveanswer = true; break; case 'n' : case 'N' : positiveanswer = false; break; default : System.out.println("Caractère incorrect"); Java / Instructions itératives Itérations / Boucles On appelle boucle ou itération l'exécution multiple d'une ou de plusieurs instructions en fonction de la situation (exprimée sous la forme d'une condition) prévalant à l'instant considéré. On trouve trois formes de réalisation en Java : L'instruction while qui permet de répéter un nombre quelconque de fois (0 ou plus) l'exécution d'une instruction ou d'un bloc d'instructions. Le nombre de répétitions n'est pas forcément connu au moment d'entrer dans la boucle. L'instruction do while qui permet de répéter un nombre quelconque de fois (1 ou plus) l'exécution d'une instruction ou d'un bloc d'instructions. Le nombre de répétitions n'est pas forcément connu au moment d'entrer dans la boucle. L'instruction for qui permet de répéter un nombre quelconque de fois (0 ou plus) l'exécution d'une instruction ou d'un bloc d'instructions. Le nombre de répétitions est généralement connu au moment d'entrer dans la boucle (mais ce n'est pas toujours le cas). EIA-FR / Jacques Bapst PR1_03 21 EIA-FR / Jacques Bapst PR1_03 23 Java / Instructions conditionnelles Instruction switch [8] Java / Instructions itératives Instruction while String typeofday; switch (dayofweek) { case "Monday": typeofday = "Start of work week"; case "Tuesday": case "Wednesday": case "Thursday": typeofday = "Midweek"; case "Friday": typeofday = "End of work week"; case "Saturday": case "Sunday": typeofday = "Weekend"; break; break; break; break; default: typeofday = "Invalid day of the week"; break; Attention :La comparaison prend en compte les minuscules/majuscules Java 7 while (expression_booléenne ) instruction Instruction itérative L'expression booléenne est évaluée Si elle est vraie, l'instruction est exécutée Puis l'expression booléenne est évaluée à nouveau etc... L'instruction while se termine si l'expression booléenne est fausse L'instruction est exécutée 0, 1 ou n fois // Affiche les nombres de 0 à 9 int count = 0; while (count <= 9) { System.out.println(count); count++; Expression booléenne false true Instruction(s) EIA-FR / Jacques Bapst PR1_03 22 EIA-FR / Jacques Bapst PR1_03 24

21 Java / Instructions itératives Instruction do... while do instruction while ( expression_booléenne ); Instruction itérative Exécute l'instruction Évalue l'expression booléenne Si elle est vraie, l'instruction est exécutée à nouveau Évalue à nouveau l'expression booléenne etc... L'instruction do se termine si l'expression booléenne est fausse L'instruction est exécutée 1 ou n fois do { display("nombre positif : "); number = keyboard.readnumber(); while (number < 0); Instruction(s) Expression booléenne true Instruction for [2] En lieu et place d'instructions, l'initialisation peut contenir la déclaration (et éventuellement l'initialisation) d'une ou plusieurs variables locales (mais toutes du même type) dont la portée est limitée au corps de la boucle La conclusion est fréquemment constituée par une instruction de mise à jour d'un compteur de boucle (incrémentation par exemple) L'initialisation, l'expression booléenne et la conclusion sont facultatives mais le point-virgule est obligatoire (par défaut, l'expression booléenne est vraie) // Affiche les nombres de 0 à 9 for (int count=0; count<=9; count++) { Java / Instructions itératives System.out.println(count); Initialisation Expression booléenne false true Conclusion Instruction(s) false EIA-FR / Jacques Bapst PR1_03 25 EIA-FR / Jacques Bapst PR1_03 27 Java / Instructions itératives Instruction itérative Instruction for [1] for ( initialisation ; expression_booléenne ; conclusion ) instruction Les expressions d'initialisation et de conclusion peuvent être formées par zéro, une ou plusieurs instructions (expressions) séparées par des virgules A deux exceptions près 1), l'instruction for est équivalente à la boucle while suivante : initialisation; while (expression_booléenne) { instruction; conclusion; 1) -S'il y a un continue, conclusion sera exécuté dans l'instruction for mais pas dans while -Initialisation et conclusion ne peuvent pas être des instructions séparées par des virgules dans la boucle while EIA-FR / Jacques Bapst PR1_03 26 Java / Instructions itératives Imbrication de boucles [1] On peut placer n'importe quelle(s) instruction(s) à l'intérieur d'une instruction d'itération while, do ou for, y compris une nouvelle instruction d'itération. Les instructions itératives peuvent donc être imbriquées. Une telle construction est très fréquente. for (int i=1; i<=5; i++) { System.out.println("i> " + i); for (int k=0; k<=2 ; k++) { System.out.println(" k> " + k); System.out.println(" "); i> 1 k> 0 k> 1 k> i> 2 k> 0 k> 1 k> i> 3 k> 0 k> 1 k> i> 4 k> 0 k> 1 k> i> 5 k> 0 k> 1 k> EIA-FR / Jacques Bapst PR1_03 28

22 Java / Instructions itératives Imbrication de boucles [2] Autre exemple d'imbrication de boucles : for (int i=0; i<3; i++) { System.out.println("i> " + i); int j = 2*i; while (j>0) { System.out.println(" j> " + j); for (int k=6; k>0 ; k=k-2) { System.out.println(" k> " + k); j = j/2; int m = 4-i; do { System.out.println(" m> " + m); while (--m > 0); i> 0 m> 4 m> 3 m> 2 m> 1 i> 1 j> 2 k> 6 k> 4 k> 2 j> 1 k> 6 k> 4 k> 2 m> 3 m> 2 m> 1 i> 2 j> 4 k> 6 k> 4 k> 2 j> 2 k> 6 k> 4 k> 2 j> 1 k> 6 k> 4 k> 2 m> 2 m> 1 Java / Instructions de rupture Instruction break break [ étiquette ] ; L'instruction break force l'interpréteur à passer immédiatement à la fin de l'instruction englobante switch, while, do ou for la plus interne L'instruction break peut être suivie du nom d'une étiquette (label). Dans ce cas, elle a pour effet de quitter immédiatement l'instruction englobante (qui peut être quelconque dans ce cas) portant l'étiquette correspondante testbreak: for (int i=1; i<=5; i++) { for (int j=1; j<=5; j++) { if (j == 3) break; if (i == 4) break testbreak; System.out.println("i*j=" + i*j); // Termine la boucle interne // Termine la boucle externe EIA-FR / Jacques Bapst PR1_03 29 EIA-FR / Jacques Bapst PR1_03 31 Java / Instructions itératives Instructions étiquetées On peut donner un nom (étiquette, label) à une instruction en la précédant d'un identificateur et d'un caractère deux points (':') : nom : instruction ; Les étiquettes ne sont utilisées qu'en relation avec les instructions d'interruption break et continue (voir pages suivantes). En Java, les étiquettes ne peuvent pas être utilisées pour effectuer un branchement direct (goto label). Remarque : même si goto est un mot réservé du langage, il n'est pas utilisé actuellement. EIA-FR / Jacques Bapst PR1_03 30 Java / Instructions de rupture Instruction continue [1] L'instruction continue force la boucle englobante la plus interne à démarrer une nouvelle itération L'instruction continue ne peut être utilisée qu'au sein d'une boucle while, do ou for Avec une étiquette, l'instruction continue force la boucle englobante identifiée par l'étiquette à démarrer une nouvelle itération Effets : continue [ étiquette ] ; Avec while et do : évalue l'expression booléenne et, si elle est vraie, exécute une nouvelle fois le corps de la boucle Avec for : effectue les instructions de conclusion puis évalue l'expression booléenne et, si elle est vraie, exécute une nouvelle fois le corps de la boucle EIA-FR / Jacques Bapst PR1_03 32

23 Java / Instructions de rupture Instruction continue [2] Java / Instructions Instruction assert [1] Un exemple d'utilisation de l'instruction continue : assert Expression_Booléenne ; assert Expression_Booléenne : Expression_Msg ; testcontinue: for (int i=1; i<=5; i++) { for (int j=1; j<=5; j++) { if (j == 3) continue; if (i == 4) continue testcontinue; System.out.println("i*j=" + i*j); // Prochaine itération // de la boucle interne // Prochaine itération // de la boucle externe C o m p l é m e n t L'instruction assert permet d'insérer des assertions dans le code source. Les assertions sont des affirmations que le programmeur tient pour vraies à l'endroit où elles sont placées et qui pourront être vérifiée lors de l'exécution du code (outil de conception). L'expression booléenne représente l'affirmation qui doit être vraie. L'expression optionnelle passée comme deuxième argument permettra de définir (par conversion en chaîne de caractères) le message associé à l'exception en cas de violation de l'assertion (c'est-à-dire dans le cas où l'expression booléenne est fausse). La violation d'une assertion lève l'exception AssertionError. EIA-FR / Jacques Bapst PR1_03 33 EIA-FR / Jacques Bapst PR1_03 35 Java / Instructions de rupture Instruction return Java / Instructions Instruction assert [2] L'instruction return termine l'exécution d'une méthode en cours d'exécution et rend le contrôle à la méthode appelante en retournant (restituant) éventuellement une valeur (expression) qui doit être compatible avec le type de la méthode. Si une méthode déclare un type de retour, l'instruction return (avec une expression compatible) doit obligatoirement figurer dans le corps de la méthode (dernière instruction exécutable). public static double square(double x) { return x * x; return [ expression ] ; C o m p l é m e n t Exemple : if (i % 3 == 0) {... else if (i % 3 == 1) {... else { assert i % 3 == 2 : i; // L'expression booléenne est-elle toujours vraie?... Des paramètres de la machine virtuelle (-ea / -da) permettent d'enclencher ou de déclencher l'évaluation des assertions lors du lancement d'une application (par défaut, elle ne sont pas évaluées). EIA-FR / Jacques Bapst PR1_03 34 EIA-FR / Jacques Bapst PR1_03 36

24 Java / Instructions Instruction synchronized synchronized ( objet_ou_tableau ) { instructions C o m p l é m e n t L'instruction synchronized permet d'éviter que plusieurs threads (exécutions parallèles) de l'application modifient simultanément un même objet L'objet (ou le tableau) de l'expression est protégé contre toute modification simultanée durant l'exécution des instructions (qui constituent la section critique) Un verrou exclusif est pris sur l'objet ou le tableau spécifié avant d'exécuter les instructions int[] a; // Tableau accessible depuis plusieurs... // threads synchronized(a) {... // Opérations sur le tableau (par ex. tri) EIA-FR / Jacques Bapst PR1_03 37

25 Java / Méthodes Une méthode c'est Informatique / Programmation On peut dire, en quelques mots, qu'une méthode c'est le regroupement d'une suite d'instructions auquel on attribue un nom (identificateur) peut être invoquée (appelée) par une instruction (dans une méthode appelante) Programmation orientée objet avec Java 04 : Méthodes permet la déclaration (optionnelle) de variables locales peut être optionnellement paramétrée au moyen d'une liste d'arguments (paramètres) peut optionnellement retourner une valeur (un résultat) à l'appelant Jacques Bapst [email protected] peut être liée à l'existence d'un objet (méthode d'instance) ou à l'existence d'une classe (méthode statique) peut optionnellement générer une exception qui indique qu'un événement exceptionnel s'est produit durant son exécution (par exemple une erreur) EIA-FR / Jacques Bapst PR1_04 3 Java / Méthodes Pourquoi créer des méthodes Java / Méthodes Méthodes [1] La taille des problèmes à résoudre à l'aide d'un programme peut être très complexe, d'où la nécessité de : Subdiviser les problèmes en sous-problèmes (plus simples) que l'on traite indépendamment : [ approche Top/Down ] Abstraction, modularisation, raffinements successifs Réutiliser des parties de code existantes (exemple : entrée/sorties, fonctions mathématiques, graphiques, etc) : [ approche Bottom/Up ] Rapidité de développement, efficacité, fiabilité Une méthode permet de regrouper, sous un nom, une suite d'instructions exécutable à répétition. Une méthode est une séquence nommée d'instructions. Ces instructions peuvent être exécutées en invoquant (appelant) la méthode. Lorsqu'une méthode est invoquée, elle peut recevoir un certain nombre de valeurs appelées arguments (ou paramètres). Une méthode peut facultativement retourner une valeur d'un certain type (elle se comporte alors comme une expression complexe). On utilise également le terme fonction pour désigner une méthode qui retourne une valeur. Une invocation de méthode est une expression (avec effet de bord) qui peut être également utilisée en tant qu'instruction simple (sans exploitation d'une éventuelle de valeur de retour). Après l'exécution de la dernière instruction de la méthode, le contrôle retourne à l'instruction qui a invoqué la méthode. EIA-FR / Jacques Bapst PR1_04 2 EIA-FR / Jacques Bapst PR1_04 4

26 Java / Méthodes Méthodes [2] Java / Méthodes Déclaration de méthode Une méthode est caractérisée par sa signature (ou en-tête) qui comprend : le nom de la méthode le type et le nom de chacun des paramètres formels (arguments) le type de la valeur retournée par la méthode (ou sinon void) les types des exceptions que la méthode peut générer divers modificateurs de méthode qui fournissent des informations supplémentaires sur certaines propriétés de la méthode La signature d'une méthode définit tout ce qu'il est nécessaire de savoir pour l'utiliser (pour l'utiliser à bon escient, une description du comportement est naturellement indispensable). La signature constitue une partie importante de la spécification de la méthode appelée aussi API (Application Programming Interface) En_tête_de_méthode { Corps_de_méthode L'en-tête de la méthode définit la signature de la méthode. Le corps de la méthode comprend les instructions qui seront exécutées lors de l'invocation de la méthode. Remarque : Contrairement à d'autres langages (Ada, C++,...) qui imposent ou permettent de placer dans des unités de compilation séparées les spécifications (en-têtes) et implémentations (corps), le langage Java groupe ces deux éléments dans une unique structure. EIA-FR / Jacques Bapst PR1_04 5 EIA-FR / Jacques Bapst PR1_04 7 Java / Méthodes Méthodes [3] Java / Méthodes En-tête de méthode La syntaxe pour déclarer l'en-tête de la méthode est la suivante : Modificateurs Type de retour de la méthode Nom de la méthode Liste des paramètres formels [ modificateurs ] type nom ( liste_param ) [ throws exceptions ] Variable locale public static int max(int a, int b) { int r = a; if (b > a) r = b; return r;... int v = max(k,3);... Valeur de retour (Expression) Invocation (appel) de la méthode avec les paramètres effectifs En-tête de la méthode (signature) Corps de la méthode modificateurs : Un ou plusieurs mots-clés séparés par des espaces. Ils définissent certaines propriétés de la méthode (visibilité, etc). Optionnel [public, private, protected, final, static, native, abstract, synchronized] type : nom : liste_param : exceptions : Définit le type de retour de la méthode (fonction). Si la méthode ne retourne pas de valeur, le type doit être void (vide) Nom de la méthode (même règles que pour les identificateurs). Liste de paramètres formels séparés par des virgules. Chaque paramètre est défini comme une variable locale (type nom). La liste de paramètres peut être vide (les parenthèses demeurent). Liste des types d'exceptions pouvant être générées par la méthode (les exceptions sont séparées par des virgules). Optionnel EIA-FR / Jacques Bapst PR1_04 6 EIA-FR / Jacques Bapst PR1_04 8

27 Java / Méthodes Corps de méthode Java / Méthodes Exemples de méthodes [2] { Instructions Le corps de la méthode est constitué d'une séquence d'instructions délimitées par des accolades. Des variables locales peuvent être déclarées, leur portée sera limitée au corps de la méthode (à partir de la déclaration). Si la signature de la méthode déclare un type de retour (autre que void), le corps de la méthode doit comprendre une instruction return suivie d'une expression compatible avec le type de retour déclaré dans la signature. Cette expression définit la valeur de retour de la méthode (la valeur restituée). // // Returns the max value between v1 and v2 // public static int max(int v1, int v2) { if (v1 > v2) return v1; else return v2; // // Method that calls other methods // public static double fcta(double a, int b, int c) { int temp = max(b, c); return square(a) / temp; EIA-FR / Jacques Bapst PR1_04 9 EIA-FR / Jacques Bapst PR1_04 11 Java / Méthodes Exemples de méthodes [1] Java / Méthodes Méthode main // // Method without parameter // Prints a separator line // public static void separate() { System.out.println(" "); // // Returns the square of the parameter val // public static double square(double val) { return val * val; La méthode main() joue un rôle particulier. C'est le point d'entrée d'une application Java (ce n'est pas le cas pour les applets qui doivent disposer des méthodes init() et start()). Elle est invoquée par la machine virtuelle lors du lancement de l'application. La méthode reçoit en argument un tableau de String contenant les éventuelles valeurs des paramètres de lancement (pour plus de détail consulter le slide intitulé Arguments sur la ligne de commande du chapitre consacré aux Entrées/Sorties). Sa signature est imposée. // // Main method (displays "Hello") // public static void main(string[] args) { System.out.println("Hello"); EIA-FR / Jacques Bapst PR1_04 10 EIA-FR / Jacques Bapst PR1_04 12

28 Java / Méthodes Utilité des méthodes Java / Méthodes Invocation de méthode [1] En Java, c'est pratiquement la seule construction permettant d'exécuter des instructions. Permet le découpage d'un problème en sous-problèmes plus simples. Améliore la lisibilité du code source (si le nom des méthodes est bien choisi, leur invocation donnera déjà au lecteur du code des informations précieuses sur le rôle de ces méthodes). Favorise le principe d'abstraction et d'encapsulation : l'utilisateur d'une méthode n'a pas à connaître tous les détails de l'implémentation; seule la spécification est nécessaire (notion de "boîte noire"). Permet la réutilisation des instructions (évite de dupliquer le code avec tous les inconvénients que cela comporte). L'invocation (l'appel) d'une méthode provoque l'exécution de ses instructions. Pour invoquer une méthode, on utilise son nom suivi de zéro, une ou plusieurs expressions séparées par des virgules et placées entre parenthèses. Les valeurs de ces expressions constituent les arguments (ou paramètres effectifs) de la méthode. Ils doivent correspondre en types (compatibilité) et en nombre à la liste définie dans la signature de la méthode. Syntaxe : Nom_de_la_méthode ( expr1, expr2,... ) Remarque :Les expressions constituant les paramètres effectifs sont évaluées de gauche à droite. C'est important dans des expressions du genre : f(f(a, f(b, c)), f(d, e)); EIA-FR / Jacques Bapst PR1_04 13 EIA-FR / Jacques Bapst PR1_04 15 Java / Méthodes Emplacement des méthodes En Java, toutes les méthodes doivent être déclarées au sein d'une classe. Il n'y a pas de méthodes globales. Contrairement à d'autres langages, Java n'autorise pas de créer directement une méthode à l'intérieur d'une autre méthode. Il n'y a pas d'imbrication de méthodes (à moins de créer une classe locale). Dans l'ordre des lignes du code source, les méthodes peuvent être invoquées (appelées) avant d'avoir été déclarées. Il est ainsi possible à deux méthodes de s'appeler mutuellement... public static void f(int i) { System.out.println("f(" + i + ")"); if (i>0) g(--i);.. public static void g(int j) { System.out.println("g(" + j + ")"); f(j);.. Java / Méthodes Invocation de méthode [2] Les méthodes définies sans type de retour (déclarées avec void) sont invoquées à la manière d'une instruction simple (donc suivies d'un point-virgule). separate(); // Les parenthèses sont obligatoires Les méthodes définies avec un type de retour sont généralement invoquées dans des expressions (affectation, paramètre effectif de méthode, ) mais peuvent également être invoquées comme des instructions simples (dans ce cas la valeur de retour n'est pas utilisée). double PI = ; double area, radius = 1.5; int error; String f = "config.ini"; area = PI * square(radius); error = readfile(f); readfile(f); // Invocation dans une expression // Invocation dans une expression // Invocation comme instruction simple EIA-FR / Jacques Bapst PR1_04 14 EIA-FR / Jacques Bapst PR1_04 16

29 Java / Méthodes Séquencement Java / Méthodes Passage de paramètres [2] Lors de l'invocation de méthodes, une pile d'appels est constituée de manière à pouvoir revenir au point d'invocation après l'exécution de la méthode (chemin de retour). public void p() { q(); public void q() { r(); public void r() { La méthode agit donc sur des copies locales des valeurs des expressions transmises en paramètres lors de l'invocation. A la sortie de la méthode (après l'exécution de la dernière instruction), les variables contenant les copies locales ne sont pas réassignées en retour (pas de "Copy Out"). A chaque invocation de la méthode, de l'espace mémoire est alloué pour enregistrer les valeurs des paramètres effectifs (ainsi que pour les autres variables locales déclarées dans la méthode). Cet espace mémoire est libéré à la sortie de la méthode. p(); q(); r(); Les variables contenant les copies locales des paramètres effectifs ainsi que les variables locales déclarées dans la méthode ne peuvent donc pas être utilisées en dehors du corps de la méthode. EIA-FR / Jacques Bapst PR1_04 17 EIA-FR / Jacques Bapst PR1_04 19 Java / Méthodes Passage de paramètres [1] Java / Méthodes Passage de paramètres [3] Lors de la définition d'une méthode, on déclare une liste (éventuellement vide) de paramètres formels qui peuvent être considérés comme des variables locales dans le corps de la méthode. Lors de l'invocation d'une méthode, on doit transmettre, pour chaque paramètre formel, une expression dont le type est compatible avec celui qui est déclaré dans la signature de la méthode. Ces expressions constituent les paramètres effectifs. Le passage des valeurs des paramètres peut s'assimiler à une assignation entre les variables constituées par les paramètres formels et les expressions qui représentent les paramètres effectifs. Illustration du mécanisme de passage de paramètres lors d'un appel de fonction. Dans l'exemple, le paramètre effectif (nb) est copié dans la variable locale représentant le paramètre formel (i) de la méthode triple(). public static void main(string[] args) { int nb = 4; int r = triple(nb); System.out.println("> " + nb + ", " + r); nb 4 i = nb; r 12 Cette assignation a lieu à l'entrée de la méthode (avant l'exécution de la première instruction). Ce mécanisme est appelé "Passage par valeur" (ou également mode "Copy In"). public static int triple(int i) { return 3*i; i 4 nb 4 i Console 4 > 4, 12 nb 4 EIA-FR / Jacques Bapst PR1_04 18 EIA-FR / Jacques Bapst PR1_04 20

30 Java / Méthodes Passage de paramètres [4] Le mécanisme qui a été vu pour le passage de paramètres de types primitifs s'applique également si les paramètres passés sont de types référence (des objets ou des tableaux). Dans ce cas, on aura donc une copie locale de la référence mais pas des valeurs référencées (c'est efficace à l'exécution mais peut induire des effets de bord dont il faut être conscient). Java / Méthodes Surcharge de méthodes [2] La technique consistant à définir plusieurs méthodes avec le même nom s'appelle la surcharge de méthode (Overloading). Lors de l'invocation d'une méthode surchargée, c'est le compilateur qui détermine (sur la base du profil des paramètres) la méthode qui doit être appelée. Le détail du passage de paramètres de type référence ainsi que les implications que peut induire ce mode de transfert seront décrits dans le chapitre suivant consacré aux tableaux. Conseil : Dans un contexte donné, plusieurs méthodes ne doivent porter le même nom que si les opérations effectuées ont une forte similitude sémantique. Il est possible de définir des méthodes comportant un nombre variable de paramètres. Comme cette syntaxe fait appel à des tableaux, elle sera décrite à la fin du chapitre suivant. Remarque : Contrairement à d'autres langages (Ada, C++,...), Java ne permet pas de surcharger les opérateurs (+, -, *, /, ==, ). EIA-FR / Jacques Bapst PR1_04 21 EIA-FR / Jacques Bapst PR1_04 23 Java / Méthodes Surcharge de méthodes (Overloading) Java / Méthodes Récursivité [1] Le langage Java permet de définir plusieurs méthodes avec le même nom pour autant que la liste des paramètres soit différente. Deux listes de paramètres sont différentes si : le nombre de paramètres est différent ou alors la liste ordonnée des types des paramètres est différente (Remarque : la deuxième règle est suffisante) On remarquera que : le type de retour de la méthode n'entre pas en considération le nom des paramètres formels non plus Exemples : public static int triple(int i) { return (i*3); public static float triple(float f) { return (f*3); C o m p l é m e n t Une méthode est dite récursive si elle s'invoque elle-même. public static long factorial(long x) { if (x<0) {... ; // Error if x is negative if (x==0) return 1; else return x * factorial(x-1); On parle de récursivité indirecte si la méthode m 1 en cours de déclaration invoque une autre méthode m 2 qui, elle, invoque m 1 dans ses instructions (directement ou indirectement). EIA-FR / Jacques Bapst PR1_04 22 EIA-FR / Jacques Bapst PR1_04 24

31 Java / Méthodes Récursivité [2] Les méthodes récursives doivent toujours contenir une instruction d'arrêt (généralement sous la forme d'une instruction if ( ) ) correspondant à un cas de base qui termine la récursivité (sous peine d'épuiser les ressources du système, notamment la mémoire). C o m p l é m e n t L'algorithme doit d'autre part garantir (dans toutes les situations) une convergence vers le cas de base (c'est-à-dire se rapprocher de l'instruction d'arrêt de la récursivité). Certains algorithmes se prêtent particulièrement bien à l'écriture de code récursif (parcours d'arbres, de graphes, fonctions mathématiques récurrentes,...). EIA-FR / Jacques Bapst PR1_04 25

32 Java / Tableaux Déclaration de tableaux [1] Informatique / Programmation Type_des_éléments [] Identificateur ; Déclaration de la variable identifiant l'objet de type tableau. La variable déclarée constitue une référence (sorte de pointeur vers une adresse mémoire) qui permet d'accéder au tableau. Programmation orientée objet avec Java 05 : Tableaux Le littéral null est une valeur particulière qui indique l'absence de référence (ou la référence vers rien). La taille du tableau n'est pas définie lors de sa déclaration mais seulement lors de sa création. Jacques Bapst [email protected] int[] intarray; // Déclaration d'un tableau de valeurs primitives int Point[] constellation; // Déclaration d'un tableau d'objets Point byte[][] matrix; // Déclaration d'un tableau de tableaux de byte EIA-FR / Jacques Bapst PR1_05 3 Java / Tableaux Tableaux Java / Tableaux Déclaration de tableaux [2] Un tableau est une séquence indexée d'éléments (valeurs) de même type. Il est caractérisé par sa taille (nombre d'éléments qu'il peut contenir) et par le type de ses éléments. Le type tableau est un type référence (comme les objets). Les éléments d'un tableau peuvent être des valeurs de types primitifs, des objets ou des tableaux. Il faut bien faire la distinction entre les deux étapes : -la déclaration du tableau ([]) qui crée une variable (référence) représentant un objet de type tableau -et la création du tableau (new) qui alloue l'espace mémoire pour enregistrer les éléments du tableau et initialise le contenu tab Type_des_éléments [] Identificateur = Initialisation ; Une expression d'initialisation peut être ajoutée à la déclaration; dans ce cas, le tableau est créé et la taille est déterminée par le résultat de l'expression d'initialisation. L'expression d'initialisation doit retourner un objet de type tableau compatible avec le type de la variable que l'on déclare. L'initialisation peut consister en une expression de création de tableau (avec l'opérateur new [voir pages suivantes] ). Une syntaxe particulière permet de spécifier un littéral tableau comme expression d'initialisation : {expr1, expr2, expr3,... (cette syntaxe, sans new, n'est autorisée que lors de la déclaration) char[] vowels= {'a','e','i','o','u','y'; EIA-FR / Jacques Bapst PR1_05 2 EIA-FR / Jacques Bapst PR1_05 4

33 Java / Tableaux Création de tableaux [1] Java / Tableaux Utilisation des tableaux [1] new Type_des_éléments [ Taille ] La taille du tableau (nombre d'éléments) est déterminée par l'expression entre crochets qui doit avoir une valeur entière positive (ou zéro); la taille ne doit pas obligatoirement être connue à la compilation. Une fois qu'un tableau est créé, sa taille ne peut plus varier. Les éléments du tableau sont initialisés à leurs valeurs par défaut (false pour les booléens, 0 pour tous les autres types primitifs, null pour les objets et les tableaux). L'opérateur new retourne une référence à l'objet tableau créé. int[] topten = new int[10]; // Tableau de 10 entiers (int) String[] text = new String[50]; // Déclaration et création simultanées byte[][] matrix = new byte[25][80]; Point[] constellation = new Point[astro.getDimension()]; Chaque élément d'un tableau est assimilé à une variable à laquelle on peut accéder individuellement. Par exemple : t[k]++ Chaque élément est identifié par un indice entier compris entre 0 et (n-1), n étant la taille du tableau L'accès aux éléments d'un tableau s'effectue de la manière suivante : Nom_tableau [ indice ] int[] tab; // Déclaration d'un tableau d'entiers (int) tab = new int[3]; // Création du tableau avec 3 éléments tab[0] = 7; // Assignation du premier élément tab[1] = 4; tab[2] = tab[0] + tab[1]; // Assignation et accès aux éléments EIA-FR / Jacques Bapst PR1_05 5 EIA-FR / Jacques Bapst PR1_05 7 Java / Tableaux Création de tableaux [2] Java / Tableaux Utilisation des tableaux [2] new Type_des_éléments [] {élém1, élém2,... Combinaison de la création d'un tableau avec l'initialisation de ses éléments (qui doivent être compatibles avec le type déclaré). La taille du tableau n'est pas spécifiée explicitement. Elle est déterminée par le nombre d'éléments énumérés entre les accolades (agrégat). Cette notation permet de créer des tableaux anonymes (non affectés à une variable) qui peuvent, par exemple, être passés en paramètre lors de l'invocation d'une méthode. // Exemple de tableau anonyme passé à la méthode askquestion String answer= askquestion("continue?", new String[] {"Yes", "No"); Le nombre d'éléments d'un tableau peut être obtenu à l'aide de l'attribut length qui est prédéfini pour tous les objets de type tableau (accessible en lecture uniquement). Exemple : nbelements = tab.length; Si, lors de l'accès à un élément d'un tableau, l'indice spécifié est négatif ou supérieur à l'indice du dernier élément (length -1), l'exception ArrayIndexOutOfBoundsException sera générée. L'expression qui détermine l'indice doit être de type byte, short, char ou int (le type long n'est pas autorisé). Le littéral null peut être utilisé pour représenter l'absence de tableau (comme pour tout autre objet) Exemple : char[] word = null; EIA-FR / Jacques Bapst PR1_05 6 EIA-FR / Jacques Bapst PR1_05 8

34 Java / Tableaux Tableaux multidimensionnels [1] Les tableaux peuvent avoir plusieurs dimensions. On parle alors de tableaux multidimensionnels (attention à ne pas confondre nombre de dimensions et taille du tableau). Un tableau multidimensionnel est un tableau de tableaux (de tableaux, de tableaux,...). Chaque paire de crochets ([]) représente une dimension (aussi bien pour la déclaration, la création que l'accès aux éléments) int[][] myarray = new int[2][3]; // Éléments initialisés à 0 Java / Tableaux Tableaux multidimensionnels [2] L'attribut length peut être consulté pour chacune des dimensions char[][] crossword = new char[5][10]; int nbrows = crossword.length; // nbrows=5 int nbcols = crossword[0].length; // nbcols=10 Lors de la création d'un tableau multidimensionnel, il n'est pas obligatoire de définir la taille de toutes les dimensions (cependant, la première dimension doit obligatoirement être définie). Par contre, si l'on définit les tailles, il faut le faire dans l'ordre, de gauche à droite. myarray // Ok, déclaration de la première dimension float[][][] colorpalette = new float[10][][]; // Ok, déclaration des deux premières dimensions float[][][] colorpalette = new float[10][20][]; // Erreur à la compilation! float[][][] colorpalette = new float[][20][]; EIA-FR / Jacques Bapst PR1_05 9 EIA-FR / Jacques Bapst PR1_05 11 Java / Tableaux Exemple d'utilisation Tableaux multidimensionnels [1] // // Multiplication table 0x0... 9x9 // int[][] multtable = new int[10][10]; // Éléments initialisés à 0 for (int i=0; i<multtable.length; i++) { for (int j=0; j<multtable[i].length; j++) { multtable[i][j] = i*j; Java / Tableaux Tableaux multidimensionnels [3] Pour les tableaux multidimensionnels, les valeurs littérales (initialiseurs) sont constituées par l'emboîtement d'accolades contenant les éléments de chacune des dimensions (reflet de la structure : tableau de tableaux). // // Tableau de 7 éléments dont chacun représente // un tableau de 5 éléments // int[][] multtable = { {0, 0, 0, 0, 0, {0, 1, 2, 3, 4, {0, 2, 4, 6, 8, {0, 3, 6, 9, 12, {0, 4, 8, 12, 16, {0, 5, 10, 15, 20, {0, 6, 12, 18, 24 ; EIA-FR / Jacques Bapst PR1_05 10 EIA-FR / Jacques Bapst PR1_05 12

35 Java / Tableaux Tableaux multidimensionnels [4] Les tableaux multidimensionnels étant des tableaux de tableaux, ils ne doivent pas obligatoirement être rectangulaires (ou cubiques ou...). // // Tableau de 7 éléments dont chacun représente // un tableau de taille variable // (tableau triangulaire) // int[][] multtable = { {0, {0, 1, {0, 2, 4, {0, 3, 6, 9, {0, 4, 8, 12, 16, {0, 5, 10, 15, 20, 25, {0, 6, 12, 18, 24, 30, 36 ; Java / Tableaux Représentation en mémoire [1] Chaque variable est associée à l'adresse d'une case mémoire Pour les types primitifs, la case mémoire contient la valeur Pour les types référence, la case mémoire contient une référence à la zone mémoire contenant l'objet ou le tableau Les illustrations qui suivent sont schématiques et servent à mettre en lumière le principe de fonctionnement (l'implémentation réelle peut être sensiblement différente) Variable de type primitif Variable Adresse Contenu int number = 122; number number Notation abstraite EIA-FR / Jacques Bapst PR1_05 13 EIA-FR / Jacques Bapst PR1_05 15 Java / Tableaux Tableaux multidimensionnels [5] Java / Tableaux Notation abstraite [1] Les éléments tableaux des tableaux multidimensionnels peuvent être définis dynamiquement y compris leur taille si elle n'a pas été déterminée lors de la déclaration. Déclaration de tableau int[] array; array // // Tableau de 100 éléments représentant chacun un // tableau de taille variable (créé dynamiquement). // Chaque élément du tableau est une chaîne de caractères. // String[][] s = new String[100][]; for (int i=0; i<s.length; i++) { s[i] = new String[(i%16)+1]; // Création dynamique du sous-tableau for (int j=0; j<s[i].length; j++) { s[i][j] = i + "/" + j; array= null; Création de tableau array= new int[4]; array array / La valeur null représente une référence vers rien Initialisation automatique des éléments à leurs valeurs par défaut EIA-FR / Jacques Bapst PR1_05 14 EIA-FR / Jacques Bapst PR1_05 16

36 Java / Tableaux Java / Tableaux Notation abstraite [2] Notation abstraite [3] Affectation des éléments du tableau Tableaux multidimensionnels array[0] = 8; array[1] = 17; array[2] = 5; array[3] = 1; array char[][] grid = { {'a', 'b', {'o', 'i', {'x', 'y', 'z' ; 0 1 'a' 'b' Déclaration et affectation combinées 0 char[] name= {'M','a','r','c'; char[] word= {'Z', 'u', 't'; grid 'o' 'i' name 'M' 'a' 'r' 'c' 'x' 'y' 'z' word 'Z' 'u' 't' Par extension, le même mécanisme s'applique aux tableaux comportant plus de deux dimensions EIA-FR / Jacques Bapst PR1_05 17 EIA-FR / Jacques Bapst PR1_05 19 Java / Tableaux Notation abstraite [3] Java / Tableaux Référence / Objet référencé [1] Affectation de tableaux name = word; name word 'M' 'a' 'r' 'c' 'Z' 'u' 't' Cette zone mémoire n'est plus référencée. Elle peut être effacée par le ramasse-miettes (Garbage Collector) Une référence peut être assimilée à un pointeur vers une adresse en mémoire (mais Java ne connaît pas de réels pointeurs). Les références sont opaques (contenu invisible) et ne peuvent pas être manipulées par le programmeur. De ce fait, les détails du mécanisme sous-jacent (détails d'implémentation) ne sont pas très importants car ils n'affectent pas le principe général de fonctionnement. Attention aux effets d'alias (couplage entre variables) System.out.println(name[1]); // 'u' word[1] = 'o'; System.out.println(name[1]); // 'o' En modifiant un élément de word, on modifie également le contenu de name! Avec les types référence, il faut toujours bien distinguer si l'on traite la référence (adresse) ou l'objet référencé (contenu). Cette distinction est très importante, notamment avec les opérateurs d'égalité (==), d'inégalité (!=) et d'affectation (=) ainsi que lors des passages en paramètre (invocation de méthodes). Ces remarques s'appliquent à tous les types référence, c'est-à-dire aux tableaux et aux objets (que nous verrons plus tard). EIA-FR / Jacques Bapst PR1_05 18 EIA-FR / Jacques Bapst PR1_05 20

37 Java / Tableaux Référence / Objet référencé [2] Comparaison et assignation de tableau et de contenu. char[] c1 = {'a', 'b', 'c'; char[] c2 = {'a', 'b', 'c'; char[] c3 = c1; if (c1 == c2) System.out.println("c1 égal à c2"); if (c1 == c3) System.out.println("c1 égal à c3"); if (c2 == c3) System.out.println("c2 égal à c3"); if (c1[0] == c2[0]) System.out.println("c1[0] == c2[0]"); if (c1[0] == c3[0]) System.out.println("c1[0] == c3[0]"); if (c2[0] == c3[0]) System.out.println("c2[0] == c3[0]"); c3[0] = 'z'; if (c1[0] == c3[0]) System.out.println("c1[0] == c3[0]"); if (c2[0] == c3[0]) System.out.println("c2[0] == c3[0]"); Java / Tableaux Passage de tableaux en paramètre [1] Le mécanisme de passage de paramètres qui a été vu dans le chapitre consacré aux méthodes s'applique également aux types référence et notamment aux tableaux. Le passage par valeur de la référence (avec copie locale de cette dernière) a cependant des implications qu'il est important de bien comprendre. Dans ce cas, la méthode peut accéder et modifier les valeurs référencées car c'est la référence à l'objet qui est assignée à la copie locale (paramètre effectif) lors de l'invocation. On a donc une copie locale de la référence mais pas des valeurs référencées (c'est efficace à l'exécution mais peut induire des effets de bord non souhaités). Remarque: Une méthode qui modifie l'état de certains objets ou tableaux passés en paramètres doit clairement l'indiquer dans sa spécification (description). EIA-FR / Jacques Bapst PR1_05 21 EIA-FR / Jacques Bapst PR1_05 23 Java / Tableaux Référence / Objet référencé [3] Java / Tableaux Passage de tableaux en paramètre [2] Dans l'exemple ci-dessous, la méthode max() reçoit, au moment de son l'appel, une copie de la référence du tableau numbers (paramètre effectif) dans la variable t (paramètre formel). Quand le sage montre la lune, l'imbécile regarde le doigt! public static void main(string[] args) { int[] numbers = {3, 2, 4, 2; int nmax = max(numbers); System.out.println("Greatest: " + nmax); numbers Lao-Tseu public static int max(int[] t) { int max = t[0]; for (int i=0; i<t.length; i++) { if (t[i]>max) max = t[i]; return max; t Console Greatest: 4 EIA-FR / Jacques Bapst PR1_05 22 EIA-FR / Jacques Bapst PR1_05 24

38 Java / Tableaux Passage de tableaux en paramètre [3] Java / Tableaux Méthodes avec paramètre variable [2] Le mécanisme a pour conséquence que la méthode max() peut, si elle le souhaite, modifier le contenu du tableau t et donc celui de numbers car c'est la même zone mémoire (alias sur les références)! Dans le corps de la méthode, les valeurs du paramètre variable sont lues comme les éléments d'un tableau (selon le type déclaré). Exemple : public static void main(string[] args) { int[] numbers = {3, 2, 4, 2; int nmax = max(numbers); System.out.println("Greatest: " + nmax); public static int max(int[] t) { t[1] = 9; // Caution: side effect! int max = t[0]; for (int i=0; i<t.length; i++) { if (t[i]>max) max = t[i]; return max; numbers t Console Greatest: C o m p l é m e n t public static void disperrors(int cause, String... errtext) {... for (int k=0; k<errtext.length; k++) { System.out.println(errText[k]);... Cette méthode disperrors() pourra être invoquée avec un nombre variable d'arguments : disperrors(2, "Erreur fatale"); disperrors(7, "Erreur de lecture", "Le fichier n'existe pas"); disperrors(5, "Erreur", "Accès bloqué", "Compte expiré"); disperrors(0); EIA-FR / Jacques Bapst PR1_05 25 EIA-FR / Jacques Bapst PR1_05 27 Java / Tableaux Méthodes avec paramètre variable [1] Java / Tableaux Boucle for revisitée (for-each) [1] C o m p l é m e n t Il est possible de définir des méthodes comportant un nombre variable de paramètres. Le mécanisme de passage des paramètres variables repose sur une mise en tableau automatique. Il s'agit seulement d'une simplification de la syntaxe de déclaration et d'invocation de la méthode. Syntaxe de déclaration d'un paramètre variable : Exemple : Type... NomDuParamètre public static void disperrors(int cause, String... errtext) Une méthode ne peut comporter qu'un seul paramètre variable et il doit être le dernier dans la liste des paramètres formels. Dans l'exemple donné, les paramètres seront transmis dans un tableau de chaînes de caractères String[] (le mécanisme est simplement masqué). C o m p l é m e n t A partir de la version 1.5 du langage, une syntaxe complémentaire a été introduite pour l'instruction for. Elle permet de parcourir tous les éléments d'un tableau ou d'une collection de données (itérateur) en utilisant une syntaxe allégée : for ( type elem : tableau ) instruction Cette forme de l'instruction for est parfois appelée for-each Exemple : boolean[] message = new boolean[200];... for (boolean elem : message) { if (elem) System.out.println("-"); else System.out.println(".");... EIA-FR / Jacques Bapst PR1_05 26 EIA-FR / Jacques Bapst PR1_05 28

39 Java / Tableaux Boucle for revisitée (for-each) [2] C o m p l é m e n t En utilisant cette nouvelle syntaxe, l'exemple donné précédemment pour illustrer les méthodes avec paramètres variables pourrait être codé ainsi : public static void disperrors(int cause, String... errtext) {... for (String text : errtext) { System.out.println(text);... Le symbole ":" se lit "in" ("dans"). Cette nouvelle syntaxe ne remplace pas la syntaxe de base (elle la simplifie dans certaines situations particulières). Chaque fois que l'on doit accéder à l'itérateur (par exemple l'indice du tableau) dans le corps de la boucle cette syntaxe ne peut pas être utilisée. EIA-FR / Jacques Bapst PR1_05 29 Java / Tableaux Méthodes utilitaires C o m p l é m e n t La classe Arrays (du package java.util) définit une série de méthodes statiques utilitaires permettant de manipuler des tableaux : Assignation d'une valeur à certains éléments d'un tableau.. fill() Test d'égalité du contenu de deux tableaux.. equals() Tri du contenu d'un tableau.. sort() Conversion d'un tableau en liste (List). aslist() Recherche binaire dans un tableau trié.. binarysearch() La classe System (du package java.lang) contient une méthode statique arraycopy() permettant de copier les éléments spécifiés d'un tableau dans un autre tableau, à une position donnée (attention :copie au premier niveau seulement [Shallow copy]). Le second tableau doit être du même type que le premier. Il peut même s'agir du même tableau. La méthode clone() de la classe Object peut également être utilisée pour copier le contenu d'un tableau (Shallow copy) : int[] b = (int[])a.clone(); EIA-FR / Jacques Bapst PR1_05 30

40 Java / Exceptions Avantages des exceptions Informatique / Programmation Augmentent la lisibilité du code en séparant les instructions qui traitent le cas normal des instructions nécessaires au traitement des erreurs ou des événements exceptionnels. Permettent (voire imposent) la déclaration explicite des exceptions qu'une méthode peut lever (fait partie de la signature). Programmation orientée objet avec Java 06 : Les exceptions et leur traitement Forcent le programmeur à prendre en compte (traiter ou propager) les cas exceptionnels (erreurs ou autres événements) qui sont déclarés dans les méthodes qu'il invoque. Permettent de créer une hiérarchie d'événements et de les traiter avec une granularité différente selon les situations. Jacques Bapst [email protected] Offrent un mécanisme de propagation automatique ce qui permet au programmeur de choisir à quel niveau il souhaite traiter l'exception (celui auquel il est à même de prendre les mesures adéquates). EIA-FR / Jacques Bapst PR1_06 3 Java / Exceptions Exceptions Java / Exceptions Gestion des exceptions Les exceptions représentent des événements qui peuvent survenir durant l'exécution d'un programme et qui rompent le flux normal des instructions. Les exceptions sont principalement utilisées pour représenter des erreurs de différents types : des erreurs matérielles (crash du disque,...) des erreurs de programmation (indice d'un tableau hors limites,...) des erreurs liées à l'environnement d'exécution (mémoire insuffisante,...), des erreurs spécifiques à une librairie (matrice singulière) ou à une application (numéro d'article non-défini), etc. Les exceptions peuvent également représenter des événements qui en sont pas à proprement parler des erreurs, mais qui correspondent à des situations exceptionnelles (prévues) qui doivent être traitées de manières différentes du flux normal des opérations (par exemple la fin d'un fichier, un mot de passe incorrect, des ressources momentanément non-disponibles, ). En Java, les exceptions sont représentées par des objets de type Throwable. Il existe plusieurs familles d'exceptions représentées par différentes sous-classes de Throwable (par ex. Exception). Différentes instructions permettent de gérer les exceptions. L'instruction throw sert à générer une exception (on dit également lever une exception, lancer une exception, ). L'instruction try / catch / finally constitue le cadre dans lequel les exceptions peuvent être détectées (capturées) et traitées. Le mot-clé throws (à ne pas confondre avec throw) est utilisé dans la déclaration de méthode (signature) pour annoncer la liste des exceptions que la méthode peut générer. L'utilisateur de la méthode est ainsi informé des exceptions qui peuvent survenir lors de son invocation et peut prendre les mesures nécessaires pour gérer ces événements exceptionnels (c'est-à-dire les traiter ou les propager). EIA-FR / Jacques Bapst PR1_06 2 EIA-FR / Jacques Bapst PR1_06 4

41 Java / Exceptions Générer (lever) une exception [1] Les exceptions peuvent être générées soit : par le système, lors de l'exécution de certaines instructions par l'exécution de l'instruction throw (dans les classes pré-définies de la plate-forme Java [librairies] ou dans le code que l'on écrit soi-même) Parmi les instructions qui génèrent des exceptions, on peut citer : La division entière par zéro qui génère ArithmeticException L'indexation d'un tableau hors de ses limites qui génère ArrayIndexOutOfBoundsException L'utilisation d'un tableau ou objet dont la référence vaut null qui génère NullPointerException La création d'un tableau avec une taille négative qui génère NegativeArraySizeException La conversion d'un objet dans un type non compatible qui génère ClassCastException Java / Exceptions Traiter une exception [1] Les instructions susceptibles de lever des exceptions peuvent être insérées dans un bloc try / catch qui se présente de la manière suivante : try { // Bloc contenant des instructions pouvant générer des exceptions. catch (ExceptionType1 e1) { // Bloc contenant les instructions qui traitent (capturent) les exceptions // du type ExceptionType1 (ou d'une de ses sous-classes) // On peut référencer l'objet exception à l'aide de la variable e1. catch (ExceptionType2 e2) { // Bloc contenant les instructions qui traitent (capturent) les exceptions // du type ExceptionType2 (ou d'une de ses sous-classes). // On peut référencer l'objet exception à l'aide de la variable e2. catch ( ) { // Et ainsi de suite EIA-FR / Jacques Bapst PR1_06 5 EIA-FR / Jacques Bapst PR1_06 7 Java / Exceptions Générer (lever) une exception [2] Pour générer explicitement une exception, on utilise l'instruction throw : throw exception_object ; L'expression qui suit l'instruction throw doit être un objet qui représente une exception (un objet de type Throwable). Lors de la création de l'objet exception, on peut généralement lui associer un message (String) qui décrit l'événement. public static long factorial(int x) throws Exception { long result = 1; if (x<0) throw new Exception("x doit être >= 0"); while (x > 1) { result *= x; x--; return result; Java / Exceptions Traiter une exception [2] Si une des instructions contenues dans le bloc try, lève une exception, le contrôle est passé au premier bloc catch dont le type d'exception correspond à l'exception qui a été levée (même classe ou classe parente de l'exception levée). Après l'exécution de la dernière instruction du bloc catch considéré, le contrôle est passé à l'instruction qui suit le dernier bloc catch (ou à la clause finally s'il y en a une). Si aucun bloc catch ne correspond au type d'exception qui a été levée, l'exception est propagée au niveau supérieur c'est-à-dire que le contrôle est transféré au traitement d'exception de la méthode invoquante ou du bloc englobant. Si aucun traitement n'existe au niveau supérieur pour ce type d'exception, la propagation se poursuit jusqu'à trouver un bloc catch traitant cette exception. Si ce n'est pas le cas, le programme se termine avec un message d'erreur sur la console de sortie (Stack Trace). EIA-FR / Jacques Bapst PR1_06 6 EIA-FR / Jacques Bapst PR1_06 8

42 Java / Exceptions Traiter une exception [3] Java / Exceptions Traiter une exception [5] try { instr1; Une exception a été générée instr2; instr3; catch (ClockException ce) { instr4; instr5; catch (NegativeArgExc na) { instr6; instr7; catch ( ) { Oui Oui Oui Non Non Non Est-elle du type ClockException? Est-elle du type NegativeArgExc? Est-elle du type? Il est possible de traiter plusieurs types d'exceptions dans une seule clause catch en utilisant le symbole ' ' comme séparateur. Les exceptions mentionnées dans une telle liste doivent être "indépendantes" sur le plan de leur relation hiérarchique. Une des exceptions ne peut pas être un ancêtre (super-classe) d'une autre (dans ce cas, mentionner l'exception ancêtre suffit pour traiter toutes celles de sa "famille"). try { catch (UnknownUser IncorrectPassword loginerror) { catch (Exception othererror) { Suite des instructions Propagation au niveau supérieur EIA-FR / Jacques Bapst PR1_06 9 EIA-FR / Jacques Bapst PR1_06 11 Java / Exceptions Traiter une exception [4] Les divers types d'exception peuvent appartenir à différentes familles (voir hiérarchie de classes, en fin de chapitre). Une exception spécialisée (par ex. FileNotFoundException) peut faire partie d'une famille plus vaste (IOException) qui elle-même fait partie d'une famille plus générale (Exception) etc. Si plusieurs clause catch sont compatibles avec le type d'exception qui a été levée (font partie de la même famille), c'est la première qui capturera l'exception et se chargera du traitement. try { catch (FileNotFoundException notfound) { catch (IOException ioerr) { catch (Exception generr) { L'ordre des clauses catch est important! Java / Exceptions Traiter une exception [6] Lorsqu'un problème a été détecté (une exception a été générée) et que l'on est en mesure de le traiter (au moins partiellement), il y a différentes mesures que l'on peut envisager, selon les cas, pour régler la situation. Dans un traitement d'exception (bloc catch) on peut par exemple : Régler le problème et recommencer le traitement (nécessite généralement un boucle). Idéal mais pas toujours possible. Faire quelque chose d'autre à la place (algorithme de substitution). Sortir de l'application (System.exit()) après affichage d'un message (et/ou de la Stack-Trace), écriture dans un fichier log, etc. Re-générer l'exception (après avoir effectué certaines opérations). Générer une nouvelle exception (après avoir éventuellement effectué certaines opérations). Retourner une valeur spéciale ou valeur par défaut (pour une fonction). Terminer la méthode (si elle n'a pas de valeur de retour). Ne rien faire (ou afficher un message) et continuer (c'est rarement une bonne solution). EIA-FR / Jacques Bapst PR1_06 10 EIA-FR / Jacques Bapst PR1_06 12

43 Java / Exceptions Propagation des exceptions [1] Java / Exceptions Propagation des exceptions [3] public class PropEx { public static void main(string[] args) { System.out.println("main starts"); b(5); b(0); System.out.println("main ends"); // // b // public static void b(int i) { System.out.println("b starts"); try { System.out.println("b step 1"); c(i); System.out.println("b step 2"); catch (Exception e) { System.out.println("b catches " + e); System.out.println("b ends"); // Suite... EIA-FR / Jacques Bapst PR1_06 13 Dans le programme PropEx, lors de la deuxième invocation de la méthode b(), une exception sera levée dans la méthode d() (division par zéro). Le déroulement de l'application sera alors altéré et l'exception sera propagée jusqu'à la méthode b() qui dispose d'un bloc catch pour traiter cette exception. b(5) 1 ère invocation main starts b starts b step 1 c starts d starts d ends c ends b step 2 b ends b(0) 2 ème invocation b starts b step 1 c starts d starts b catches ArithmeticException: / by zero b ends main ends EIA-FR / Jacques Bapst PR1_06 15 Java / Exceptions // Suite Propagation des exceptions [2] // // c // public static void c(int i) throws Exception { System.out.println("c starts"); d(i); System.out.println("c ends"); // // d // public static void d(int i) throws Exception { System.out.println("d starts"); int a=10/i; // Cette instruction peut générer une exception System.out.println("d ends"); Java / Exceptions Interprétation de la Stack-Trace [1] Si, dans l'exemple précédent (PropEx), on supprime tout traitement d'exception, l'exception provoquée par la division par zéro (dans la méthode d()) sera propagée jusqu'à la méthode main() qui sera alors interrompue avec affichage du nom de l'exception et de l'état de la pile des appels (Stack-Trace) : java.lang.arithmeticexception: / by zero at javabasic.propex.d(propex.java:43) at javabasic.propex.c(propex.java:37) at javabasic.propex.b(propex.java:24) at javabasic.propex.main(propex.java:13) Exception in thread "main" Il est important de savoir interpréter ces informations de manière à localiser rapidement la cause du problème qui a causé l'interruption de l'application et agir au bon endroit. La page suivante décrit comment interpréter cette Stack-Trace. EIA-FR / Jacques Bapst PR1_06 14 EIA-FR / Jacques Bapst PR1_06 16

44 Java / Exceptions Interprétation de la Stack-Trace [2] Java / Exceptions Clause finally [2] La Stack-Trace décrit (dans l'ordre inverse) la séquence (pile) des appels qui ont conduit à l'interruption de l'application. java.lang.arithmeticexception: / by zero at javabasic.propex.d(propex.java:43) at javabasic.propex.c(propex.java:37) at javabasic.propex.b(propex.java:24) at javabasic.propex.main(propex.java:13) Exception in thread "main" Un bloc finally est généralement utilisé pour effectuer des opérations de conclusion (fermeture de fichiers, de connexion réseau, de base de données, etc.) qui devraient être effectuées dans tous les cas de figure. La première ligne affichée correspond au type d'exception qui a été générée (avec, éventuellement, le texte du message qui lui est associé). On trouve ensuite l'enchaînement des invocations de méthodes où chacune des lignes est structurée de la manière suivante : at Package.Classe.Méthode(Fichier_Source:No_de_ligne) Dans le cas d'une application, on trouvera sur la dernière ligne de la séquence des appels, la méthode main() qui constitue le point d'entrée du programme. Le bloc finally évite donc de devoir placer ces instructions de conclusion dans le bloc try et dans tous les blocs catch. L'utilisation des instructions break, continue, return ou throw (dans les blocs try ou catch) n'empêche pas l'exécution préalable du bloc finally. Le bloc finally est optionnel mais un bloc try doit obligatoirement être accompagné d'au moins un bloc catch ou d'un bloc finally (ou naturellement des deux). EIA-FR / Jacques Bapst PR1_06 17 EIA-FR / Jacques Bapst PR1_06 19 Java / Exceptions Clause finally [1] Java / Exceptions Clause finally [3] Une clause finally peut être ajoutée à une instruction try / catch. Cette clause définit un bloc d'instructions qui seront exécutées à la fin de l'instruction try / catch indépendamment du fait que des exceptions aient été levées ou non. Le bloc finally sera exécuté dans tous les cas. Si aucune exception n'est levée dans le bloc try, le bloc finally sera exécuté après la dernière instruction du bloc try. Si une exception est levée dans le bloc try et est capturée par un bloc catch, le bloc finally sera exécuté après la dernière instruction du bloc catch. Si une exception est levée dans le bloc try et n'est pas capturée par un bloc catch, le bloc finally sera exécuté avant la propagation de l'exception au niveau supérieur. Exemple d'utilisation de la clause finally : try { openfile(f); content= readfile(f); print(content); catch (InvalidData invdat) { System.out.println("Les données du fichier sont erronées"); catch (PrintError prerr) { System.out.println("Erreur durant l'impression"); finally { closefile(f); //--- Effectué dans tous les cas EIA-FR / Jacques Bapst PR1_06 18 EIA-FR / Jacques Bapst PR1_06 20

45 Java / Exceptions Objet exception Java / Exceptions Exceptions contrôlées / non-contrôlées L'objet exception sert principalement de marqueur pour l'événement qui lui est associé. Dans un traitement d'exception (bloc catch), l'objet exception est transmis et il peut être utilisé pour obtenir plus d'informations concernant l'événement. Quelques méthodes que l'on peut utiliser avec les objets exception : getmessage() tostring() printstacktrace() getstacktrace() : retourne un String contenant le message (texte) associé à l'exception : retourne un String contenant le nom de l'exception suivi du message associé : affiche sur la console de sortie le nom de l'exception, le message associé ainsi que l'état de la pile des appels qui ont conduit au traitement de l'exception (Stack-Trace) : retourne les informations de la Stack-Trace sous forme d'un tableau de StackTraceElement Les exceptions contrôlées (checked) [du type Exception] doivent être soit traitées (dans une clause catch), soit propagées pour être traitées à un niveau supérieur (annoncée avec throws dans l'en-tête). Elle ne peuvent pas être ignorées (le compilateur génère une erreur dans ce cas). Pour les exceptions non-contrôlées (unchecked) [du type RuntimeException ou Error], le programmeur a le choix de les traiter ou de les ignorer (sans erreur à la compilation). Si une telle exception survient et qu'elle n'est traitée nulle part, elle sera alors propagée et "remontera" jusqu'à la méthode main() interrompant ainsi brutalement l'application. EIA-FR / Jacques Bapst PR1_06 21 EIA-FR / Jacques Bapst PR1_06 23 Java / Exceptions Hiérarchie de classes Java / Exceptions La classe Error Dans le langage Java, toutes les exceptions sont représentées par des objets qui spécialisent la classe de base Throwable. Trois sous-classes de Throwable sont pré-définies : Error, Exception et RuntimeException selon l'arborescence suivante : Error Exceptions non-contrôlées Throwable RuntimeException Exception Exceptions contrôlées EIA-FR / Jacques Bapst PR1_06 22 La classe Error représente généralement des erreurs sévères qui surviennent dans la machine virtuelle. Le langage n'impose par que les programmeurs traitent ce type d'exceptions car elles ne devraient pas survenir dans un environnement sain (machine virtuelle correctement installée). On ne traite généralement pas ce type d'exceptions dans une application standard sauf éventuellement au niveau le plus haut pour informer l'utilisateur (si c'est encore possible) et éviter le crash brutal de l'application. D'autre part, les applications ne devraient pas générer (dans des instructions throw) ce genre d'exceptions. Exemples : OutOfMemoryError, StackOverflowError, AssertionError (Erreur de conception) EIA-FR / Jacques Bapst PR1_06 24

46 Java / Exceptions La classe Exception Java / Exceptions Créer de nouveaux types d'exceptions La classe Exception représente la classe de base de la plupart des exceptions qui sont générées (throw) et traitées (catch) dans les applications (exceptions contrôlées). Un grand nombre de sous-classes de Exception sont pré-définies dans les classes de la plate-forme Java Exemples : PrintException, IOException Les exceptions spécifiques à une librairie ou à une application sont généralement représentées par des sous-classes de Exception. La classe RuntimeException représente une sous-classe particulière de Exception (voir page suivante). Le langage impose que les exceptions de type Exception (qui ne sont pas une sous-classe de RuntimeException) soient traitées par les applications (en plaçant les instructions critiques dans un bloc try / catch, ou en déclarant l'exception dans la signature de la méthode à l'aide du mot-clé throws déléguant ainsi le traitement au niveau supérieur). EIA-FR / Jacques Bapst PR1_06 25 Pour créer ses propres types d'exceptions, il suffit de dériver (spécialiser) une classe de type Throwable (choisir une des classes existantes proche de celle que l'on souhaite créer ou, sinon, dériver la classe générale Exception). Généralement, dans cette sous-classe, on crée uniquement deux constructeurs : un constructeur sans paramètre et un constructeur qui prend un message (String) en paramètre. On crée rarement de nouveaux champs ou de nouvelles méthodes. public class ClockException extends Exception { public ClockException() { super(); public ClockException(String message) { super(message); EIA-FR / Jacques Bapst PR1_06 27 A prendre tel quel pour l'instant (sera étudié ultérieurement) Java / Exceptions La classe RuntimeException La classe RuntimeException représente une sous-classe particulière (exceptions non-contrôlées) de la classe Exception. Elle représente des erreurs qui sont détectées par la machine virtuelle durant l'exécution de l'application. Par exemple, l'exception NullPointerException indique que la référence à un objet n'est pas définie (null). Cette exception peut potentiellement survenir lors de l'exécution de n'importe quelle instruction qui manipule un objet. De ce fait, le langage n'impose pas que les exceptions de type RuntimeException (et de ses sous-classes) soient traitées par les applications (ce qui serait extrêmement lourd et contraignant). Si nécessaire, les applications peuvent cependant traiter ce type d'exceptions (dans un bloc try / catch) et prendre ainsi les mesures adéquates. Exemples : ArithmeticException, ArrayIndexOutOfBoundsException Java / Exceptions Utiliser des exceptions personnalisées L'utilisation des types d'exceptions que l'on a créés est identique à l'utilisation des types d'exceptions pré-définis. if (hour < 0 hour > 23) { throw new ClockException("Heure incorrecte"); try { catch (ClockException clockerr) { System.out.println(clockErr); catch (Exception othererr) { EIA-FR / Jacques Bapst PR1_06 26 EIA-FR / Jacques Bapst PR1_06 28

47 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Comparaison de chaînes Informatique / Programmation Programmation orientée objet avec Java 07 : Chaînes de caractères Jacques Bapst [email protected] Comme pour tous les types référence, l'opérateur "==" compare les références et non pas les objets référencés (les chaînes de caractères). La méthode equals() permet, elle, de comparer deux chaînes de caractères (objets référencés) et retourne true si elles sont égales. La méthode compareto() remplace les opérateurs "plus petit", "égal", "plus grand" en utilisant l'ordre lexicographique (ordre du dictionnaire) et en retournant respectivement une valeur (int) négative, 0 ou positive. String mystring = "abc"; String otherstr = "abcdef"; if (mystring == otherstr) System.out.println("Same string object"); if (mystring.equals(otherstr)) System.out.println("Same contents"); if (mystring.compareto(otherstr) < 0) System.out.println(myString + " smaller than " + otherstr); EIA-FR / Jacques Bapst PR1_07 3 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Chaînes de caractères (String) En Java les chaînes de caractères sont représentées par des objets de type String (une classe prédéfinie). Les chaînes de caractères ne font donc pas partie des types primitifs mais sont des types référence. Une syntaxe particulière est utilisée pour définir des littéraux de type String : on entoure le texte avec des guillemets (" "). On peut insérer des séquences d'échappement (identiques à celles définies pour le type char) dans les littéraux de type String. La déclaration et création d'une variable de type String s'effectue de la manière suivante : String sometext = "Hello"; sometexte "Hello" Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Objets String immuables Les objets de type String sont immuables : une fois créés ils ne peuvent plus être modifiés. Naturellement, la variable de type référence peut changer de valeur, et pointer vers une nouvelle chaîne (créée à un autre emplacement). String sometext = "Hello"; sometext = "Bonjour"; sometext "Hello" "Bonjour" Les objets immuables ont l'avantage de pouvoir être partagés sans risque et l'on évite les problèmes d'alias ( optimisations possibles). Par contre, si l'on manipule fréquemment des objets de type String (à l'intérieur de boucles par exemple) cela peut conduire à la création d'un nombre considérable d'objets (temporaires) avec un coût non négligeable (ressources mémoires et temps d'exécution). Il est préférable dans ce cas de déclarer et utiliser des objets de type StringBuffer ou StringBuilder qui sont eux modifiables (voir pages suivantes). EIA-FR / Jacques Bapst PR1_07 2 EIA-FR / Jacques Bapst PR1_07 4

48 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Opérations sur les chaînes [1] Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Opérations sur les chaînes [3] L'opérateur "+" permet de concaténer (mettre bout à bout) des chaînes de caractères. Si un des deux opérandes de l'opérateur "+" est un String, l'autre opérande sera, si nécessaire, automatiquement converti en un objet de type String (par invocation de la méthode tostring()). String mytext = "Hello"; String String s1 = mytext + " Mark"; rec = "Hello" + s ')'; Remarque :Les objets de type String étant immuables, la concaténation est implémentée en créant un objet temporaire de type StringBuffer qui est utilisé ensuite pour créer un nouvel objet de type String. C'est donc une opération assez lourde. La classe String dispose d'un grand nombre de méthodes pour traiter les chaînes de caractères. Les exemples qui suivent n'en sont qu'une illustration sommaire. La méthode length() permet de connaître la longueur d'une chaîne de caractères (nombre de caractères). La méthode charat() permet de retrouver le caractère situé à la position n d'une chaîne (0 n length() -1). La méthode substring() retourne une sous-chaîne d'une chaîne donnée. Les paramètres déterminent la position initiale et la position finale (+1) de la sous-chaîne dans la chaîne originelle. String name = "James Bond"; int i = name.length(); // i = 10 char c = name.charat(1); // c = 'a' String s = name.substring(2, 4); String t = "Yes".toUpperCase(); // s = "me" // t = "YES" EIA-FR / Jacques Bapst PR1_07 5 EIA-FR / Jacques Bapst PR1_07 7 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Opérations sur les chaînes [2] Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Opérations sur les chaînes [4] Différentes méthodes permettent de convertir des valeurs de types primitifs en objets de type String et inversement (voir la tabelle qui figure à la fin du premier chapitre du document de cours). Ces méthodes se trouvent soit dans la classe String, soit dans les classes Wrapper associées aux types primitifs ( Byte, Short, Integer, Long, Float, Double, Character, Boolean). Dans les librairies de base, il existe souvent plusieurs méthodes pour effectuer un même type de conversion. int i = Integer.parseInt("43"); 43 double d = Double.parseDouble("3.14"); 3.14 String s = String.valueOf('Z'); boolean b = (i > 10); String t = (new Boolean(b)).toString(); String t = Boolean.toString(b); // Idem "Z" true "true" "true" C o m p l é m e n t La méthode split() permet de découper une chaîne de caractères sur la base d'un séparateur qui est exprimé sous la forme d'une expression régulière (regex). La méthode retourne le résultat dans un tableau de String qui contient les fragments découpés. La syntaxe à utiliser pour les expressions régulières est définie dans la classe Pattern (java.util.regex). public static void main(string[] args) { String String[] elems; path = "usr/lib/ruby/test.rb"; String seppattern1 = "/"; elems = path.split(seppattern1); // Slash separator String seppattern2 = "/ \\."; // Slash or dot separator elems = path.split(seppattern2); elems Æ {"usr", "lib", "ruby", "test.rb" elems Æ {"usr", "lib", "ruby", "test", "rb" EIA-FR / Jacques Bapst PR1_07 6 EIA-FR / Jacques Bapst PR1_07 8

49 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Formatage de chaînes [1] Classe StringBuffer [1] C o m p l é m e n t A partir de la version 1.5 du langage, une méthode de formatage assez puissante a été introduite dans la classe String. Cette méthode statique nommée format() retourne une chaîne de caractères formatée et prend en paramètre une chaîne de formatage (qui doit respecter une certaine syntaxe), ainsi qu'un nombre variable d'arguments (de type Object ou de types primitifs qui seront automatiquement convertis par le nouveau mécanisme d'autoboxing). Exemple : String s =String.format("%.2f", v); dans ce cas, si v = f, alors s ="1.57" C o m p l é m e n t Contrairement à la classe String, la classe StringBuffer permet de créer des chaînes de caractères modifiables (la taille et le contenu peuvent varier durant l'exécution de l'application). La notion de capacité (Capacity) représente la taille du buffer interne qui mémorise la chaîne de caractères (nombre total de caractères disponibles avant de devoir agrandir la taille du buffer interne). La capacité est automatiquement augmentée lorsque c'est nécessaire. La capacité initiale peut être définie lors de la création d'un objet StringBuffer (paramètre du constructeur, 16 par défaut). Ne pas confondre capacité et longueur d'un objet StringBuffer. La syntaxe de la chaîne de formatage est relativement complexe et sa description se trouve dans l'api de la classe Formatter (du package java.util) U n t e x t e length() = 8 capacity() = 20 EIA-FR / Jacques Bapst PR1_07 9 EIA-FR / Jacques Bapst PR1_07 11 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Formatage de chaînes [2] Classe StringBuffer [2] C o m p l é m e n t Cette nouvelle méthode de formatage est largement inspirée de celle de la méthode printf() que l'on trouve dans le langage C (elle n'est pas totalement équivalente mais très fortement compatible). Une méthode printf() a d'ailleurs été ajoutée dans la classe PrintStream et peut donc être invoquée sur les flux de sortie System.out et System.err. Exemples : int i = 250; float v = f; System.out.printf("v with 3 digits %.3f %n", v); System.out.printf("Hex/Octal %1$x/%1$o %n", i); System.out.printf("%5d%8.3f %n", i, v); C o m p l é m e n t Pour créer un objet de type StringBuffer, on doit utiliser l'opérateur new( ) (pas de syntaxe simplifiée). StringBuffer sometext = new StringBuffer("Hello"); Création en définissant une capacité initiale : // Création d'une chaîne vide avec une capacité de 2000 caracères StringBuffer sb = new StringBuffer(2000); // Ajout d'une chaîne littérale (String) sb.append("bonjour"); System.out.println(sb.length()); // 7 System.out.println(sb.capacity()); // 2000 sb.append(" à tous!"); v with 3 digits Hex/Octal fa/ System.out.println(sb.length()); // 16 System.out.println(sb.capacity System.out.println(sb.capacity()); // 2000 EIA-FR / Jacques Bapst PR1_07 10 EIA-FR / Jacques Bapst PR1_07 12

50 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Opérations sur les StringBuffer Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Classe StringBuilder Différentes méthodes permettent de manipuler les objets de type StringBuffer : Dans la librairie standard de la plateforme Java, on trouve également la classe StringBuilder. C o m p l é m e n t append() insert() replace() delete() setcharat() deletecharat() substring() Ajoute un élément à la fin de la chaîne de caractères (surcharge pour différents types d'éléments) Insère un élément à une position donnée de la chaîne de caractères (surcharge pour différents types d'éléments) Remplace une partie d'une chaîne de caractères par une autre Efface une portion donnée d'une chaîne de caractères Remplace un caractère à une position donnée Efface (supprime) un caractère à une position donnée Extrait une sous-chaîne C o m p l é m e n t Son API est compatible avec celle de la classe StringBuffer qu'elle peut remplacer dans toutes les situations où le code s'exécute dans un seul thread (c'est-à-dire dans tous les cas où il n'est pas indispensable que le code soit thread-safe). La plupart des méthodes de la classe StringBuilder s'exécutent plus rapidement que celles de la classe StringBuffer. Toutes les indications données dans les pages précédentes pour la classe StringBuffer s'appliquent également à la classe StringBuilder. tostring() Convertit le contenu en type String EIA-FR / Jacques Bapst PR1_07 13 EIA-FR / Jacques Bapst PR1_07 15 Java / Chaînes de caractères (String / StringBuffer / StringBuilder) Conversions String Û StringBuffer Pour convertir un objet de type String en un objet de type StringBuffer on utilise le constructeur (opérateur new( )). String s1 = "Hello"; StringBuffer sbuf = new StringBuffer(s1); C o m p l é m e n t Pour convertir un objet de type StringBuffer en un objet de type String on utilise la méthode tostring( ) ou substring( ). StringBuffer vtext = new StringBuffer(); vtext.append("un texte"); String s2 = vtext.tostring(); String s3 = vtext.substring(3, 6); // s3 <-- "tex" EIA-FR / Jacques Bapst PR1_07 14

51 Java / Entrées / Sorties (I/O) Flux (Stream) Informatique / Programmation La notion de flux (Stream) caractérise un chemin (une voie) de communication entre une source d'information et sa destination. Programmation orientée objet avec Java 08 : Entrées / Sorties (I/O) Jacques Bapst [email protected] L'accès aux informations s'effectue de manière séquentielle. Les librairies Java distinguent deux genres de flux : Les flux binaires (Byte Stream) qui peuvent représenter des données quelconques (nombres, données structurées, programmes, sons, images, ) Les flux de caractères (Character Stream) qui représentent des textes (chaînes de caractères) au format Unicode. EIA-FR / Jacques Bapst PR1_08 3 Java / Entrées / Sorties (I/O) Entrées / Sorties (I/O) Les entrées/sorties (Input/Output ou I/O) permettent à un programme de communiquer avec certains périphériques. Les entrées/sorties permettent par exemple : de lire et d'écrire sur la console (lecture au clavier et affichage à l'écran en mode 'caractères') d'accéder aux fichiers et répertoires des disques de communiquer avec d'autres applications (localement ou au travers du réseau) Les librairies de la plate-forme Java offrent un grand nombre de classes dédiées aux entrées/sorties. La plupart des classes se trouvent dans le package java.io (qui comporte plus de 50 classes!). Au fil des versions, d'autres packages sont venus compléter la librairie. Il y a notamment le package java.nio, le package java.nio.file, etc. Java / Entrées / Sorties (I/O) Utilisation des flux La communication avec un flux comprend trois phases : L'ouverture du flux, en entrée (pour la lecture) ou en sortie (pour l'écriture) La répétition de la lecture ou de l'écriture des données (généralement des bytes ou des caractères) La fermeture du flux Quelques classes importantes pour utiliser les flux courants : Flux d'entrée Flux de sortie Flux binaires DataInputStream DataOutputStream Flux de caractères BufferedReader PrintWriter N Open Read / Write End? Y Close EIA-FR / Jacques Bapst PR1_08 2 EIA-FR / Jacques Bapst PR1_08 4

52 Java / Entrées / Sorties (I/O) Lecture et écriture des flux Pour lire un fichier texte il faut ouvrir un flux d'entrée La classe FileReader constitue une des couches de base et comporte les méthodes élémentaires pour lire le flux depuis le système de fichiers Pour écrire un fichier texte il faut ouvrir un flux de sortie La classe FileWriter constitue une des couches de base et comporte les méthodes élémentaires pour écrire le flux sur le système de fichiers La lecture et l'écriture de fichiers textes sont réalisées en enrobant la couche de base avec des outils de plus haut niveau (imbrication) Mémoire tampon (buffer) pour minimiser les accès au disque Conversion bytes Û caractères (encodage Unicode) Découpage en lignes / Insertion des retours à la ligne, etc. Illustration (pour l'écriture) : PrintWriter BufferedWriter FileWriter File-System (par ex. disque) Java / Entrées / Sorties (I/O) Écriture d'un fichier texte En plus des méthodes print() et println() la classe PrintWriter comporte également la méthode printf() qui a été décrite dans le chapitre précédent (formatage des chaînes de caractères) et qui permet de formater le texte écrit dans le fichier. printf(string format, Object... args) Pour la syntaxe du texte de formatage, voir description dans l'api de la classe java.util.formatter Exemples p.printf("%.2f", resultscore); p.printf("nombre %d Prix %ld Total %9ld\n", nbitems, price, price*nbitems); p.printf("%5d%8.3f %n", i, v); EIA-FR / Jacques Bapst PR1_08 5 EIA-FR / Jacques Bapst PR1_08 7 Java / Entrées / Sorties (I/O) Écriture d'un fichier texte Pour écrire séquentiellement dans un fichier de texte on peut utiliser la classe PrintWriter de la manière suivante: Ouverture String filename = "C:\\Temp\\TestOut.txt"; PrintWriter p = new PrintWriter( new BufferedWriter( new FileWriter(filename))); Écriture p.print("hello"); p.println(" world" + 3*2); p.println("fin du fichier " + filename); Fermeture p.close(); Java / Entrées / Sorties (I/O) Lecture d'un fichier texte Pour lire séquentiellement le contenu d'un fichier de texte on peut utiliser la classe BufferedReader de la manière suivante : Ouverture String filename = "C:\\Temp\\TestIn.txt"; BufferedReader r = new BufferedReader( new FileReader(filename)); Lecture (ligne par ligne) String s; s = r.readline(); while (s!= null) { System.out.println(s); s = r.readline(); Fermeture r.close(); //--- Tant qu'il y a encore des lignes... EIA-FR / Jacques Bapst PR1_08 6 EIA-FR / Jacques Bapst PR1_08 8

53 Java / Entrées / Sorties (I/O) Lecture d'un fichier texte La classe Scanner (java.util) offre différentes méthodes pour décomposer les données d'un flux de caractères ou d'un String. Ouverture String filename = "D:\\Foo\\Config\\Init.cfg"; Scanner scf = new Scanner(new BufferedReader( new FileReader(filename))); Lecture (ligne par ligne, utilisation d'un 2 ème Scanner pour analyser chaque ligne) String line; while (scf.hasnextline()) { line = scf.nextline(); Scanner scs = new Scanner(line); scs.usedelimiter("="); //--- Séparateur (regex pattern) String key = scs.next(); float val = scs.nextfloat(); Fermeture scf.close(); Length=1.2 Width=5.5 Depth=0.27 Contenu du fichier Init.cfg EIA-FR / Jacques Bapst PR1_08 9 Java / Entrées / Sorties (I/O) Lecture au clavier La lecture au clavier s'effectue en imbriquant (en enrobant) le flux standard (System.in) dans deux constructeurs de classes qui se chargeront de la conversion des octets en caractères Unicode et de la mise en place d'une mémoire tampon intermédiaire. Lecture au clavier : BufferedReader keyboard = new BufferedReader( new InputStreamReader(System.in)); String s = keyboard.readline(); Remarques :La méthode readline() attend jusqu'à ce que l'utilisateur introduise des caractères au clavier et termine la saisie en pressant sur la touche Return (Enter). Le caractère fin de ligne n'est pas inclus dans le String retourné. Si l'utilisateur presse uniquement sur Return, le String sera vide (longueur = 0). EIA-FR / Jacques Bapst PR1_08 11 Java / Entrées / Sorties (I/O) Entrées/Sorties standard (console) Les flux suivants sont prédéfinis dans la classe System. Ces flux sont toujours ouverts et on ne les ferme pas. System.in Entrée standard (lecture du clavier) [ InputStream ] System.out Sortie standard (affichage à l'écran) [ PrintStream ] System.err Sortie des messages d'erreur [ PrintStream ] (souvent identique à out par défaut) Écriture sur la console : System.out.print("Résultats : "); System.out.println(5*4 + ", " + 6); //--- Reste sur la même ligne System.out.println(5*4 + ", " + 4+2); //--- Attention au piège! System.err.println("Erreur : Nom de fichier incorrect"); Java / Entrées / Sorties (I/O) Lecture au clavier Une autre manière de faire (souvent plus pratique) est d'utiliser la classe Scanner (java.util) qui permet également de saisir mais, en plus, de transformer et d'interpréter ce qui a été saisi au clavier. Exemple d'utilisation : Scanner scan = new Scanner(System.in); System.out.print("Enter an integer (or 'x' to exit) : "); while (scan.hasnextint()) { int i = scan.nextint(); System.out.println("Value = " + i); System.out.print("Enter an integer (or 'x' to exit) : "); Remarques :La classe Scanner offre de nombreuses possibilités pour décomposer et interpréter les informations lues. Pour plus de détail il faut consulter la documentation (API). EIA-FR / Jacques Bapst PR1_08 10 EIA-FR / Jacques Bapst PR1_08 12

54 Java / Entrées / Sorties (I/O) Importation des classes I/O La plupart des classes d'entrées/sorties se trouvent dans la librairie (package) java.io (ou év. dans java.nio). Tout programme qui utilise des entrées/sorties (sauf s'il se limite aux flux standard) devra préalablement importer toutes les classes externes nécessaires. On utilisera pour cela la pseudo-instruction : import java.io.*; Cette instruction doit être placée avant la déclaration de la classe qui utilise les entrées/sorties (juste après package ). Elle a pour effet de rendre visible toutes les classes contenues dans le paquetage java.io (importation sélective également possible). Pour pouvoir utiliser la classe Scanner il faut également l'importer : import java.util.scanner; Java / Entrées / Sorties (I/O) Hiérarchie de la classe IOException La classe IOException comporte un grand nombre de sousclasses correspondant à différents types d'événements qui peuvent survenir lorsqu'on travaille avec les entrées/sorties. java.lang.throwable +-- java.lang.exception +-- java.io.ioexception +-- ChangedCharSetException +-- CharacterCodingException +-- CharConversionException +-- CloseChannelException +-- EOFException +-- FileNotFoundException +-- FileLockInterruptionException +-- MalformedURLException +-- ProtocolException +-- SocketException +-- UnknownHostException +-- UnsupportedEncodingException +-- ZipException +-- Plusieurs de ces classes comportent elles-mêmes des sous-classes EIA-FR / Jacques Bapst PR1_08 13 EIA-FR / Jacques Bapst PR1_08 15 Java / Entrées / Sorties (I/O) Traitement des exceptions Java / Entrées / Sorties (I/O) Lecture séquentielle d'un fichier texte La plupart des opérations d'entrées/sorties risquent de générer des exceptions du type IOException (une sous-classe d'exception). Ces exceptions (contrôlées) sont déclarées dans la signature des méthodes concernées et le compilateur impose donc au programmeur de les traiter ou de déclarer leur propagation. Il faut éviter de mettre des instructions try / catch à chaque ligne. Grâce au mécanisme de propagation des exceptions, il est possible de concentrer le traitement à un seul endroit (ou à quelques endroits stratégiques judicieusement choisis). Dans les applications, il faut trouver le bon compromis et placer les traitements d'exception aux endroits où l'on peut prendre les mesures adéquates et/ou informer correctement l'utilisateur. Pas de message du genre : "Erreur d'entrée/sortie" Mais plutôt un message clair : "Le fichier C:\Image\Tx1.gif n'existe pas" EIA-FR / Jacques Bapst PR1_08 14 import java.io.*; public class Pg1 { public static void main(string [] args) { String l, w, filename; BufferedReader f, keyboard; try { keyboard = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Entrer le nom du fichier : "); filename = keyboard.readline(); f = new BufferedReader(new FileReader(filename)); l = f.readline(); while (l!= null) { if (l.charat(0)=='#') System.out.println(" "); else System.out.println(l); l = f.readline(); f.close(); catch (IOException e) { System.err.println("Erreur: " + e); EIA-FR / Jacques Bapst PR1_08 16

55 Java / Entrées / Sorties (I/O) Décomposition (parsing) des données lues Java / Entrées / Sorties (I/O) Spécification de Scanner C o m p l é m e n t Les données enregistrées dans des fichiers textes sont généralement structurées et nécessitent une phase d'analyse et de décomposition (parsing) avant de pouvoir les utiliser. La plateforme Java offre différents outils pour faciliter ce travail, par exemple : Classes StringTokenizer et StreamTokenizer Classe Scanner Méthode split() de la classe String Classes Pattern et Matcher (package java.util.regex) La classe StringTokenizer est la plus ancienne et, si elle est parfois plus performante, elle est cependant moins flexible que Scanner ou split() qui se basent sur des Expressions régulières (regex pattern). C o m p l é m e n t Method Summary (Extract) boolean boolean String String boolean double int String Scanner hasnextline() Returns true if there is another line in the input of this scanner. hasnext () Returns true if the next token in this scanner's input can be interpreted as a next() Finds and returns the next complete token from this scanner. next(string pattern) Returns the next token if it matches the pattern constructed from the specified string. nextboolean() Scans the next token of the input into a boolean value and returns that value. nextdouble() Scans the next token of the input as a double. nextint() Scans the next token of the input as a int. nextline() Advances this scanner past the current line and returns the input that was skipped. next () Scans the next token of the input as a skip(string pattern) Skips input that matches a pattern constructed from the specified string. Scanner usedelimiter(string pattern) Sets this scanner's delimiting pattern to a pattern constructed from the specified String. EIA-FR / Jacques Bapst PR1_08 17 EIA-FR / Jacques Bapst PR1_08 19 Java / Entrées / Sorties (I/O) Spécification de Scanner Java / Entrées / Sorties (I/O) Spécification de StringTokenizer Constructor Summary (Extract) Scanner(InputStream source) Constructs a new Scanner that produces values scanned from the specified input stream. Scanner(Readable source) Constructs a new Scanner that produces values scanned from the specified source Scanner(String source) Constructs a new Scanner that produces values scanned from the specified string. Constructor Summary StringTokenizer(String str) Constructs a string tokenizer for the specified string. StringTokenizer(String str, String delim) Constructs a string tokenizer for the specified string. StringTokenizer(String str, String delim, boolean returndelims) Constructs a string tokenizer for the specified string. C o m p l é m e n t Method Summary (Extract) String boolean boolean boolean boolean boolean findinline(string pattern) Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters. hasnext() Returns true if this scanner has another token in its input. hasnext(string pattern) Returns true if the next token matches the pattern constructed from the specified string. hasnextboolean() Returns true if the next token in this scanner's input can be interpreted as a boolean value using a case insensitive pattern created from the string "true false". hasnextdouble() Returns true if the next token in this scanner's input can be interpreted as a double value using the nextdouble() method. hasnextint() Returns true if the next token in this scanner's input can be interpreted as an int value in the default radix using the nextint() method. C o m p l é m e n t Method Summary (Extract) int boolean boolean Object String String counttokens() Calculates the number of times that this tokenizer's nexttoken method can be called (before raising an exception). hasmoreelements() Returns the same value as the hasmoretokens method. hasmoretokens() Tests if there are more tokens available from this tokenizer's string. nextelement() Returns the same value as the nexttoken method, except that its declared return value is Object rather than String. nexttoken() Returns the next token from this string tokenizer. nexttoken(string delim) Returns the next token in this string tokenizer's string. EIA-FR / Jacques Bapst PR1_08 18 EIA-FR / Jacques Bapst PR1_08 20

56 Java / Entrées / Sorties (I/O) Utilisation de StringTokenizer Java / Entrées / Sorties (I/O) Fichiers à accès direct [1] C o m p l é m e n t import java.util.stringtokenizer; import java.io.*; public class Pg2 { public static void main(string [] args) { String l, w, filename; StringTokenizer st; BufferedReader f, keyboard; try { keyboard = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Entrer le nom du fichier : "); filename = keyboard.readline(); f = new BufferedReader(new FileReader(filename)); l = f.readline(); while (l!= null) { st = new StringTokenizer(l); while (st.hasmoretokens()) { System.out.print("(" + st.nexttoken() + ")"); System.out.println(); l = f.readline(); f.close(); catch (IOException e) { System.err.println("Erreur: " + e); C o m p l é m e n t La classe RandomAccessFile (assez indépendante des autres classes du package java.io) permet de lire et d'écrire dans un fichier à des positions arbitraire (accès direct, accès aléatoire). Un curseur (File Pointer) peut être positionné à un emplacement quelconque et les opérations de lecture/écriture auront lieu à partir de cet endroit (après l'opération, le curseur sera automatiquement positionné après le dernier byte lu ou écrit). Lors de l'ouverture du fichier, on indique le fichier à traiter ainsi que le mode d'accès : "r" : lecture uniquement "rw" : lecture et écriture Si le fichier n'existe pas, il sera créé à l'emplacement indiqué (selon les paramètres du constructeur). EIA-FR / Jacques Bapst PR1_08 21 EIA-FR / Jacques Bapst PR1_08 23 Java / Entrées / Sorties (I/O) Méthode split() Java / Entrées / Sorties (I/O) Fichiers à accès direct [2] Pour décomposer une chaîne de caractères, il existe également la méthode split() qui se trouve dans la classe String. Exemple d'utilisation avec un accès en lecture/écriture dans un fichier binaire existant : C o m p l é m e n t Pour le découpage de la chaîne, cette méthode se base sur une expression régulière dont la syntaxe est définie dans la classe Pattern (java.util.regex). String str = "Mots, séparés, par, des, virgules"; String[] words = str.split(", "); for (int i=0; i<words.length; i++) { System.out.println(words[i]); Mots séparés par des virgules C o m p l é m e n t RandomAccessFile f = new RandomAccessFile("config.dat", "rw"); f.seek(50); byte[] data = new byte[100]; f.read(data); int i = f.readint(); // Déplacement vers le byte 50 du fichier // Crée un buffer pour contenir les données // Lit 100 bytes du fichier f.seek(50); // Retour au byte 50 f.writeint(i); f.write(data); f.close(); // Lit un entier codé sur 4 bytes dans le fichier // Écrit d'abord l'entier // puis écrit les 100 bytes // Fermeture du fichier EIA-FR / Jacques Bapst PR1_08 22 EIA-FR / Jacques Bapst PR1_08 24

57 C o m p l é m e n t Java / Entrées / Sorties (I/O) Fichiers à accès direct [3] La classe RandomAccessFile est principalement destinée à la manipulation de données binaires car elle n'inclut pas de méthodes de lecture et d'écriture de chaînes de caractères assurant la conversion au format Unicode (seuls les 8 bits de plus faible poids de chaque caractère sont considérés). La méthode readline()permet de lire une ligne de texte mais ne fonctionne correctement que pour du texte simple (ASCII / 8 bits). La méthode writebytes()permet d'écrire du texte (String) mais ne fonctionne correctement que pour du texte simple (ASCII / 8 bits). De plus, il faut s'assurer d'ajouter les caractères de terminaison à la fin de chaque ligne. Remarque : Les caractères de terminaison de lignes (EOL) dépendent de la plate-forme d'exécution : System.getProperty("line.separator") Java / Entrées / Sorties (I/O) Conversions types primitifs Û String Dans les opérations d'entrées/sorties avec des flux de caractères (notamment en lecture), des conversions entre types primitifs et String sont fréquemment nécessaires. Rappel des méthodes de conversion : Conversions Type primitif Wrapper en String de String byte Byte tostring(byte b) parsebyte(string s) short Short tostring(short s) parseshort(string s) int Integer tostring(int i) parseint(string s) long Long tostring(long l) parselong(string s) float Float tostring(float f) parsefloat(string s) double Double tostring(double d) parsedouble(string s) D'autres fonctions de conversion sont également disponibles dans la classe String, notamment la méthode valueof() qui permet de convertir en String les valeurs de tous les types primitifs. EIA-FR / Jacques Bapst PR1_08 25 EIA-FR / Jacques Bapst PR1_08 27 Java / Entrées / Sorties (I/O) Arguments de la ligne de commande En Java, un programme peut recevoir des arguments lors de son lancement (des paramètres d'exécution sur la ligne de commande). Dans le programme on récupère ces paramètres dans un tableau de chaînes de caractères (String[]) transmis à la méthode main(). public class Echo { public static void main(string[] args) { for (int i=0; i<args.length; i++) { System.out.println(args[i]); if (args.length == 0) System.out.println("No arguments"); prompt> java Echo hello 10 world hello 10 world prompt> java Echo no arguments Java / Entrées / Sorties (I/O) Utilisation des fonctions de conversion Un exemple d'utilisation : public class GetRuntimeParams { public static void main(string[] args) { int p1 = 0; float p2 = 0; double p3 = 0; boolean p4 = false; try { p1 = Integer.parseInt(args[0]); p2 = Float.parseFloat(args[1]); p3 = Double.parseDouble(args[2]); p4 = Boolean.valueOf(args[3]).booleanValue(); catch (Exception e) { System.err.println("Incorrect Runtime Parameters Types or Values"); System.err.println("Should be : int, float, double, boolean"); return; EIA-FR / Jacques Bapst PR1_08 26 EIA-FR / Jacques Bapst PR1_08 28

58 Java / Classes et objets Classes [2] Informatique / Programmation Une classe peut être considérée comme un moule (ou un plan) permettant de créer des objets qui ont des propriétés similaires mais qui ont tous leur identité propre (indépendance). Classe new Instances Programmation orientée objet avec Java 09 : Classes et objets Objet 1 Jacques Bapst [email protected] Objet 3 Objet 2 EIA-FR / Jacques Bapst PR1_09 3 Java / Classes et objets Classes [1] Java / Classes et objets Propriétés des objets Une classe est une collection nommée de de champs (ou attributs) contenant des valeurs de constructeurs servant à créer les objets de méthodes définissant des actions (opérations) La classe est l'élément structurel le plus fondamental de tout programme Java (on ne peut pas écrire de code sans créer au moins une classe). Les champs et les méthodes sont collectivement nommés membres de la classe : les champs sont les membres données (data members) les méthodes sont les membres fonctions (function members) Chaque classe définit un nouveau type de données qui permettra de créer (d'instancier) des objets de ce type. Les objets créés sont appelés instances de la classe. Un objet est principalement caractérisé par : une identité (son nom); doit être univoque dans le contexte d'utilisation un type (la classe dont il provient, avec les classes ascendantes) un état (qui est défini par la valeur actuelle de ses champs); l'état peut évoluer dans le temps (chaque objet vit sa vie) un comportement (qui est défini par l'ensemble de ses méthodes publiques); ensemble des actions et des opérations possibles La programmation orientée objet met les objets au cœur de la conception des applications (contrairement à la programmation procédurale qui centre la conception sur les traitements appliqués aux données). Une application orientée objet est constituée d'un ensemble d'objets qui communiquent en s'échangeant des messages (par l'invocation de leurs méthodes). EIA-FR / Jacques Bapst PR1_09 2 EIA-FR / Jacques Bapst PR1_09 4

59 Java / Classes et objets Déclaration de classes [1] La syntaxe de base pour la déclaration d'une classe est la suivante : modificateurs class nom_de_la_classe { déclaration_de_champs déclaration_de_constructeurs déclaration_de_méthodes Les modificateurs (liste de mots-clés) seront vus ultérieurement (public pour l'instant). Les noms de classes sont habituellement écrits avec la première lettre en majuscule et en utilisant la notation MixedCase / CamelCase (transition minuscules/majuscules pour séparer les éléments du nom). Java / Classes et objets Déclaration des champs [1] Les champs appelés aussi attributs (ou membres données) définissent la valeur (l'état) de l'objet. La syntaxe de déclaration des champs est proche de la déclaration d'une variable locale : Modificateurs Type Nom_du_champ [ = Expression ] ; Les modificateurs sont constitués de mots-clés qui déterminent diverses propriétés, notamment la visibilité (public, protected, private). Il seront étudiés dans un prochain chapitre. Le type peut être soit un type primitif, un tableau ou le nom d'une classe (rappelons que chaque classe définit un type référence). Exemples : Random, StringReader, FileOutputStream EIA-FR / Jacques Bapst PR1_09 5 EIA-FR / Jacques Bapst PR1_09 7 Java / Classes et objets Déclaration de classes [2] Exemple de déclaration de classe : public class Point { public double px; public double py; // Coordonnée x du point (champ) // Coordonnée y du point (champ) public Point() { // Constructeur 1 px = 0.0; py = 0.0; public Point(double x, double y) { // Constructeur 2 px = x; py = y; public double distanceorigin() { return Math.sqrt(px*px + py*py); // Méthode Java / Classes et objets Déclaration des champs [2] Une expression d'initialisation peut être mentionnée lors de la déclaration d'un champ (=...). En l'absence d'expressions d'initialisation, les champs sont automatiquement initialisés à leurs valeurs par défaut (false et 0 pour les types primitifs, null pour les objets et les tableaux) public class Circle { // Définition et initialisation des champs public Point center = new Point(0, 0); public double radius = 0.0; // Suite de la déclaration de la classe Cercle EIA-FR / Jacques Bapst PR1_09 6 EIA-FR / Jacques Bapst PR1_09 8

60 Java / Classes et objets Constructeurs [1] Java / Classes et objets Méthodes Un constructeur est une sorte de méthode qui sera invoquée lors de la création d'un objet de cette classe (opérateur new). Un constructeur doit porter le nom de la classe et ne doit pas comporter de type de retour dans sa déclaration (même pas void). Le but du constructeur est d'initialiser l'objet (notamment la valeur de ses champs). Un constructeur retourne implicitement une référence à une instance de la classe (objet). Si aucun constructeur n'est défini dans une classe, Java fournit un constructeur par défaut, sans argument, et qui se charge uniquement de créer les champs et de leur attribuer une valeur initiale (valeur par défaut ou valeur de l'expression d'initialisation). Les méthodes ont déjà été étudiées dans un chapitre précédent. Elles ne sont pas forcément déclarées avec le modificateur static (c'est même plutôt l'exception en programmation objet). Un prochain chapitre sera consacré à approfondir les notions de champs/méthodes statiques et non-statiques. Les méthodes ont accès aux champs de la classe dans laquelle elles sont déclarées. Ces champs sont accessibles par leurs noms simples ou en utilisant le préfixe this (explication de ce mot réservé dans les pages suivantes). Les méthodes peuvent invoquer d'autres méthodes définies dans la même classe en utilisant leur nom simple ou en utilisant le préfixe this (comme pour les champs). Les constructeurs ne sont pas des méthodes à strictement parler même si, par beaucoup d'aspects, ils leur ressemblent. EIA-FR / Jacques Bapst PR1_09 9 EIA-FR / Jacques Bapst PR1_09 11 Java / Classes et objets Constructeurs [2] Comme les méthodes, les constructeurs peuvent être surchargés (en suivant les même règles). Lorsqu'une classe possède des constructeurs multiples (surchargés), il est possible, dans le corps d'un constructeur, d'invoquer un autre constructeur, un utilisant la syntaxe spéciale : this(expr1, expr2,...) Dans la déclaration de la classe Point, le premier constructeur aurait pu être écrit ainsi : public Point() { // Constructeur 1 this(0.0, 0.0); // Invocation du Constructeur 2 Java / Classes et objets Déclaration et création d'objets La classe Point permet de déclarer des objets de ce type : Point p1; // Déclaration d'un objet de type Point La déclaration ne crée pas un objet mais uniquement une référence vers un objet du type mentionné (comme pour les tableaux). p1 Pour créer un objet on utilise l'opérateur new suivi du nom de la classe et d'une liste facultative d'arguments entre parenthèses. new nom_de_la_classe(expr1, expr2,... ) new Point(1.2, 3.4) 1.2 px 3.4 py Restriction importante : L'appel à this(...) doit apparaître comme première instruction dans un constructeur. L'opérateur new fait appel à l'un des constructeurs de la classe en fonction du profil des paramètres transmis (constructeur par défaut ou l'un des constructeurs définis explicitement dans la classe). EIA-FR / Jacques Bapst PR1_09 10 EIA-FR / Jacques Bapst PR1_09 12

61 Java / Classes et objets Création d'objets La classe Point déclarée précédemment permet de déclarer et de créer des objets de ce type : Java / Classes et objets Utilisation des objets L'accès aux membres des objets s'effectue en utilisant l'opérateur point (.) selon la syntaxe suivante : Point p1; p1 = new Point(); Point p2 = new Point(); Point p3 = new Point(2.0, 4.5); // Déclaration d'un objet de type Point // Création d'un objet et assignation // de la référence à p1 // Déclaration de p2, création d'un // objet Point et assignation de la // référence à p2 // Idem, mais utilisation du deuxième // constructeur pour créer l'objet Nom_de_l'objet.Nom_du_membre Le membre pouvant être soit un champ soit une méthode : Point p1 = new Point(1.0, 2.0); // Déclare et crée un objet p1 double vx, vy, d; Les objets, comme les tableaux, sont des types référence. p1, p2 et p3 ne contiennent donc pas les objets mais sont des références vers les zones mémoires contenant les objets. vx = p1.px; // Lit un champ de l'objet p1 vy = p1.py; p1.px = p1.px + 1.5; // Modifie la valeur du champ d = p1.distanceorigin(); // Exécute une méthode de p1 EIA-FR / Jacques Bapst PR1_09 13 EIA-FR / Jacques Bapst PR1_09 15 Java / Classes et objets Représentation en mémoire Java / Classes et objets Notion d'objet [1] C o m p l é m e n t p1 = new Point(2.5, 4.2); Référence p Point Nom classe Champ p1.px Champ p1.py Objet référencé Création de l'espace mémoire pour contenir l'objet et initialisation des champs (constructeur) Objet Attribut : Entité typée et nommée qui possède des attributs et des méthodes : Case mémoire typée et nommée Méthode : Procédure ou fonction nommée qui a accès aux attributs de l'objet Pour accéder aux composants (membres) d'un objet il faut : Notation abstraite Référence Objet référencé détenir une variable qui référence cet objet connaître le nom de l'attribut ou de la méthode utiliser l'opérateur "." p1 = new Point(2.5, 4.2); p1 2.5 px 4.2 py Notation à utiliser utilisation comme une variable, resp. une procédure / fonction EIA-FR / Jacques Bapst PR1_09 14 EIA-FR / Jacques Bapst PR1_09 16

62 Java / Classes et objets Notion d'objet [2] Java / Classes et objets Notion d'alias Exemple : Type d'objet Car Attributs int year float speed Méthodes void filltank (int liters) double breakdownrisk(int km) Affectation a = b Comparaison a == b Passage en paramètre p(a) Type primitif Copie de la valeur Test sur la valeur Passage de la valeur (copie locale) Objet / Tableau Copie de la référence L'objet n'est pas modifié Test sur la référence, pas sur le contenu de l'objet! Passage de la référence (copie) L'objet risque d'être modifié! Car c = new Car(); c.year = 1999; System.out.println(c.speed); c.filltank(30); System.out.println(c.breakDownRisk(50)); Généralement, les méthodes ne sont pas mentionnées dans la représentation de l'état de la mémoire. c 1999 year 80.3 speed filltank() breakdownrisk() Type primitif : accès à la zone mémoire par une seule variable Objet / Tableau : accès à la zone mémoire possible par plusieurs variables Car mycar = new Car(); Car othercar = new Car(); mycar.year = 1999; othercar = mycar; othercar.year = 2014; System.out.println(myCar.year); // 2014!!! EIA-FR / Jacques Bapst PR1_09 17 EIA-FR / Jacques Bapst PR1_09 19 Java / Classes et objets Notion d'objet [3] Les types référence sont de vrais types Java qui peuvent être utilisés : Pour la déclaration de variables locales Pour la déclaration d'attributs d'un objet Comme paramètres de méthodes Comme résultat d'une fonction Type d'objet Car Attributs int year Engine motor Type d'objet Engine mycar 1999 year 'K' motor type Attributs char type int power 86 power Java / Classes et objets Référence à l'objet courant : this Le mot clé this est utilisé pour référencer l'objet à l'intérieur duquel le code est exécuté. On peut considérer que l'objet this est implicitement passé en référence lors de l'invocation de chaque méthode d'instance : Point p1 = new Point(1.0, 2.0); double d = p1.distanceorigin(); Dans l'exemple ci-dessus, l'objet p1 est implicitement passé en paramètre (invisible) à la méthode distanceorigin(). A l'intérieur du corps de la méthode distanceorigin() on peut, si nécessaire, utiliser le mot-clé this pour référencer l'objet sur lequel la méthode a été invoquée (p1 dans cet exemple). Attention :Il ne faut pas confondre this utilisé pour référencer l'objet courant avec la forme this() qui est utilisée pour invoquer un constructeur depuis un autre constructeur. EIA-FR / Jacques Bapst PR1_09 18 EIA-FR / Jacques Bapst PR1_09 20

63 Java / Classes et objets Classe : Notation UML Dans le langage de modélisation UML (Unified Modeling Language), les classes sont représentées graphiquement sous la forme de rectangles comprenant le nom de la classe et éventuellement le nom des champs, des constructeurs et des méthodes. Différents niveaux de détails sont possibles : Point Point Point px py distanceorigin() Champs Méthodes + px : double + py : double + Point(x : double, y : double) + distanceorigin() : double Indicateurs de visibilité : + : public - : private # : protected EIA-FR / Jacques Bapst PR1_09 21 Java / Classes et objets En bref, écrire une classe c'est Choisir un nom pour la classe Intégrer cette classe dans un paquetage Écrire la spécification (déclarer la partie publique) Signature des méthodes avec les exceptions prévues Explication de l'effet attendu (rôle des paramètres, valeur de retour, effet sur les données, pré- et post-conditions) Écrire une implémentation : Définition des attributs (choix des structures de données) Conception du corps des méthodes (choix des algorithmes) Codage proprement dit (identificateur, flux d'instructions, lisibilité, méthodes privées) Tester le bon fonctionnement Éventuellement Documenter la classe avec /** */ (Javadoc) Affiner, optimiser, EIA-FR / Jacques Bapst PR1_09 22

64 Java / Packages, contrôle d'accès, encapsulation Paquetages Informatique / Programmation Programmation orientée objet avec Java 10 : Packages / Contrôle d'accès / Encapsulation Un paquetage (Package) est une collection nommée de classes et/ou d'interfaces. Un paquetage peut comprendre des sous-paquetages. Les paquetages permettent de grouper des classes apparentées et de définir un espace de désignation (Namespace) pour les classes qu'il contient. Les paquetages servent également à gérer les droits d'accès (visibilité) des classes les unes par rapport aux autres. Les paquetages sont organisés de manière hiérarchique (structure arborescente avec racines multiples). Jacques Bapst [email protected] Dans le nom des paquetages, le point ('.') est utilisé comme séparateur entre les différents niveaux hiérarchiques. Exemple : java.lang.string : La classe String se trouve dans le sous-paquetage lang du paquetage java EIA-FR / Jacques Bapst PR1_10 3 Java / Packages, contrôle d'accès, encapsulation Unités de compilation Java / Packages, contrôle d'accès, encapsulation Déclaration de paquetage [1] Un programme Java est généralement constitué d'un ensemble de classes. Le code source de chaque classe publique doit être enregistré dans un fichier séparé portant le nom de la classe avec l'extension ".java". Un tel fichier constitue une unité de compilation. Le résultat de la compilation (Bytecode) est enregistré dans un fichier portant le nom de la classe avec l'extension ".class". Exemple : La classe Point déclarée précédemment doit être enregistrée dans un fichier nommé "Point.java" Après la compilation, un nouveau fichier "Point.class" sera créé, il contiendra le Bytecode correspondant à la classe Point Le mot clé package est utilisé pour indiquer le paquetage auquel appartiennent la ou les classes de l'unité de compilation. package Nom_du_paquetage ; Cette pseudo-instruction, si elle est utilisée, doit être la première (hormis les commentaires) de l'unité de compilation (fichier source). Exemple : package ch.eiafr.tic; public class Point {... La classe Point fait partie du paquetage ch.eiafr.tic Le nom complet de la classe est "ch.eiafr.tic.point" EIA-FR / Jacques Bapst PR1_10 2 EIA-FR / Jacques Bapst PR1_10 4

65 Java / Packages, contrôle d'accès, encapsulation Déclaration de paquetage [2] Java / Packages, contrôle d'accès, encapsulation Importation de paquetage [2] Si aucune instruction package n'apparaît dans un fichier source, (ce qui est déconseillé) les classes définies dans cette unité de compilation seront attribuées à un paquetage par défaut (qui est anonyme). Les noms des paquetages sont habituellement écrits en utilisant uniquement des minuscules (convention de codage). Pour faciliter l'échange de code Java (librairies publiques), il est utile d'avoir un espace de désignation globalement univoque (pour éviter les conflits dans les noms de classes). C'est pour cela qu'il est recommandé de créer l'arborescence des paquetages en utilisant comme racine, les noms de domaines internet (en inversant les éléments de l'url, tout en respectant la syntaxe des identificateurs Java!). Exemple : Nom de domaine : eia-fr.ch Racine des paquetages : ch.eiafr L'instruction import doit être placée au début de l'unité de compilation, juste après l'instruction package (s'il y en a une). L'instruction import peut être répétée à volonté pour importer plusieurs classes et/ou plusieurs paquetages. L'importation d'un paquetage entier (...*) ne rend pas visible le contenu des éventuels sous-paquetages. Si nécessaire, les sous-paquetages doivent être importés explicitement. En cas de conflit (importation de paquetages contenant des classes portant le même nom), le compilateur imposera l'utilisation du nom complet pour accéder aux classes homonymes. Le paquetage java.lang étant considéré comme fondamental, il est implicitement importé et l'on peut donc utiliser ses classes par leurs noms simples (par exemple : String, Math, System,...) sans avoir à les importer. EIA-FR / Jacques Bapst PR1_10 5 EIA-FR / Jacques Bapst PR1_10 7 Java / Packages, contrôle d'accès, encapsulation Importation de paquetage [1] Java / Packages, contrôle d'accès, encapsulation Importation statique Par défaut, une classe d'un paquetage p peut faire référence à toute autre classe de p par son nom simple (le nom de la classe uniquement, par exemple Point). Pour référencer une classe d'un paquetage différent de celui dans lequel on se trouve, il faut utiliser son nom complet (paquetage + classe, par exemple ch.eiafr.tic.line). Afin d'alléger l'écriture, on peut "importer" les classes d'un paquetage externe en utilisant l'instruction import. Il existe deux formes : Importation d'une classe individuelle Importation de toutes les classes contenues dans un paquetage : import ch.eiafr.tic.line; : import ch.eiafr.tic.*; L'instruction import rend accessible, par leurs noms simples, les classes externes mentionnées. C o m p l é m e n t Depuis la version 1.5 du langage, il est possible d'importer sélectivement ou globalement les membres statiques d'une classe en ajoutant le mot-clé static à l'instruction import (les membres statiques seront vus en détail au chapitre suivant). Cette importation statique permet, dans certains cas, d'alléger l'écriture en évitant de devoir préfixer les champs et les méthodes statiques avec le nom du package et/ou de la classe. Par exemple : import static java.lang.math.max; importe la méthode statique max() qui pourra donc être invoquée sans préfixe : r = max(v1, v2); Pour importer tous les membres statiques de la classe Math : import static java.lang.math.*; a = PI * pow(r, 2); EIA-FR / Jacques Bapst PR1_10 6 EIA-FR / Jacques Bapst PR1_10 8

66 Java / Packages, contrôle d'accès, encapsulation Paquetages et unités de compilation [1] La hiérarchie des répertoires du disque dans lesquels sont enregistrés les fichiers des classes (.class) doit correspondre à la hiérarchie des paquetages. Paquetages package ch.eiafr.tic; public class Point {... package ch.eiafr.tic.tools; public class Complex {... public class Graph {... package ch.eiafr.tic.test; public class TestPoint {... Répertoires / Fichiers C: +-ClassesJava +-ch +-eiafr +-tic +-test +-tools Racine des paquetages Point.class TestPoint.class Complex.class Graph.class Java / Packages, contrôle d'accès, encapsulation Structure des unités de compilation En résumé, les unités de compilation (fichiers.java") doivent respecter la structure suivante : (zéro ou) une instruction package zéro, une ou plusieurs instructions import une ou plusieurs définitions de classes (class), d'interfaces ou de classes-internes (mais une seule classe ou interface publique au premier niveau) package...; import...; import...; import...; public class... {... Ces éléments (package, import, class) peuvent naturellement être entourés de commentaires, mais ils doivent impérativement apparaître dans l'ordre mentionné ci-dessus. EIA-FR / Jacques Bapst PR1_10 9 EIA-FR / Jacques Bapst PR1_10 11 Java / Packages, contrôle d'accès, encapsulation Paquetages et unités de compilation [2] La hiérarchie des fichiers contenant les classes constitue un sousarbre qui peut être placé n'importe où dans l'arborescence générale du disque. Le paramètre (ou la variable d'environnement) classpath indique à la machine virtuelle Java, la liste des répertoires (racines) dans lesquels se trouvent les classes. java -classpath.;c:\classesjava;g:\info\lib... A partir de ces racines (points d'entrée), la machine virtuelle complète le chemin d'accès en y ajoutant les sous-répertoires définis par l'arborescence des paquetages. Java / Packages, contrôle d'accès, encapsulation Librairie de classes Java La plate-forme Java comprend une vaste collection de classes prédéfinies qui peuvent être utilisées indépendamment de l'environnement d'exécution des applications. Cette librairie de classes est organisée en paquetages (et sous-paquetages) qui rassemblent, par domaine, des classes apparentées. L'arborescence des paquetages de la plate-forme Java possède deux racines principales java et javax. Les pages qui suivent donnent un aperçu succinct (quelques paquetages importants) de la plate-forme Java. Remarque : L'ensemble des fichiers.class peut également être enregistré dans un seul fichier.jar qui contient toutes les classes et leur arborescence sous forme éventuellement comprimée (format ZIP). Conseil :Inutile de réinventer la roue. Avant de coder une fonction particulière, il faut s'assurer qu'elle n'est pas disponible dans la bibliothèque des classes standard. EIA-FR / Jacques Bapst PR1_10 10 EIA-FR / Jacques Bapst PR1_10 12

67 Java / Packages, contrôle d'accès, encapsulation Librairie de classes Java [1] Java / Packages, contrôle d'accès, encapsulation Librairie de classes Java [3] C o m p l é m e n t java.lang java.io java.math java.net java.security Le noyau des classes du langage, comprenant notamment String, Math, System, Thread et Exception. Ce package est implicitement importé. Classes et interfaces d'entrée/sorties. Bien que certaines des classes de ce paquetage soient conçues pour travailler directement avec les fichiers, la plupart d'entre-elles permet de travailler avec des flux d'octets ou des flux de caractères. Petit paquetage qui contient des classes destinées à l'arithmétique entière de précision arbitraire et à l'arithmétique décimale. Classes et interfaces destinées à l'interconnexion avec d'autres systèmes (réseau). Classes et interfaces de contrôle d'accès et d'authentification. Plusieurs sous-paquetages. C o m p l é m e n t javax.swing javax.swing.event Grand paquetage (comportant de nombreux souspaquetages) destiné à étendre AWT pour la création d'interfaces utilisateur graphiques (GUI) sophistiquées. Introduit de nouveaux composants graphiques avec des propriétés beaucoup plus étendues qu'awt. Complète et améliore java.awt.event avec des classes spécialisées pour les composants Swing. Une description de l'ensemble des classes (et interfaces) contenues dans ces paquetages accompagne le JDK (Java Development Kit). La documentation est à télécharger séparément. Elle peut être consultée en ligne sur le site d'oracle : java.util Diverses classes utilitaires y compris un cadre de collections puissant, à utiliser avec les collections d'objets Les environnements de développement (Eclipse, NetBeans, ) permettent généralement également de consulter la description des API de la plateforme Java (voir documentation correspondante). EIA-FR / Jacques Bapst PR1_10 13 EIA-FR / Jacques Bapst PR1_10 15 Java / Packages, contrôle d'accès, encapsulation Librairie de classes Java [2] Java / Packages, contrôle d'accès, encapsulation Contrôle d'accès aux membres C o m p l é m e n t java.applet javax.accessibility java.awt java.awt.event java.awt.image Définit la classe Applet qui est la super-classe de toutes les applets. Ensemble de classes et d'interfaces permettant la réalisation d'applications adaptées à des personnes handicapées (par exemple mal-voyants) Définit le cadre de l'interface utilisateur graphique de base AWT (Abstract Windowing Toolkit). Contient également les classes permettant de gérer des graphiques 2D. Définit les classes et les interfaces utilisées pour la gestion des événements en AWT et Swing. Ensemble de classes et d'interfaces servant à manipuler les images. Tous les champs et toutes les méthodes d'une classe peuvent être utilisés dans le corps de la classe elle-même en utilisant leurs noms simples. Cependant, le langage Java permet de spécifier des restrictions d'accès aux membres d'une classe (champs et méthodes) en dehors de cette classe (appelée classe de définition ou classe de déclaration). Le contrôle d'accès aux membres s'effectue à l'aide de différents mots-clés qui peuvent précéder la déclaration des champs et des méthodes (ces mots-clés font partie d'un groupe de mots réservés appelés modificateurs). java.awt.print Ensemble de classes et d'interfaces destinées à l'impression de documents. Le mode d'accès par défaut (si l'on n'indique aucun mot-clé de contrôle d'accès dans la déclaration) est appelé "package" ou parfois "friendly" (mais ces termes ne peuvent pas être utilisés comme modificateurs dans le code). EIA-FR / Jacques Bapst PR1_10 14 EIA-FR / Jacques Bapst PR1_10 16

68 Java / Packages, contrôle d'accès, encapsulation Modificateurs d'accès [1] Les modificateurs qui contrôlent l'accès aux membres (champs ou méthodes) sont les suivants : Modificateur public protected Aucun ( package) private Description des droits d'accès sur le membre Accessible à toutes les classes de tous les paquetages Accessible aux classes dérivées (sous-classes) ainsi qu'aux classes du même paquetage Sera décrit plus en détail dans le cadre de l'héritage Accessible à toutes les classes du même paquetage Accessible seulement aux autres membres de la même classe (classe de définition) Le modificateur public peut également être utilisé dans la déclaration des classes. Il indique que la classe est accessible partout où le paquetage est accessible (par import...). Sans lui, la classe n'est accessible qu'au sein de son paquetage. Java / Packages, contrôle d'accès, encapsulation Modificateur d'accès private Si, dans une classe A, on déclare un objet k de type A (ou si une méthode de la classe A reçoit en paramètre un objet k de type A) alors les membres privés de l'objet k sont accessibles à l'intérieur de la classe A. Autrement dit, dans une classe A, on peut accéder aux membres privés de tous les objets de type A (pas seulement ceux de this). public class A {... private int x; private A c;... public void m1(a k) { k.x = this.x + 2; System.out.println(k.x);... public void m2() { x += c.x;... // k.x est accessible // c.x est accessible EIA-FR / Jacques Bapst PR1_10 17 EIA-FR / Jacques Bapst PR1_10 19 Java / Packages, contrôle d'accès, encapsulation Modificateurs d'accès [2] Les règles d'accès aux membres peuvent également être présentées sous la forme suivante : Accessible à : public protected package private Classe de définition Oui Oui Oui Oui Classe du même paquetage Oui Oui Oui Non Sous-classe dans un paquetage différent Classe (qui n'est pas une sous-classe) dans un paquetage différent Oui Oui Non Non Oui Non Non Non Par défaut Java / Packages, contrôle d'accès, encapsulation Encapsulation [1] L'une des techniques essentielles de la programmation orientée objet est l'encapsulation. L'encapsulation consiste à masquer les données au sein des classes et à manipuler leur contenu qu'au moyen de méthodes publiques. La mise en place du mécanisme d'encapsulation s'effectue en utilisant judicieusement les contrôles d'accès aux membres des classes. Avantages de l'encapsulation : Masquage des détails de l'implémentation (qui peut être changée sans conséquences pour les utilisateurs externes) Protection de la classe contre des utilisations erronées (contrôles de cohérence dans les méthodes) Simplification de l'api (les champs et les méthodes internes sont cachés) EIA-FR / Jacques Bapst PR1_10 18 EIA-FR / Jacques Bapst PR1_10 20

69 Java / Packages, contrôle d'accès, encapsulation Encapsulation [2] En règle générale, il est recommandé de masquer les champs en les déclarant private et - seulement si nécessaire - de définir des méthodes publiques pour accéder à ces champs (ces méthodes appelées accesseurs/mutateurs ou getters/setters sont généralement nommées getxxx(), isxxx() et setxxx()). Version encapsulée de la classe Point : public class Point { private double px; private double py; // Coordonnée x du point (champ) // Coordonnée y du point (champ) public Point() {... // Constructeur 1 public Point(double x, double y) {... // Constructeur 2 public double getpx() {return px; public double getpy() {return py; // Get px // Get py public void setpx(double x) {px = x; // Set px (nécessaire?) public void setpy(double y) {py = y; // Set py (nécessaire?) public double distanceorigin() {... EIA-FR / Jacques Bapst PR1_10 21

70 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Membres de classe [1] Informatique / Programmation Programmation orientée objet avec Java 11 : Membres statiques, initialiseurs, wrappers Jacques Bapst [email protected] On peut également créer des membres associés à la classe qui sont appelés membres de classe ou membres statiques. Pour rendre un membre statique, on utilise le mot-clé (modificateur) static devant la déclaration du champ ou de la méthode : public class Point { public double px; // Champ d'instance public double py; // Champ d'instance public int pnr; // Champ d'instance public static int nextnr = 1; // Champ statique public Point(double x, double y) { pnr = nextnr++; public double distanceorigin() {... // Constructeur // Méthode d'instance // Méthode statique public static double distance(point p1, Point p2) {... EIA-FR / Jacques Bapst PR1_11 3 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Membres d'instance Par défaut, lors de la création d'un objet (instanciation d'une classe avec l'opérateur new), les membres (champs et méthodes) sont associés à chacune des instances de la classe. On les appelle membres d'instance. px py Classe Point distanceorigin() new Point : p1 px = 1.0 py = 2.0 distanceorigin() Instances Point : p2 px = 3.0 py = 1.5 distanceorigin() Java / Membres statiques, initialiseurs, finaliseurs, wrappers Membres de classe [2] Les membres de classe ne sont pas associés aux instances (objets) mais seulement à la classe. Ils sont accessibles par toutes les instances de la classe (ils sont partagés par toutes les instances). px py pnr nextnr Classe Point distanceorigin() distance(point, Point) new Point : p1 px = 1.0 py = 2.0 pnr= 1 distanceorigin() Instances Point : p2 px = 3.0 py = 1.5 pnr = 2 distanceorigin() EIA-FR / Jacques Bapst PR1_11 2 EIA-FR / Jacques Bapst PR1_11 4

71 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Membres de classe [3] Java / Membres statiques, initialiseurs, finaliseurs, wrappers Importation statique On peut donc déclarer : -des champs statiques (ou champs de classe) -des méthodes statiques (ou méthodes de classe) Les champs statiques sont enregistrés au niveau de la classe et ils peuvent être accédés et manipulés par toutes les instances (objets) de cette classe. Indépendamment du nombre d'objets créés, il n'existe qu'un seul exemplaire des données associées aux champs statiques (contrairement aux champs d'instance dont il existe un exemplaire pour chaque objet créé). On peut considérer les champs statiques comme étant des variables globales partagées par toutes les instances. Il faut donc les utiliser avec précaution et parcimonie afin d'éviter des couplages inutiles (ou même dangereux) entre objets. C o m p l é m e n t Il est possible d'importer sélectivement ou globalement les membres statiques d'une classe en ajoutant le mot-clé static à l'instruction import. Cette importation statique permet, dans certains cas, d'alléger l'écriture en évitant de devoir préfixer les champs et les méthodes statiques avec le nom du package et/ou de la classe. Par exemple : import static java.lang.math.max; importe la méthode statique max() qui pourra donc être invoquée sans préfixe : r = max(v1, v2); Pour importer tous les membres statiques de la classe Math : import static java.lang.math.*; a = PI * pow(r, 2); EIA-FR / Jacques Bapst PR1_11 5 EIA-FR / Jacques Bapst PR1_11 7 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Membres de classe [4] Les méthodes statiques sont liées à une classe et non pas à une instance (objet) de la classe. Dans une méthode statique, on ne peut pas faire référence à une méthode d'instance sans créer d'objet, car les méthodes statiques ne s'exécutent pas dans le contexte d'un objet (autrement dit, pour les méthodes statiques, il n'existe pas de référence this). Pour accéder à un membre statique d'une classe en dehors de cette classe, il faut préfixer le nom du membre (champ ou méthode) avec le nom de la classe (ou utiliser import static ). Point p1 = new Point(1.0, 2.0); Point p2 = new Point(2.0, 3.0); int n = Point.nextNr; // Champ statique double d1 = Point.distance(p1, p2); // Méthode statique double d2 = p1.distanceorigine(); // Méthode d'instance Java / Membres statiques, initialiseurs, finaliseurs, wrappers Représentation en mémoire Les champs statiques existent et sont accessibles même si l'on n'a pas créé d'objets. On les représentera donc dans une zone mémoire liée à la classe et commune à toutes les instances de cette classe. p1 = new Point(2.5, 4.2); p2 = new Point(5.0, 6.0); n = Point.nextNr; n = p1.nextnr; Bien que déconseillée, cette notation est acceptée par le langage. Le compilateur la remplacera par n = Point.nextNr; Le champ statique nextnr est associé à la classe Point et est commun à toutes ses instances p1 p2 Point 2.5 px 4.2 py 1 pnr 5.0 px 6.0 py 2 pnr 3 nextnr EIA-FR / Jacques Bapst PR1_11 6 EIA-FR / Jacques Bapst PR1_11 8

72 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Modificateur final Java / Membres statiques, initialiseurs, finaliseurs, wrappers Initialiseur statique Le modificateur final peut être utilisé lors de la déclaration de variables locales, de paramètres de méthodes et de champs. Il indique que la valeur de la variable ou du champ ne peut plus être modifiée après l'affectation initiale. Cela revient donc à déclarer des constantes. Il est très fréquent de déclarer les constantes générales comme champs statiques au niveau de la classe et de les déclarer public. Exemple : public static final double PI = ; Les champs déclarés constants (static final) sont habituellement écrits en majuscules et utilisent le caractère sous-ligné '_' comme séparateur. Exemple : private static final double FREQUENCY_MAX = 3.5E9; Pour les classes et les méthodes, une autre utilisation du mot-clé final sera vue dans le cadre de l'héritage. Exemple d'initialisation statique : // // Calcule à l'avance et mémorise certaines valeurs // trigonométriques dans un tableau // public class Sinusoid { private static int nbpoints = 500; public static double[] valsine = new double[nbpoints]; // Initialisation du tableau valsine static { double x = 0.0; double dx = (Math.PI/2)/(nbPoints-1); for(int i=0; i<nbpoints; i++, x+=dx) { valsine[i] = Math.sin(x);... EIA-FR / Jacques Bapst PR1_11 9 EIA-FR / Jacques Bapst PR1_11 11 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Initialisation de classes Java / Membres statiques, initialiseurs, finaliseurs, wrappers Initialiseur d'instance [1] Le langage Java permet d'écrire du code d'initialisation de classe qui sera exécuté lors de l'élaboration de la classe (en même temps que l'initialisation des champs statiques). Ce code appelé initialiseur statique est simplement constitué d'un bloc d'instructions (entre accolades) précédé du mot-clé static. Une classe peut posséder un nombre quelconque d'initialiseurs statiques qui peuvent être placés partout où une déclaration de champ ou une déclaration de méthode est permise (ils seront exécutés dans ordre d'écriture du code dans le fichier source). Les initialiseurs statiques peuvent être considérés comme des méthodes statiques anonymes. Les restrictions définies pour les méthodes statiques s'appliquent également aux instructions des initialiseurs statiques. C o m p l é m e n t Les classes peuvent également posséder des initialiseurs d'instance. Un initialiseur d'instance initialise un objet (contrairement à l'initialiseur statique qui initialise une classe) Un initialiseur d'instance est constitué d'un bloc d'instructions entre accolades (il peut y en avoir plusieurs dans une classe, ils seront exécutés dans l'ordre d'écriture du code dans le fichier source). Les initialiseurs d'instance sont exécutés après le constructeur de la classe parente et avant le constructeur de la classe dans laquelle ils sont déclarés. Conseil :Il est généralement préférable d'effectuer les initialisations de l'objet dans le constructeur de la classe. EIA-FR / Jacques Bapst PR1_11 10 EIA-FR / Jacques Bapst PR1_11 12

73 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Initialiseur d'instance [2] Java / Membres statiques, initialiseurs, finaliseurs, wrappers Wrappers [1] C o m p l é m e n t Exemple d'initialiseur d'instance : public class... {... private static int dim = 1000; private int[] intarr = new int[dim]; // intarr initialization { for(int i=0; i<dim; i++) { intarr[i] = i;... En Java, pour des raisons d'efficacité, les types primitifs ne sont pas des objets. Dans certaines circonstances, il peut être utile de pouvoir traiter les types primitifs comme des objets (par exemple pour pouvoir les enregistrer dans des structures de données abstraites de type liste, pile, arbre, ne manipulant généralement que des objets). Ainsi, il existe pour chaque type primitif, une classe Wrapper (classe d'emballage, classe enveloppe) qui permet de convertir (d'emballer) une variable (ou une valeur littérale) de type primitif en un objet correspondant (une instance d'une des classes d'emballage). Les classes Wrapper sont déclarées dans le paquetage java.lang (et sont donc accessibles sans importation explicite). Les classes Wrapper disposent d'un certain nombre de constantes et de méthodes (statiques et non-statiques) permettant d'effectuer diverses conversions. EIA-FR / Jacques Bapst PR1_11 13 EIA-FR / Jacques Bapst PR1_11 15 C o m p l é m e n t Java / Membres statiques, initialiseurs, finaliseurs, wrappers Finaliseur d'objet : finalize Un finaliseur représente l'opposé d'un constructeur et exécute du code de finalisation de l'objet. Le ramasse-miettes (garbage-collector) se charge de récupérer automatiquement l'espace mémoire utilisé par les objets (dès que ces derniers ne sont plus référencés). Le programmeur n'a pas à se soucier de cet aspect. Cependant, si l'objet contient d'autres types de ressources (fichiers ouverts, connexions réseau, transactions dans une base de données, etc.) il peut être nécessaire d'écrire du code de finalisation qui devra s'exécuter avant que l'objet disparaisse. Un finaliseur est une méthode d'instance (héritée de Object) -dont le nom est finalize() -qui ne possède aucun paramètre -qui ne retourne aucune valeur (void) La méthode finalize() (si elle a été définie) sera invoquée automatiquement par la machine virtuelle avant que le ramassemiettes ne détruise l'objet. Java / Membres statiques, initialiseurs, finaliseurs, wrappers Wrappers [2] Liste des classes d'emballage (Wrappers) : Type primitif byte short Classe Wrapper Byte Short int Integer (Et non pas Int!) long float double Long Float Double char Character (Et non pas Char!) boolean Boolean A deux exceptions près, le nom de la classe Wrapper correspond à celui du type primitif avec une majuscule initiale. Les classes Wrapper créent des objets immuables! EIA-FR / Jacques Bapst PR1_11 14 EIA-FR / Jacques Bapst PR1_11 16

74 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Wrappers [3] Exemples d'utilisation des classes Wrapper : String str = "1.23"; float primf = 3.456F; Float objf; primf = Float.MAX_VALUE; primf = Float.MIN_VALUE; // Plus grande valeur positive de type float // Plus petite valeur positive de type float objf = new Float(primF); // Conversion float -> Float primf = objf.floatvalue(); // Conversion Float -> float objf = new Float("2.34"); // Conversion String -> Float objf = Float.valueOf(str); // Conversion String -> Float str = objf.tostring(); // Conversion Float -> String str = Float.toString(primF); // Conversion float -> String primf = Float.parseFloat(str); // Conversion String -> float Ces exemples, donnés pour les types float et Float, s'appliquent par analogie aux autres types primitifs (avec quelques légères différences pour les types boolean et char). EIA-FR / Jacques Bapst PR1_11 17 Java / Membres statiques, initialiseurs, finaliseurs, wrappers Autoboxing / Unboxing C o m p l é m e n t Un mécanisme de conversions automatiques entre types primitifs et classes Wrapper a été introduit dans le langage. Lorsque c'est possible, le compilateur génère automatiquement le code de conversion entre les variables de types primitifs et les objets des classes Wrapper : Type primitif Classe Wrapper [ Autoboxing ] Classe Wrapper Type primitif [ Unboxing ]... int i=12, j, r; Integer obja =new Integer(34), objb; objb = i; // Autoboxing j = obja; // Unboxing r = ++obja + i;... EIA-FR / Jacques Bapst PR1_11 18

75 Java / Sous-classes, héritage et polymorphisme Arborescence de classes Informatique / Programmation L'héritage induit une relation arborescente entre les classes. A En notation UML, le symbole Programmation orientée objet avec Java 12 : Sous-classes, héritage et polymorphisme C B D signifie "est une sous-classe de" "hérite de" Jacques Bapst [email protected] -La classe A est la classe parente (super-classe) de B -La classe B est la classe parente de C et D -La classe B est une sous-classe de A -Les classes C et D sont des sous-classes de B B joue plusieurs rôles EIA-FR / Jacques Bapst PR1_12 3 Java / Sous-classes, héritage et polymorphisme Sous-classe et héritage L'héritage est une propriété essentielle de la programmation orientée objet. Ce mécanisme permet d'ajouter des fonctionnalités à une classe (une spécialisation) en créant une sous-classe qui hérite des propriétés de la classe parente et à laquelle on peut ajouter des propriétés nouvelles. La classe qui hérite est appelée sous-classe (ou classe dérivée) de la classe parente (qui est également appelée super-classe). L'héritage permet à une sous-classe d'étendre les propriétés de la classe parente tout en héritant des champs (attributs) et des méthodes (comportement) de cette classe parente. En Java, une classe ne peut hériter que d'une seule classe parente. On parle dans ce cas d'héritage simple (par opposition à l'héritage multiple qui permet à une classe d'hériter de plusieurs classes parentes). Java / Sous-classes, héritage et polymorphisme Exemple : classe Vehicule Pour illustrer le concept, prenons l'exemple d'une classe Vehicule permettant de décrire (très sommairement) les propriétés et les comportements d'un véhicule du monde réel. Avec une modélisation très simpliste, la classe pourrait être représentée de la manière suivante : Vehicule marque couleur vitesse etat demarrer() arreter() accelerer() freiner() EIA-FR / Jacques Bapst PR1_12 2 EIA-FR / Jacques Bapst PR1_12 4

76 Java / Sous-classes, héritage et polymorphisme Implémentation classe Vehicule public class Vehicule { private String marque; private String couleur; private double vitesse; // Vitesse actuelle private int etat; // 0:arrêt, 1:marche,... public Vehicule(String marque, String couleur) { this.marque = marque; this.couleur = couleur; vitesse = 0.0; etat = 0; public void demarrer() { etat = 1; public void arreter() { if (vitesse == 0) etat = 0; public void accelerer() { if (etat == 1) vitesse += 5.0; public void freiner() { if (vitesse >= 5.0) vitesse -= 5.0; else vitesse = 0.0; EIA-FR / Jacques Bapst PR1_12 5 Java / Sous-classes, héritage et polymorphisme Sous-classes Voiture et Camion La classe Voiture est une sous-classe de Vehicule. Elle hérite de tous les attributs et méthodes de Vehicule (marque, couleur,..., freiner()) en y ajoutant deux nouveaux attributs (modele et nbportes). La classe Camion est également une sous-classe de Vehicule et hérite de tous ses attributs et méthodes. La classe Camion étend la classe parente (Vehicule) en y ajoutant deux nouveaux attributs (chargemax et poidschargement) ainsi que deux nouvelles méthodes (charger() et decharger()). Dans les sous-classes Voiture et Camion, on peut utiliser les attributs et les méthodes héritées (par exemple couleur ou freiner()) comme si ces membres avaient été déclarés dans chacune des sous-classes (sous réserve, naturellement, que les droits d'accès le permettent). EIA-FR / Jacques Bapst PR1_12 7 Java / Sous-classes et héritage Sous-classes de Vehicule Java / Sous-classes, héritage et polymorphisme Déclaration de sous-classe A partir de la classe Vehicule on peut, en utilisant l'héritage, créer de nouvelles classes (Voiture et Camion) qui spécialisent la classe Vehicule en y ajoutant de nouvelles propriétés. Vehicule marque couleur vitesse etat demarrer() arreter() accelerer() freiner() Dans le langage UML, un tel diagramme est appelé "Diagramme de classes". Il montre les relations entre les classes d'une application La déclaration d'une sous-classe s'effectue en utilisant le mot-clé extends suivi du nom de la classe parente : public class Voiture extends Vehicule { private String modele; // Nouveau champ private int nbportes; // Nouveau champ public Voiture(String marque, String modele, String couleur, int nbportes) { // Constructeur Voiture modele nbportes Camion chargemax poidschargement charger() decharger() super(marque, couleur); // Appelle le constructeur de la classe parente this.modele = modele; this.nbportes = nbportes; EIA-FR / Jacques Bapst PR1_12 6 EIA-FR / Jacques Bapst PR1_12 8

77 Java / Sous-classes, héritage et polymorphisme Relations entre classes [1] L'héritage entre une sous-classe et sa classe parente est caractérisé par une relation de type "Est un..." ("Is a...") ou "Est une sorte de..." ("Is kind of...") Une voiture est un véhicule Un camion est un véhicule Attention : l'inverse n'est pas forcément vrai! Une sous-classe crée une spécialisation de la classe parente. A l'inverse, on parle de généralisation lorsqu'on passe des sousclasses à leur classe parente. Point à retenir lors de la conception d'une application : "Est un..." Héritage Java / Sous-classes, héritage et polymorphisme Relations entre classes [2] Il existe une autre relation importante qui peut exister entre deux classes. Il s'agit de la relation de composition (ou agrégation) qui est caractérisée par une relation de type ou ou ou "A un..." ("Has a...") "Possède un..." "Est composé de..." "Contient..." Une voiture possède un moteur Une voiture a un propriétaire "A un..." Composition Agrégation En Java, les relations de composition sont réalisées en créant dans la classe "contenant" une référence vers un objet de la classe "contenu". public class Voiture extends Vehicule { private Personne propriétaire; private FuelMotor moteur; EIA-FR / Jacques Bapst PR1_12 9 EIA-FR / Jacques Bapst PR1_12 11 Java / Sous-classes, héritage et polymorphisme Généralisation / Spécialisation Java / Sous-classes, héritage et polymorphisme Relations entre classes [3] En notation UML, la relation "A un", "Possède un", est représentée de la manière suivante : Oeuvre Voiture Spécialisation Roman Livre Film Opera BD Opera-Rock Généralisation C o m p l é m e n t Agrégation 1 Propriétaire Composition 4 Roue La distinction sémantique entre composition et agrégation ne se traduit pas (en Java) par des différences d'implémentation. public class Voiture extends Vehicule { private Personne leproprietaire; private Roue[] lesroues; EIA-FR / Jacques Bapst PR1_12 10 EIA-FR / Jacques Bapst PR1_12 12

78 Java / Sous-classes, héritage et polymorphisme Généralisation Java / Sous-classes, héritage et polymorphisme Classe Object Important! La relation d'héritage ("Est un...") permet de traiter les objets des sous-classes comme s'ils étaient des objets de leur classe parente (par généralisation). Camion Vehicule v1 = c1; c1 = new Camion(...); // Ok, un camion est un véhicule Camion c2 = v1; // ERREUR, un véhicule n'est pas forcément un camion! Camion c3 = (Camion)v1; // Ok, v1 référence effectivement un camion Si nécessaire, le système effectue donc une conversion élargissante (automatique) de la sous-classe vers la classe parente (Upcasting). Une conversion explicite (transtypage, casting) d'un objet de la classe parente vers un objet de la sous-classe (Downcasting) est possible si l'instance à convertir référence effectivement (au moment de l'exécution) un objet de la sous-classe considérée (sinon, il y aura une erreur ClassCastException à l'exécution). En Java, chaque classe que l'on crée possède une classe parente. Si l'on ne définit pas explicitement une classe parente (avec extends), la super-classe par défaut est Object (qui est déclarée dans le paquetage java.lang). La classe Object est donc l'ancêtre de toutes les classes Java (c'est la racine unique de l'arbre des classes). La classe Object est la seule classe Java qui ne possède pas de classe parente. Toutes les classes héritent donc des méthodes de la classe Object (par exemple tostring(), equals(), finalize(), etc). La classe Object constitue la généralisation ultime : Tous les objets sont des Object! EIA-FR / Jacques Bapst PR1_12 13 EIA-FR / Jacques Bapst PR1_12 15 Java / Sous-classes, héritage et polymorphisme Opérateur instanceof L'opérateur instanceof permet de tester (à l'exécution) l'appartenance d'un objet à une classe (ou une interface) donnée. Dans l'exemple précédent, on aurait pu écrire : if (v1 instanceof Camion) { c3 = (Camion)v1; else {... // v1 ne référence pas un Camion Un tel test permet d'éviter une erreur fatale (à l'exécution) si la variable v1 ne référence pas un objet de type Camion. Remarque 1 : (v1 instanceof Vehicule) est également vrai! Remarque 2 : L'upcasting et le downcasting n'engendrent aucune opération ni changement en mémoire (c'est une autre "vue" de l'objet) Java / Sous-classes, héritage et polymorphisme Chaînage des constructeurs Un constructeur d'une sous-classe peut faire appel à un constructeur de la classe parente en utilisant le mot réservé super selon la syntaxe suivante : super(expr1, Expr2,...); Si un constructeur d'une sous-classe invoque explicitement un constructeur de la classe parente, l'instruction super(...) doit être la première instruction du constructeur. Si l'on ne fait pas explicitement appel à un constructeur de la classe parente, une invocation du constructeur par défaut de la super-classe (constructeur sans paramètre) sera automatiquement ajoutée (comme première instruction). Si un tel constructeur n'existe pas dans la classe parente, une erreur sera générée à la compilation. Le langage garantit ainsi que tous les éléments des classes parentes aient été élaborés avant la création d'un objet de la classe considérée. EIA-FR / Jacques Bapst PR1_12 14 EIA-FR / Jacques Bapst PR1_12 16

79 C o m p l é m e n t Java / Sous-classes, héritage et polymorphisme Masquage des champs Si une sous-classe définit un champ avec le même nom qu'un champ de sa classe parente (une pratique à éviter), alors le champ de la super-classe est masqué dans le corps de la sous-classe. Dans ce cas, on peut, dans le corps de la sous-classe accéder au champ de la classe parente en utilisant le mot-clé super suivi d'un point et du nom du champ. Si les classes A et B définissent toutes deux un champ x et que B est une sous-classe de A alors, dans les méthodes de B, on peut utiliser : x Champ x de la classe B this.x super.x ((A)this).x Champ x de la classe B Champ x de la classe A Champ x de la classe A (par transtypage) La notation super.super.x n'est pas autorisée, seul le casting (((A)c).x) permet d'accéder à un champ masqué d'une classe ancêtre. Les champs statiques peuvent également être masqués mais ils restent accessibles en les préfixant avec le nom de la classe. Java / Sous-classes, héritage et polymorphisme Redéfinition des méthodes [2] Les classes Polygone et Rectangle définissent toutes deux une méthode area() avec une signature identique. La méthode invoquée par un appel obj.area() dépendra du type de l'objet référencé par la variable obj lors de l'exécution de cette instruction. C'est toujours la méthode associée au type effectif de l'objet référencé qui est exécutée, même si l'objet est enregistré dans une variable déclarée avec le type d'une classe parente : Rectangle r = new Rectangle(2.6, 5.3); Polygon p = r; // Conversion élargissante (Upcasting) double s = p.area(); // Invoque r.area() et non pas area() de la // classe Polygon car la variable p référence // un objet de type Rectangle EIA-FR / Jacques Bapst PR1_12 17 EIA-FR / Jacques Bapst PR1_12 19 Java / Sous-classes, héritage et polymorphisme Redéfinition des méthodes [1] Lorsqu'une classe définit une méthode d'instance en utilisant la même signature (même nom, type de retour [év. une sous-classe], paramètres, etc.) qu'une méthode de sa classe parente, cette méthode redéfinit (overrides) la méthode de sa super-classe. Par exemple : Polygon Rectangle public class Polygon { public double area() { // Calcul de la surface d'un polygone quelconque public class Rectangle extends Polygon { public double area() { // Calcul de la surface du rectangle (longueur*largeur) Java / Sous-classes, héritage et polymorphisme Redéfinition des méthodes [3] Dans la sous-classe Rectangle, il est possible d'invoquer la méthode area() de la classe parente Polygon en utilisant la notation suivante : super.area() Remarque : La notation super.super.f() n'est pas autorisée et il est impossible d'accéder à une méthode masquée d'une classe ancêtre (autre que la classe parente). A l'extérieur de la classe de déclaration, il n'est, par contre, pas possible pour un objet de type Rectangle, d'invoquer la méthode area de la classe Polygon. Attention à bien distinguer (et ne pas confondre) les notions de surcharge (overloading) et de redéfinition (overriding) de méthodes. EIA-FR / Jacques Bapst PR1_12 18 EIA-FR / Jacques Bapst PR1_12 20

80 Java / Sous-classes, héritage et polymorphisme Redéfinition des méthodes [4] Java / Sous-classes, héritage et polymorphisme Redéfinition des méthodes [6] C o m p l é m e n t L peut être utilisée pour indiquer explicitement l intention de redéfinir une méthode. Bien qu étant facultative, elle apporte deux avantages : Si on se trompe en écrivant le nom de la méthode lors de la redéfinition, le compilateur peut alors informer le programmeur de son erreur. La redéfinition étant explicite, le code est plus public double area() { C o m p l é m e n t Si une méthode est redéfinie dans une sous-classe, le type de retour doit être identique à celui de la méthode correspondante de la classe parente. En redéfinissant une méthode, il est possible d'étendre sa zone de visibilité (private package protected public) mais non de la restreindre. Une méthode redéfinie ne peut pas générer plus d'exceptions contrôlées que celles qui sont déclarées dans la méthode de la classe parente (mais elle peut en déclarer moins). Éviter de : surcharger une méthode qui est redéfinie redéfinir une partie des méthodes surchargées car cela provoque des risques de confusion et crée des pièges lors des modifications ultérieures des classes. EIA-FR / Jacques Bapst PR1_12 21 EIA-FR / Jacques Bapst PR1_12 23 Java / Sous-classes, héritage et polymorphisme Redéfinition des méthodes [5] Java / Sous-classes, héritage et polymorphisme Modificateur final Les méthodes statiques (méthodes de classe) peuvent être masquées, dans des sous-classes, par des méthodes statiques possédant le même nom (*** une pratique à éviter ***). Dans la déclaration d'une classe, le modificateur final indique que la classe ne peut pas être sous-classée (on ne peut pas créer de classes dérivées). C o m p l é m e n t Ces méthodes masquées restent cependant accessibles en les préfixant avec le nom de la classe dans laquelle elles sont définies (comme il est recommandé de le faire avec toutes les méthodes statiques). On ne peut donc pas spécialiser une méthode statique dans une sous-classe (comme les méthodes statiques ne sont jamais associées à un objet, le polymorphisme de s'applique pas). En outre, une méthode statique ne peut pas masquer une méthode d'instance d'une super-classe (erreur à la compilation). Dans la déclaration d'un champ, le modificateur final indique que la valeur du champ ne peut pas être modifiée après l'affectation initiale (dans la déclaration ou dans le constructeur). Permet de définir des valeurs constantes. Dans la déclaration d'une méthode, le modificateur final indique que la méthode ne peut pas être redéfinie dans une sous-classe. Dans la déclaration des paramètres d'une méthode, le modificateur final indique que la valeur de ces paramètres ne peut pas être modifiée (il s'agit de paramètres d'entrée de la méthode). Remarque : L'utilisation du modificateur final permet en outre au compilateur d'effectuer certaines optimisations : mise en ligne de méthodes (inlining), suppression de la recherche dynamique (late binding), etc. EIA-FR / Jacques Bapst PR1_12 22 EIA-FR / Jacques Bapst PR1_12 24

81 Java / Sous-classes, héritage et polymorphisme Modificateur protected Java / Sous-classes, héritage et polymorphisme Polymorphisme [1] Le modificateur protected appliqué aux membres (champs ou méthodes) d'une classe indique que ces champs ne sont accessibles que dans la classe de définition, dans les classes du même paquetage et dans les sous-classes de cette classe (indépendamment du paquetage). Il s'agit d'un accès plus restrictif que public mais - contrairement à ce que son nom pourrait laisser croire - moins restrictif que l'accès par défaut (package). Si l'on considère le diagramme de classes suivant : age poids mange() dort() Animal Le modificateur protected devrait être utilisé avec les champs et les méthodes qui ne sont pas requis par les utilisateurs de la classe mais qui pourraient s'avérer utiles à la création de sous-classes dans d'autres paquetages. nom mange() joue() Chien mange() nage() Poisson EIA-FR / Jacques Bapst PR1_12 25 EIA-FR / Jacques Bapst PR1_12 27 Java / Sous-classes, héritage et polymorphisme Modificateur private Java / Sous-classes, héritage et polymorphisme Polymorphisme [2] Le modificateur private, appliqué aux membres (champs ou méthodes) d'une classe, indique que ces champs ne sont accessibles que dans la classe de définition. Même s'il ne sont pas accessibles dans les sous-classes, les champs privés sont malgré tout hérités dans les sous-classes (une zone mémoire leur est allouée). Il s'agit de l'accès le plus restrictif. Le modificateur private devrait être utilisé avec les champs et les méthodes qui ne sont utilisés qu'au sein de la classe de définition et qui devraient être cachés partout ailleurs. Conseil : D'une manière générale il vaut mieux commencer par un accès restrictif aux membres d'une classe ( private). Si nécessaire, il est toujours possible de relâcher les restrictions dans des versions ultérieures de la classe. Un relâchement des restrictions préserve la compatibilité ascendante (ce qui n'est pas le cas si l'on restreint les droits d'accès). On peut déduire du diagramme de classes les considérations suivantes : Chien et Poisson sont des sous-classes d'animal Animal est la classe parente de Chien et de Poisson Chien hérite des membres d'animal (age, poids, dort()) Chien ajoute le champ nom Chien ajoute la méthode joue() Chien redéfinit la méthode mange() Poisson hérite des membres d'animal (age, poids, dort()) Poisson ajoute la méthode nage() Poisson redéfinit la méthode mange() EIA-FR / Jacques Bapst PR1_12 26 EIA-FR / Jacques Bapst PR1_12 28

82 Java / Sous-classes, héritage et polymorphisme Polymorphisme [3] Java / Sous-classes, héritage et polymorphisme Polymorphisme [5] Si l'on implémente les classes Animal, Chien et Poisson et que l'on écrit le code suivant : Chien milou = new Chien(...); milou.mange(); La méthode mange() qui sera invoquée est celle qui est définie dans la sous-classe Chien (car milou est du type Chien et la méthode mange() est redéfinie pour cette sous-classe). Si la sous-classe Chien ne redéfinissait pas la méthode mange(), ce serait alors la méthode mange() d'animal qui serait invoquée (la classe Chien en hériterait). En Java, dans la plupart des situations où il y a des relations d'héritage, la détermination de la méthode à invoquer n'est pas effectuée lors de la compilation. C'est seulement à l'exécution que la machine virtuelle déterminera la méthode à invoquer selon le type effectif de l'objet référencé à ce moment là. Ce mécanisme s'appelle "Recherche dynamique de méthode" (Late Binding ou Dynamic Binding). Ce mécanisme de recherche dynamique (durant l'exécution de l'application) sert de base à la mise en oeuvre de la propriété appelée polymorphisme. EIA-FR / Jacques Bapst PR1_12 29 EIA-FR / Jacques Bapst PR1_12 31 Java / Sous-classes, héritage et polymorphisme Polymorphisme [4] Java / Sous-classes, héritage et polymorphisme Polymorphisme [6] Comme un Chien est un Animal (relation d'héritage) on peut écrire le code suivant : Animal toutou = new Chien(...); toutou.mange(); Quelle méthode mange() sera invoquée dans ce cas? C'est toujours la méthode mange() définie dans la sous-classe Chien qui sera invoquée. Même si toutou est une référence de type Animal, c'est le type de l'objet référencé qui détermine la méthode qui sera appelée (comportement décrit sous "Redéfinition des méthodes"). On pourrait définir le polymorphisme comme la propriété permettant à un programme de réagir de manière différenciée à l'envoi d'un même message (invocation de méthode) en fonction des objets qui reçoivent ce message. Il s'agit donc d'une aptitude d'adaptation dynamique du comportement selon les objets en présence. Avec l'encapsulation et l'héritage, le polymorphisme est une des propriétés essentielles de la programmation orientée objet. Remarque : La surcharge de méthodes peut également être considérée comme une forme de polymorphisme. Le choix de la méthode à invoquer est cependant déterminé à la compilation EIA-FR / Jacques Bapst PR1_12 30 EIA-FR / Jacques Bapst PR1_12 32

83 Java / Sous-classes, héritage et polymorphisme Exemple de polymorphisme [1] L'exemple qui suit est destiné à illustrer le principe du polymorphisme. Il se base sur les classes précédemment définies (Animal, Chien et Poisson). Si l'on souhaite enregistrer et manipuler une collection d'animaux (une ménagerie) on peut créer et alimenter le tableau suivant : // Déclaration et création du tableau Animal[] menagerie = new Animal[6]; // Alimentation du tableau menagerie[0] = new Poisson(...); menagerie[1] = new Chien(...); menagerie[2] = new Chien(...); menagerie[3] = new Animal(...); menagerie[4] = new Poisson(...); menagerie[5] = new Chien(...); Java / Sous-classes, héritage et polymorphisme Exemple de polymorphisme [3] On peut ensuite appeler la méthode nourrir() en lui passant en paramètre la ménagerie précédemment créée : nourrir(menagerie); Sur la base du contenu de menagerie, la méthode nourrir() appellera successivement : mange() de la classe Poisson mange() de la classe Chien mange() de la classe Chien mange() de la classe Animal mange() de la classe Poisson mange() de la classe Chien La méthode nourrir() n'a pas besoin de déterminer elle-même quelle méthode doit être appelée pour chaque animal. Le polymorphisme fera en sorte que le message mange() soit interprété (à l'exécution) de manière appropriée selon les objets qui le reçoivent (ainsi chaque animal mangera selon ses goûts!). EIA-FR / Jacques Bapst PR1_12 33 EIA-FR / Jacques Bapst PR1_12 35 Java / Sous-classes, héritage et polymorphisme Exemple de polymorphisme [2] Le polymorphisme nous permet d'écrire une méthode nourrir dont la fonction est de donner à manger à chaque animal contenu dans le tableau passé en paramètre en appelant successivement la méthode mange() pour chacun d'eux. // // Appelle la méthode mange() pour chaque animal contenu // dans le tableau passé en paramètre // public static void nourrir(animal[] tabanimaux) { if (tabanimaux == null) return; for (int i=0; i<tabanimaux.length; i++) { if (tabanimaux[i]!= null) { tabanimaux[i].mange(); EIA-FR / Jacques Bapst PR1_12 34 Java / Sous-classes, héritage et polymorphisme Polymorphisme Synthèse du mécanisme En Java, les variables sont typées. Avec la notion d'héritage, plusieurs «types» peuvent être compatibles avec une déclaration de variable. short s; // Ne peut rien contenir d'autre qu'un short Object o; // Peut contenir une référence vers un Object, // ou un objet d une sous-classe Le compilateur s assure que les instructions sont compatibles avec la déclaration : Object o; o = "ah"; int i=o.length(); // Refusé, car length() œ Object int i=((string)o).length(); // Ok si o référence un String A l exécution, Java «suit toujours la flèche» pour atteindre les méthodes : Animal a; public class Animal { void mange() {... a = new Chien(); a.mange(); // Ce sera bien la méthode redéfinie par la // classe Chien qui sera exécutée public class Chien extends Animal { void mange() {... // Redéfinition! EIA-FR / Jacques Bapst PR1_12 36

84 Java / Classes abstraites et interfaces Classes abstraites : métaphore Informatique / Programmation Programmation orientée objet avec Java 13 : Classes abstraites et interfaces Jacques Bapst [email protected] Comme les autres classes (et les interfaces), une classe abstraite définit un nouveau type qui peut être associé à un identificateur (déclaration de variables, champs, tableaux, paramètres formels, ). Comme nous l'avons vu dans un des chapitres précédents, les classes peuvent être considérées comme étant des moules (des modèles, des plans,...) permettant de fabriquer des objets. Si l'on poursuit avec cette métaphore, les classes abstraites peuvent être considérées comme étant des moules incomplets (des modèles partiels, des plans non terminés,...) qui ne peuvent pas être utilisés tels quels pour créer des objets mais qui peuvent être utilisés pour fabriquer d'autres plans plus précis (représentés par des sous-classes) qui seront complétés et qui permettront, eux, de créer des objets (des instances des sousclasses). EIA-FR / Jacques Bapst PR1_13 3 Java / Classes abstraites et interfaces Classes et méthodes abstraites Java / Classes abstraites et interfaces Classes abstraites Une classe abstraite est une classe qui contient une ou plusieurs méthodes abstraites. Elle peut malgré tout contenir d'autres méthodes habituelles (appelée parfois méthodes concrètes). Une méthode abstraite est une méthode qui ne contient pas de corps. Elle possède simplement une signature de définition suivie du caractère point-virgule (pas de bloc d'instructions). Classe abstraite extends Classe concrète new Instances (Objets) Une méthode abstraite doit obligatoirement être déclarée avec le modificateur abstract. Objet 1 Exemple : public abstract double area(); Objet 2 Une classe possédant une ou plusieurs méthodes abstraites devient obligatoirement une classe abstraite. Cette classe doit également être déclarée avec le modificateur abstract. Objet 3 EIA-FR / Jacques Bapst PR1_13 2 EIA-FR / Jacques Bapst PR1_13 4

85 Java / Classes abstraites et interfaces Classes abstraites : règles [1] Java / Classes abstraites et interfaces Utilité des classes abstraites Les règles suivantes s'appliquent aux classes abstraites : Une classe abstraite ne peut pas être instanciée : on ne peut pas créer d'objet en utilisant l'opérateur new. Une sous-classe d'une classe abstraite ne peut être instanciée que si elle redéfinit chaque méthode abstraite de sa classe parente et qu'elle fournit une implémentation (un corps) pour chacune des méthodes abstraites. Une telle sous-classe est souvent appelée sous-classe concrète afin de mettre en évidence le fait qu'elle n'est pas abstraite. Si une sous-classe d'une classe abstraite n'implémente pas toutes les méthodes abstraites dont elle hérite, cette sous-classe est elle-même abstraite (et ne peut donc pas être instanciée). Les méthodes déclarées avec l'un des modificateurs suivants : static, private ou final ne peuvent pas être abstraites étant donné qu'elles ne peuvent pas être redéfinies dans une sous-classe. En pratique, les classes abstraites permettent de définir des fonctionnalités (des comportements) que les sous-classes devront impérativement implémenter même si la classe abstraite n'est pas en mesure de fournir elle-même une implémentation pour ces méthodes. Les utilisateurs des sous-classes d'une classe abstraite sont donc assurés de trouver toutes les méthodes définies dans la classe abstraite dans chacune des sous-classes concrètes. Les classes abstraites constituent donc une sorte de contrat (spécification contraignante) qui garantit que certaines méthodes seront disponibles dans les sous-classes et qui oblige les programmeurs à les implémenter dans toutes les sous-classes concrètes. EIA-FR / Jacques Bapst PR1_13 5 EIA-FR / Jacques Bapst PR1_13 7 Java / Classes abstraites et interfaces Classes abstraites : règles [2] Java / Classes abstraites et interfaces Exemple de classe abstraite [1] Autres règles s'appliquant aux classes abstraites : Une classe déclarée final ne peut pas contenir de méthodes abstraites car elle ne peut pas être sous-classée. Une classe peut être déclarée abstract même si elle ne possède pas réellement de méthode abstraite. Cela signifie que son implémentation est incomplète en certains points (p. ex. le corps de certaines méthodes doit être complété en fonction du contexte) et qu'elle est destinée à jouer le rôle de classe parente pour une ou plusieurs sous-classes qui achèveront l'implémentation. Si l'on souhaite, par exemple, créer une hiérarchie de classes qui décrive des formes géométriques à deux dimensions, on pourrait envisager l'arborescence représentée par le diagramme de classes suivant : Shape Circle Rectangle Triangle Même si elle ne possède pas de méthodes abstraites, une telle classe ne peut pas être instanciée (erreur à la compilation). Square EIA-FR / Jacques Bapst PR1_13 6 EIA-FR / Jacques Bapst PR1_13 8

86 Java / Classes abstraites et interfaces Exemple de classe abstraite [2] Sachant que toutes les formes possèdent les propriétés périmètre et surface, il est judicieux de placer les méthodes définissant ces propriétés (perimeter() et area()) dans la classe qui est à la racine de l'arborescence (Shape). La classe Shape ne peut cependant pas implémenter ces deux méthodes car on ne peut pas calculer le périmètre et la surface sans connaître le détail de la forme. On pourrait naturellement implémenter ces méthodes dans chacune des sous-classes de Shape mais il n'y a aucune garantie que toutes les sous-classes les possèdent (ce serait laissé au bon vouloir des programmeurs des sous-classes). Il est possible de résoudre ce problème en déclarant dans la classe Shape deux méthodes abstraites perimeter() et area() ce qui rend la classe Shape elle-même abstraite et impose aux créateurs de sous-classes de les implémenter. Java / Classes abstraites et interfaces Exemple de classe abstraite [4] // // Rectangle // public class Rectangle extends Shape { protected double length, width; public Rectangle(double length, double width) { this.length = length; this.width = width; public double getlength() { return length; public double getwidth() { return width; public double perimetre() { return 2*(length + width); public double surface() { return length * width; EIA-FR / Jacques Bapst PR1_13 9 EIA-FR / Jacques Bapst PR1_13 11 Java / Classes abstraites et interfaces Exemple de classe abstraite [3] // // Shape // public abstract class Shape { // Classe abstraite public abstract double perimeter(); // Méthode abstraite public abstract double area(); // Méthode abstraite // // Circle // public class Circle extends Shape { public static final double PI = ; private double radius; public Circle(double radius) { this.radius = radius; public double getradius() { return radius; public double perimeter() { return 2*PI*radius; public double area() { return PI*radius*radius; EIA-FR / Jacques Bapst PR1_13 10 Java / Classes abstraites et interfaces Exemple de classe abstraite [5] Les autres sous-classes (Square, Triangle,...) pourraient être implémentées selon le même modèle. Même si la classe Shape est abstraite, il est tout de même possible de déclarer des variables de ce type qui pourront recevoir des objets créés à partir des sous-classes concrètes : Shape[] drawing = new Shape[3]; drawing[0] = new Rectangle(2.5, 6.8); drawing[1] = new Circle(4.66); drawing[2] = new Square(0.125); // Conversion élargissante // Conversion élargissante // Conversion élargissante Le polymorphisme permet ensuite d'invoquer une méthode commune sur chacun des objets : double totalarea = 0.0; for (int i=0; i<drawing.length; i++) { totalarea += drawing[i].area(); // Calcule la somme // des surfaces EIA-FR / Jacques Bapst PR1_13 12

87 Java / Classes abstraites et interfaces Interface [1] Comme une classe et une classe abstraite, une interface permet de définir un nouveau type (référence). Le comportement des objets de ce type (les opérations que l'on peut effectuer) sera déterminé par le contenu (la définition) de cette interface. Une interface constitue essentiellement une spécification qui laisse de côté les détails d'implémentation. L'interface définit ainsi une sorte de contrat que les classes qui l'implémenteront s'engagent à respecter. Les interfaces jouent un rôle important dans la phase de conception (API) d'applications, de librairies ou de systèmes basés sur des ensembles d'objets qui communiquent. Par certains aspects, la notion d'interface est assez proche de la notion de classe abstraite mais elle comporte cependant un certain nombre de spécificités qui l'en distinguent et qui en étendent le potentiel. EIA-FR / Jacques Bapst PR1_13 13 Java / Classes abstraites et interfaces Interface [3] Le corps d'une interface peut contenir : Des constantes qui sont implicitement publiques Les modificateurs static et final ne sont pas nécessaires (implicites). Des méthodes abstraites qui sont obligatoirement publiques Le modificateur abstract n'est pas nécessaire (implicite). Le modificateur public n'est pas nécessaire (implicite). Des méthodes avec une implémentation par défaut Le modificateur default doit être utilisé. Des méthodes statiques. Par contre Une interface ne peut pas définir de champs d'instance. Une interface ne définit pas de constructeur (on ne peut pas l'instancier et elle n'intervient pas dans le chaînage des constructeurs). EIA-FR / Jacques Bapst PR1_13 15 Java / Classes abstraites et interfaces Interface [2] Du point de vue syntaxique, la définition d'une interface est proche de celle d'une classe abstraite. Il suffit de remplacer les mots-clés abstract class par le motclé interface : public interface Printable { public void print(); Une fois l'interface déclarée, il est possible de déclarer des variables de ce (nouveau) type : Printable document; Printable[] printspool; Java / Classes abstraites et interfaces Utilisation des interfaces [1] En Java, une classe ne peut hériter que d'une et d'une seule classe parente (héritage simple). Une classe peut, par contre, implémenter une ou plusieurs interfaces en utilisant la syntaxe suivante : implements interface1, interface2,... L'implémentation d'une ou de plusieurs interfaces (implements) peut être combinée avec l'héritage simple (extends). La clause implements doit suivre la clause extends. Exemples : public class Report implements Printable {... public class Book implements Printable, Zoomable {... public class Circle extends Shape implements Printable {... public class Square extends Rectangle implements Printable, Zoomable {... EIA-FR / Jacques Bapst PR1_13 14 EIA-FR / Jacques Bapst PR1_13 16

88 Java / Classes abstraites et interfaces Utilisation des interfaces [2] Lorsqu'une classe déclare une interface dans sa clause implements, elle indique ainsi qu'elle s'engage à fournir une implémentation (c'est-à-dire un corps) pour chacune des méthodes abstraites de cette interface. Si une classe implémente une interface mais ne fournit pas d'implémentation pour toutes les méthodes abstraites de l'interface, elle hérite des méthodes (abstraites) non implémentées de l'interface et doit elle-même être déclarée abstract. Si une classe implémente plus d'une interface, elle doit implémenter toutes les méthodes abstraites de chacune des interfaces mentionnées dans la clause implements (ou alors être déclarée abstract). Les méthodes de l'interface qui sont déclarées avec une implémentation par défaut peuvent être redéfinies (ou non) dans les classes qui implémentent l'interface. Java / Classes abstraites et interfaces Exemple d'interface [2] Tous les objets dont la classe implémente l'interface Comparable pourront ensuite être triés. public class Person implements Comparable { private int age; public int compareto(object p) { if (p instanceof Person) { if (this.age < ((Person)p).age) return -1; if (this.age > ((Person)p).age) return 1; return 0; else Person[] population; Tools.sort(population); EIA-FR / Jacques Bapst PR1_13 17 EIA-FR / Jacques Bapst PR1_13 19 Java / Classes abstraites et interfaces Exemple d'interface [1] Si l'on souhaite caractériser la fonctionnalité de comparaison qui est commune à tous les objets qui ont une relation d'ordre (plus petit, égal, plus grand), on peut définir l'interface Comparable de la manière suivante : public interface Comparable { public int compareto(object v); Cette interface définit un type de données qui peut ensuite être utilisé dans des traitements qui nécessitent une relation d'ordre, dans une méthode de tri par exemple : public class Tools { public static void sort(comparable[] t) { if (t[i].compareto(t[j]) > 0) Java / Classes abstraites et interfaces Exemple d'interface [3] Supposons que nous voulions que les classes dérivées de la classe Shape disposent toutes d'une méthode print() permettant d'imprimer les formes géométriques. Il serait naturellement possible d'ajouter une méthode abstraite print() à la classe Shape et ainsi chacune des sous-classes concrètes devrait implémenter cette méthode. L'utilisateur de ces sous-classes serait ainsi sûr de disposer d'une méthode print() lui permettant d'imprimer la forme. Avec cette solution, le problème serait résolu pour toutes les sous-classes de Shape, mais si d'autres classes (qui n'héritent pas de Shape) souhaitaient également disposer des fonctions d'impression, elles devraient à nouveau déclarer des méthodes abstraites d'impression dans leur arborescence. L'utilisation d'une interface permet de résoudre ce problème de manière plus élégante en découplant la fonctionnalité d'impression de la hiérarchie des classes. EIA-FR / Jacques Bapst PR1_13 18 EIA-FR / Jacques Bapst PR1_13 20

89 Java / Classes abstraites et interfaces Exemple d'interface [4] Au lieu d'ajouter une méthode abstraite print() dans la classe Shape nous créons une interface nommée Printable qui définit la méthode abstraite print() : public interface Printable { public void print(); Et nous déclarons que la classe Shape implémente l'interface Printable (le corps de la classe Shape reste inchangé) : public abstract class Shape implements Printable { public abstract double perimeter(); // Méthode abstraite public abstract double area(); // Méthode abstraite EIA-FR / Jacques Bapst PR1_13 21 Java / Classes abstraites et interfaces Exemple d'interface [6] L'implémentation des sous-classes de Shape s'effectue donc de la même manière que si la méthode print() avait été déclarée comme méthode abstraite dans Shape. L'avantage de l'interface Printable réside dans le fait qu'elle peut être utilisée avec d'autres classes qui n'ont rien à voir avec la classe Shape : public class Book extends Document implements Printable { Un autre avantage est que l'interface Printable peut être utilisée en combinaison avec d'autres interfaces, ce qui n'est pas possible avec les classes (car une sous-classe ne peut pas avoir plusieurs super-classes). public class Book extends Document implements Printable, Zoomable { EIA-FR / Jacques Bapst PR1_13 23 Java / Classes abstraites et interfaces Exemple d'interface [5] Chaque sous-classe concrète de Shape devra obligatoirement implémenter le corps de la méthode print() (en plus des méthodes abstraites perimeter() et area()) : // // Circle // public class Circle extends Shape { public static final double PI = ; private double radius; public Circle(double radius) { this.radius = radius; public double getradius() { return radius; public double perimeter() { return 2*PI*radius; public double area() { return PI*radius*radius; public void print() {... Java / Classes abstraites et interfaces Interface fonctionnelle Une interface fonctionnelle est une interface comprenant exactement une méthode abstraite. Une interface fonctionnelle peut malgré tout comporter des constantes, des méthodes avec une implémentation par défaut, des méthodes redéclarant certaines méthodes de la classe Object ainsi que des méthodes statiques. La notion d'interface fonctionnelle joue un rôle important en lien avec l'utilisation des expressions Lambda. peut précéder la déclaration des interfaces fonctionnelles. Ainsi, le compilateur vérifiera que les règles énoncées soient public interface SimpleFuncInterface { public void dowork(); EIA-FR / Jacques Bapst PR1_13 22 EIA-FR / Jacques Bapst PR1_13 24

90 Java / Classes abstraites et interfaces Classe abstraite ou interface? Lors de la conception d'une application ou d'une librairie, le choix conceptuel entre une classe abstraite et une interface n'est pas toujours facile. Parmi les points à prendre en considération, on peut rappeler que : Une classe peut implémenter plusieurs interfaces mais ne peut hériter que d'une seule classe abstraite. Une interface peut être implémentée par une classe sans qu'il y ait de rapports étroits entre les deux. Une sous-classe est liée par une relation plus forte ("Est un..." ). Les classes abstraites et les interfaces permettent de définir des implémentation par défaut pour les méthodes. Les interfaces fonctionnelles (une seule méthode abstraite) peuvent être implémentées par des expressions Lambdas ou des références de méthodes permettant ainsi d'alléger le code. Java / Classes abstraites et interfaces Gestion des exceptions Les méthodes concrètes ne peuvent pas annoncer plus d'exceptions contrôlées dans leurs clauses throws, que celles qui sont annoncées dans la déclaration des méthodes abstraites qu'elles implémentent (déclaration dans classe abstraite ou interface). public interface Writable { public void write(object o) throws IOException, MemOverflow; public class Buffer implements Writable { public void write(object o) throws MemOverflow, ArithmeticException { La méthode concrète write() n'a pas l'obligation d'annoncer toutes les exceptions définies dans l'interface Writable (on ne peut pas imposer une liste d'exceptions). Elle ne peut pas annoncer d'exceptions contrôlées supplémentaires mais peut ajouter des exceptions non-contrôlées (comme ArithmeticException par exemple). EIA-FR / Jacques Bapst PR1_13 25 EIA-FR / Jacques Bapst PR1_13 27 Java / Classes abstraites et interfaces Extension des interfaces Les interfaces peuvent avoir des sous-interfaces (tout comme les classes peuvent avoir des sous-classes). Comme pour les classes, le mot-clé extends est utilisé pour créer une sous-interface. public interface Zoomable extends Observable {... Une sous-interface hérite de toutes les méthodes et de toutes les constantes de son interface parente et peut définir de nouvelles méthodes ainsi que de nouvelles constantes. Contrairement aux classes, une interface peut posséder plusieurs interfaces parentes (héritage multiple). public interface Transformable extends Scalable, Translatable, Rotatable {... Une classe qui implémente une sous-interface doit implémenter les méthodes abstraites définies directement par l'interface ainsi que les méthodes abstraites héritées de toutes les interfaces parentes de la sous-interface. Java / Classes abstraites et interfaces Conflits de noms [1] Des conflits de noms (collision) peuvent se produire lorsqu'une classe implémente plusieurs interfaces comportant des noms de méthodes ou de constantes identiques. Il faut distinguer plusieurs situations : Plusieurs méthodes portent des signatures identiques : Pas de problème, la classe doit implémenter cette méthode Mêmes noms de méthodes mais profils de paramètres différents : Implémentation de deux ou plusieurs méthodes surchargées Mêmes noms de méthodes, profils de paramètres identiques, mais types des valeurs de retour différents : Pas possible d'implémenter les deux interfaces (cela provoquera une erreur à la compilation : Interface-Collision) Seulement les listes d'exceptions sont différentes : La méthode ne peut pas générer plus d'exceptions contrôlées que celles correspondant à l'intersection de l'ensemble des clauses d'exception EIA-FR / Jacques Bapst PR1_13 26 EIA-FR / Jacques Bapst PR1_13 28

91 Java / Classes abstraites et interfaces Conflits de noms [2] Noms de constantes identiques dans plusieurs interfaces : Doivent être accédées en utilisant la notation qualifiée (Interface.Constante) Plusieurs méthodes portent des signatures identiques mais ont des implémentations par défaut différentes : Erreur détectée par le compilateur Obligation de redéfinir la méthode en conflit dans la classe qui implémente les interfaces Les méthodes par défaut peuvent malgré tout être invoquée avec la syntaxe Interface.super.Méthode EIA-FR / Jacques Bapst PR1_13 29 Java / Classes abstraites et interfaces Interface de marquage Il est parfois utile de définir une interface entièrement vide appelée interface de marquage. Une classe peut implémenter cette interface en la nommant dans la clause implements sans avoir à implémenter de méthodes. Dans ce cas, toutes les instances de la classe deviennent des instances valables de l'interface. Il est donc possible de tester si un objet implémente l'interface de marquage à l'aide de l'opérateur instanceof : if (obj instanceof Cloneable) {... Une interface de marquage sert à communiquer aux instances qui l'implémentent des informations supplémentaires concernant l'objet, son comportement, son implémentation, Les interfaces java.lang.cloneable et java.io.serializable constituent deux exemples d'interfaces de marquage de la plateforme Java. EIA-FR / Jacques Bapst PR1_13 30

92 Java / Classes internes Classes membres statiques [1] Informatique / Programmation Une classe membre statique est une classe définie comme un membre statique d'une autre classe. Des interfaces peuvent également être déclarées comme membres statiques d'une classe. Les remarques qui suivent s'appliquent donc également aux interfaces membres statiques. Programmation orientée objet avec Java 14 : Classes internes Jacques Bapst [email protected] Par analogie avec les méthodes statiques, on pourrait parler de "classe de classe" (mais cela porte un peu à confusion). Une classe membre statique se comporte comme une classe de premier niveau avec en outre la possibilité d'accéder aux membres statiques de la classe qui la contient (classe englobante). Une classe membre statique a accès à tous les membres statiques de sa classe englobante, y compris les membres privés (private). L'inverse est également vrai : les méthodes de la classe englobante ont accès à tous les membres (statiques ou non-statiques) d'une classe membre statique, y compris les membres privés. EIA-FR / Jacques Bapst PR1_14 3 Java / Classes internes Classes internes Jusqu'à présent, les classes (et interfaces) que nous avons vues étaient toutes des classes (et interfaces) de premier niveau (c'està-dire des membres directs des paquetages, sans imbrication). Le langage Java permet cependant de définir des classes à l'intérieur d'autres classes. On parle dans ce cas de classes internes (Nested Class). Il existe quatre types de classes internes : Les classes membres statiques (Static Nested Class) Les classes membres Les classes locales Les classes anonymes (Inner Class) (Local Inner Class) (Anonymous Inner Class) Attention :D'un auteur à l'autre, le vocabulaire utilisé pour qualifier ces différentes classes internes peut varier sensiblement. Java / Classes internes Classes membres statiques [2] Une classe membre statique a même accès à tous les membres des autres classes membres statiques (classes "sœurs"), y compris aux membres déclarés private de ces classes. Une classe membre statique peut être déclarée avec ses propres modificateurs de contrôle d'accès. Ces modificateurs (public, protected, private, aucun) possèdent les mêmes significations que pour les autres membres d'une classe (champs et méthodes). En dehors de la classe englobante, une classe membre statique est nommée en combinant le nom de la classe externe avec le nom de la classe interne. Par exemple : LinkedStack.Linkable node Restrictions : Une classe membre statique ne peut pas posséder le même nom qu'une de ses classes englobantes. Une classe membre statique ne peut être englobée que dans une classe de premier niveau ou dans une classe membre statique. EIA-FR / Jacques Bapst PR1_14 2 EIA-FR / Jacques Bapst PR1_14 4

93 Java / Classes internes Exemple d'interface membre statique Java / Classes internes Classes membres [2] //===== Une classe qui implémente une pile sous forme de liste chaînée ===== public class LinkedStack { // Interface membre statique qui définit la manière dont les objets sont liés public static interface Linkable { public Linkable getnext(); public void setnext(linkable node); // La tête de liste est un objet de type Linkable Linkable head; // Les corps des méthodes sont omis public void push(linkable node) {... public Linkable pop() {... //===== Cette classe implémente l'interface membre statique ===== public class LinkableInteger implements LinkedStack.Linkable { // Les données et le constructeur du noeud int i; public LinkableInteger(int i) { this.i = i; // Données et méthodes requises pour implémenter l'interface LinkedStack.Linkable next; public LinkedStack.Linkable getnext() { return next; public void setnext(linkedstack.linkable node) { next = node; Restrictions : Une classe membre ne peut pas porter le même nom qu'une classe ou qu'un paquetage englobant (une telle restriction ne s'applique pas aux champs et aux méthodes). Les classes membres ne peuvent pas contenir de champs, de méthodes ou de classe déclarés static (à l'exception des constantes qui sont déclarées à la fois static et final). Pour instancier une classe membre à l'extérieur de la classe de définition, il faut disposer d'une instance de la classe englobante. On utilisera cette instance avec l'opérateur new pour créer un objet de la classe membre. Syntaxe : InstanceExt.new ClasseInterne Exemple : ExtClName eobj = new ExtClName( ); // Objet externe ExtClName.IntClName iobj = eobj.new IntClName( ); et non pas : ExtClName.IntClName iobj = eobj.new ExtClName.IntClName( ); // Objet interne EIA-FR / Jacques Bapst PR1_14 5 EIA-FR / Jacques Bapst PR1_14 7 Java / Classes internes Classes membres [1] Java / Classes internes Classes membres [3] Une classe membre est une classe qui est déclarée comme un membre non-statique d'une classe englobante. Les interfaces ne peuvent pas être déclarées comme membres non-statiques d'une classe. Une instance d'une classe membre est toujours associée à une instance (un objet) de la classe englobante. Le code d'une classe membre a accès à tous les champs et à toutes les méthodes (autant statiques que non-statiques et même s'ils sont déclarés privés) de sa classe englobante et des classes "sœurs". Comme tous les autres membres de la classe, une classe membre peut être déclarée avec ses propres modificateurs de contrôle d'accès. Ces modificateurs (public, protected, private, aucun) possèdent les mêmes significations que pour les autres membres de la classe (champs et méthodes). C o m p l é m e n t Une syntaxe particulière est utilisée pour accéder explicitement aux champs et méthodes d'instance de son objet englobant. Cette syntaxe n'est nécessaire que pour référencer un membre d'une classe englobante qui est masqué par un membre du même nom dans la classe interne (ce qui est à éviter!) : Nom_Classe_Englobante. this. Nom_Membre LinkedStack.this.head Il est également possible d'accéder à un champ masqué ou à une méthode redéfinie d'une super-classe de la classe englobante : Nom_Classe_Englobante. super. Nom_Membre Reactor.super.run() Une classe de premier niveau peut étendre (spécialiser) une classe membre ce qui introduit deux hiérarchies distinctes (la hiérarchie de classes habituelle + une hiérarchie de confinement) qui affectent les éléments visibles (portée). A éviter! EIA-FR / Jacques Bapst PR1_14 6 EIA-FR / Jacques Bapst PR1_14 8

94 Java / Classes internes Exemple de classe membre //===== Une classe qui implémente une pile sous forme de liste chaînée ===== public class LinkedStack { // Interface membre statique qui définit la manière dont les objets sont liés public static interface Linkable {... // Contenu omis private Linkable head; public void push(linkable node) {... public Linkable pop() {... // Contenu omis // Contenu omis // Cette méthode retourne un objet de type Enumeration pour l'objet LinkedStack courant public java.util.enumeration enumerate() { return new Enumerator(); // Classe membre qui implémente l'interface Enumeration protected class Enumerator implements java.util.enumeration { Linkable current; // Le constructeur utilise le champ privé head de la classe englobante public Enumerator() { current = head; public boolean hasmoreelements() { return (current!= null); public Object nextelement() { if (current==null) throw new java.util.nosuchelementexception(); Object value = current; current = current.getnext(); return value; Java / Classes internes Classes locales [2] Les restrictions suivantes s'appliquent aux classes locales : Une classe locale n'est visible qu'au sein du bloc qui la définit; elle ne peut jamais être utilisée hors de ce bloc. Les classes locales ne peuvent pas être déclarées public, protected, private ou static. Ces modificateurs sont réservés aux membres de la classe. Pour les mêmes raisons que les classes membres, les classes locales ne peuvent pas contenir de champs, de méthodes ou de classes statiques (à l'exception des constantes déclarées static final). Une classe locale ne peut pas avoir le même nom qu'une de ses classes englobantes. Une classe locale ne peut accéder aux variables locales et paramètres de méthode qui se trouvent dans sa portée que si ces variables et paramètres sont déclarés avec le modificateur final. Dans ce cas, le compilateur créera une copie de ces variables locales car leur durée de vie peut être plus courte que celle des instances de la classe locale. EIA-FR / Jacques Bapst PR1_14 9 EIA-FR / Jacques Bapst PR1_14 11 Java / Classes internes Classes locales [1] Une classe locale est une classe qui est déclarée au sein d'un bloc de code Java (généralement dans une méthode). Tout comme une variable locale, une classe locale n'est visible qu'à l'intérieur du bloc dans lequel elle a été déclarée. Les classes locales sont déclarée à l'intérieur d'une classe englobante et elles partagent de ce fait plusieurs caractéristiques des classes membres. Les interfaces ne peuvent pas être déclarées localement. Le code d'une classe locale peut accéder à tous les membres (y compris aux membres privés) de la classe englobante. Les classes locales peuvent également accéder à toutes les variables locales et aux paramètres de méthode qui se trouvent dans la portée de la définition locale de la méthode pour autant qu'ils soient déclarés final (car la durée de vie d'une instance d'une classe locale peut être plus longue que l'exécution de la méthode dans laquelle elle est déclarée). EIA-FR / Jacques Bapst PR1_14 10 Java / Classes internes Exemple de classe locale //===== Un exemple de classe locale utilisant des variables locales ===== public class TestLocalClass { // Interface membre statique public static interface IntHolder { public int getvalue(); public static void main(string[] args) { IntHolder[] holders = new IntHolder[10]; for (int i=0; i<10; i++) { final int fi = i; // Classe locale pouvant utiliser les variables locales déclarées final class MyIntHolder implements IntHolder { public int getvalue() { return fi; holders[i] = new MyIntHolder(); // Instancie la classe locale // La classe locale et la variable fi ne sont plus visibles mais on peut malgré tout utiliser // le tableau d'instance holders et afficher les valeurs 0 9 (1) for (int i=0; i<10; i++) System.out.println(holders[i].getValue()); (1) Pour expliquer ce comportement assez surprenant, il faut savoir que chaque instance d'une classe locale possède une copie privée de chaque variable locale déclarée final qu'elle utilise. Ainsi, l'instance mémorise l'état des variables qui étaient dans sa portée au moment où elle a été créée. EIA-FR / Jacques Bapst PR1_14 12

95 Java / Classes internes Classes anonymes [1] Une classe anonyme est une classe locale qui ne possède pas de nom. Une classe anonyme est soit : une sous-classe d'une classe parente existante une classe qui implémente une interface existante (c'est donc également une sous-classe d'object) Une classe anonyme combine la déclaration et l'instanciation de la sous-classe sous la forme d'une expression qui peut apparaître comme fragment d'une expression plus grande (par exemple dans une invocation de méthode). Lorsqu'une sous-classe locale (ou classe implémentant une interface) n'est utilisée qu'une seule fois, on peut envisager d'en faire une classe anonyme qui place la définition et l'utilisation de la classe au même endroit. Cela peut, dans certains cas, favoriser la compacité et la lisibilité du code source. Java / Classes internes Classes anonymes [3] Les classes anonymes constituent une forme particulière de classes locales et toutes les restrictions mentionnées pour les classes locales s'appliquent également aux classes anonymes. En plus, on peut mentionner la restriction suivante : Comme les classes anonymes ne possèdent pas de nom, il n'est pas possible de définir explicitement des constructeurs (elles possèdent uniquement le constructeur par défaut). En remplacement, on peut cependant créer un initialiseur d'instance qui pourra jouer pratiquement le même rôle qu'un constructeur. Quand utiliser une classe anonyme? La classe possède un corps très court Une seule instance de la classe est nécessaire Le nom de la classe ne facilite pas la compréhension du code Il faut toujours privilégier la lisibilité du code source. EIA-FR / Jacques Bapst PR1_14 13 EIA-FR / Jacques Bapst PR1_14 15 Java / Classes internes Classes anonymes [2] La création d'une classe anonyme fait intervenir une nouvelle syntaxe qui combine la définition et l'instanciation de la classe. Pour la définir plus formellement, il faut distinguer les deux situations possibles. Sous-classe anonyme : new Nom_Classe_Parente( [ Liste_Param ] ) { Corps_Sous_Classe Classe anonyme implémentant une interface : new Nom_Interface() { Corps_Classe Cette nouvelle syntaxe introduit une complication supplémentaire sur le plan de la mise en page (indentation) car la création d'une classe anonyme s'effectue généralement dans le cadre d'une expression (voir exemple). A utiliser avec modération! Java / Classes internes Exemple de classe anonyme //===== Un exemple de classe anonyme pour filtrer des fichiers dans un répertoire ===== public class TestAnonymousClass { // Liste tous les fichiers du répertoire D:\Data possédant l'extension.java public static void main(string[] args) { File f = new File("D:\\Data"); // Le répertoire à énumérer // La méthode list() prend en argument un objet de type FilenameFilter // Une instance de la sous-classe anonyme de FilenameFilter est créée // directement dans l'expression d'invocaton de la méthode list() String[] filelist=f.list(new FilenameFilter() { public boolean accept(file dir, String s) { return s.endswith(".java"); ); // N'oubliez pas la parenthèse et le point-virgule qui achèvent l'appel de la méthode // Affichage de la liste des fichiers trouvés for (int i=0; i<filelist.length; i++) { System.out.println("File name : " + filelist[i]); Noter la mise en page pour l'écriture des classes anonymes (conventions de codage Oracle). EIA-FR / Jacques Bapst PR1_14 14 EIA-FR / Jacques Bapst PR1_14 16

96 Java / Classes internes Remarques sur les classes internes [1] Les différents types de classes internes offrent des mécanismes supplémentaires pour organiser et structurer le code source. En créant une classe interne, on limite leur niveau d'exposition en les encapsulant au sein d'autres classes. Pour les classes membres (statiques ou non), on peut limiter leur accès en utilisant les modificateurs public, protected et private. On peut ainsi retrouver au niveau des classes internes certains bénéfices de l'encapsulation. Si l'on combine plusieurs niveaux d'imbrication (qui créent une hiérarchie de confinement) avec une hiérarchie de classes complexe, on peut très vite arriver à de grandes complications en terme de portée, visibilité et masquage des identificateurs concernés. Les classes internes ne doivent être utilisées que si elles apportent des simplifications dans la conception et favorisent la lisibilité et la maintenance du code. Sinon, elles sont plutôt à éviter. EIA-FR / Jacques Bapst PR1_14 17 Java / Classes internes Remarques sur les classes internes [2] Dans les applications comportant une interface utilisateur graphique (GUI), les classes internes et plus particulièrement les classes anonymes sont fréquemment utilisées pour créer, à la volée, des gestionnaires d'événements (Event Listener). Sur le plan de l'implémentation, les classes internes sont traitées de la même manière que les classes de premier niveau : chacune donne lieu à un fichier.class séparé (c'est également vrai pour les classes anonymes). Suivant les types de classes internes, le nom du fichier résultant de la compilation est composé de manière différente mais il comporte généralement le caractère '$' (on trouvera par exemple les fichiers LinkedStack$Linkable.class ou FilenameFilter$1.class). Lors du déploiement d'une application, il peut être important de connaître ces détails d'implémentation; par contre, pour l'écriture d'une application, cela n'a aucune incidence. EIA-FR / Jacques Bapst PR1_14 18

97 Java / Conventions de codage Pourquoi des conventions de codage? Informatique / Programmation Programmation orientée objet avec Java 15 : Conventions de codage Jacques Bapst [email protected] Le respect de certaines conventions générales facilite grandement la lecture du code source : Reconnaissance plus rapide de la structure du code (on se retrouve en terrain connu) Identification rapide de certaines entités par leur convention d'écriture (constantes, classes, ) Un code source est écrit une fois et généralement lu à de nombreuses reprises (parfois longtemps après son écriture et souvent par des lecteurs différents). Il vaut donc la peine d'investir un peu de temps au moment de son écriture afin de faciliter sa lecture et sa compréhension ultérieure. Certains éditeurs offrent des aides pour la mise en page du code source et le respect de certaines règles de codage. Les conventions proposées par Oracle : EIA-FR / Jacques Bapst PR1_15 3 Java / Conventions de codage Pourquoi des conventions de codage? Les fichiers sources d'un programme sont destinés à deux types de lecteurs : l'humain et la machine (le compilateur notamment). Pour le compilateur : vaut bien "a.b(c)" "myfile.println(currenttime)" Les conventions de codage (Style Guidelines) ont pour but d'améliorer, pour les humains, la lisibilité des fichiers sources en respectant certaines règles qui ne sont pas imposées par le langage (choix des identificateurs, mise en page, ). Il existe des conventions plus ou moins contraignantes. Un certain nombre de conventions générales (proposées par Sun) sont adoptées par la très grande majorité des développeurs Java. D'autres (généralement plus contraignantes) sont imposées dans le cadre de certains projets afin de garantir une certaine homogénéité des codes sources indépendamment de leur auteur (et assurer une stabilité dans le temps). Java / Conventions de codage Mise en page Les commentaires doivent être alignés au niveau d'indentation du code qui suit (pas de commentaires qui brisent la structure du code en débordant dans la marge d'indentation). Ne pas dépasser (env.) 80 caractères par lignes (pour éviter le scrolling horizontal et les problèmes d'impression). Une seule instruction par ligne (sauf exceptions). Déclarer de préférence les variables locales au début des méthodes. Décomposer le code des méthodes trop longues (celles qui ne tiennent pas sur une page imprimée). TOUJOURS bien indenter! Accolade ouvrante placée en fin de ligne Indentation de 2 ou 4 espaces Accolade fermante seule sur la ligne et alignée sur le début de la ligne contenant l'accolade ouvrante qui lui correspond Aligner les instructions lorsque cela a un sens (lisibilité). if (a > b) { nb = 1; else { nb = -1; ok = false; EIA-FR / Jacques Bapst PR1_15 2 EIA-FR / Jacques Bapst PR1_15 4

98 Java / Conventions de codage Commentaires Java / Conventions de codage Choix des identificateurs [1] Pour les commentaires généraux utiliser de préférence la notation "// texte" (même pour les commentaires qui s'étendent sur plusieurs lignes). Utiliser la notation "/* texte */" pour inactiver temporairement une portion de code. Pour les applications (ou librairies) d'une certaine envergure, des commentaires de documentation ("/** texte */") devraient précéder chaque classe et chaque membre public (champs et méthodes) de la classe. Pour les exercices, on pourra se contenter d'un en-tête précédant chaque méthode (au minimum une ligne séparatrice). Inutile d'ajouter des commentaires triviaux : int counter; // Variable compteur i++; // i = i + 1 Type d'identificateur Packages Classes Interfaces Méthodes (procédure) Méthodes (fonctions) Convention de nommage Uniquement des mots en minuscules séparés par des points (niveaux hiérarchiques). Si possible, utilisation d'url inversé. Un ou plusieurs noms (substantifs). Notation Mixed-Case (Camel-Case) avec première lettre en majuscule. Un ou plusieurs nom ou adjectifs. Notation Mixed-Case (Camel-Case) avec première lettre en majuscule. Un verbe (év. avec compléments) Notation Mixed-Case (Camel-Case) avec première lettre en minuscule. Un ou plusieurs noms ou noms qualifiés (éventuellement précédés de get ou is). Notation Mixed-Case (Camel-Case) avec première lettre en minuscule. Exemple com.ibm.javadev ch.eif.project.i02 Raster StringTokenizer Printable ActionListener runprocess() draw() maxwidth() isvisible() EIA-FR / Jacques Bapst PR1_15 5 EIA-FR / Jacques Bapst PR1_15 7 Java / Conventions de codage Choix des identificateurs [1] Java / Conventions de codage Choix des identificateurs [2] D'une manière générale, les identificateurs doivent être autodescriptifs sans toutefois être trop longs (< ~30 caractères). Les variables temporaires peuvent faire exception à cette règle. Par exemple les compteurs de boucle sont fréquemment déclarés avec un seul caractère (traditionnellement i, j, k, m, n pour les entiers). Pour les identificateurs composés de plusieurs mots on adoptera généralement la notation dite Mixed-Case ou Camel-Case où les mots sont écrits en minuscules exceptée la première lettre des mots lors de la transition d'un mot à l'autre (la première lettre du premier mot pouvant être en majuscule ou en minuscule selon les cas). amixedcaseidentifier SomeOther Dans la notation Mixed-Case on n'utilise généralement pas d'autres caractères de séparation. Type d'identificateur Champs Variables locales Paramètres Constantes (static final) Énumérations (enum) Types génériques (< >) Convention de nommage Un ou plusieurs noms ou noms qualifiés. Notation Mixed-Case (Camel-Case) avec première lettre en minuscule. Un ou plusieurs noms ou noms qualifiés. Mots en majuscules séparés par le caractère souligné ('_'). Un ou plusieurs noms ou noms qualifiés. Mots en majuscules séparés par le caractère souligné ('_'). Exemple position maxspeed PI MAX_LENGTH Une seule lettre, en majuscule. <K, V> GREEN ROTATION_MODE EIA-FR / Jacques Bapst PR1_15 6 EIA-FR / Jacques Bapst PR1_15 8