CIE303 - Programmation Orientée Objet en Java

Transcription

1 Module 303 Programmation orientée objet en Java Version 1.0 (Fortement inspiré et traduit de «The Java Tutorial» [1]

2 1. Table des matières Sommaire 1. Table des matières Présentation de Java Situation Caractéristiques Différentes éditions et versions La numérotation des versions La communauté Java Les API, les outils, les frameworks Le concept orienté-objet en Java Les objets Les classes L héritage Les interfaces Les packages Questions Éléments de base Les variables Les noms des variables Types de base (types primitifs) Valeurs littérales Les tableaux Questions Les opérateurs Les expressions, les instructions et les blocs Les instructions de contrôle Les classes et les objets Les classes Les objets Le mot clé «this» Contrôler l accès Le mot clé «static» Les classes internes Les types énumérés Les annotations Liste des mots réservés Les interfaces et l héritage Les interfaces L héritage Surcharger une méthode Polymorphisme Le mot clé final Le mot clé abstract Les nombres et les chaînes de caractères Les nombres [2]

3 9. Les génériques Les exceptions Les collections Architecture Application simple Application client-serveur Le modèle 3-tiers Java et les bases de données JDBC Architecture Les limites de JDBC JPA Java Persistence API Interfaces utilisateurs graphiques Interfaces graphiques avec Swing Le positionnement des composants Les événements Applications Web en Java JSP Java Server Pages JSF Java Server Faces Vaadin Technologies natives [3]

4 2. Présentation de Java Ce chapitre présente les caractéristiques de Java et son environnement Situation Java est actuellement le langage de programmation le plus utilisé dans le monde. Il y aurait plus de 9 millions de développeurs Java. Et l environnement d exécution Java est téléchargé plus d 1 milliard de fois chaque année. Sa richesse et sa communauté en font en langage utilisé pour le développement de toute sorte d applications, des applications d entreprise jusqu aux applications mobiles. Initialement développé par Sun, la première version de la JVM date de Sun a été racheté par Oracle en janvier La version actuelle est Java SE 7, sorti en juillet Interprété 2.2. Caractéristiques Write once, run anywhere (Écrit une fois, exécuté partout) : Java est un langage interprété. Le code Java est compilé en bytecode, puis exécuté par un interpréteur : la JVM (Java Virtual Machine). Indépendant de la plate-forme d exécution Il n'y a pas de compilation spécifique à chaque plate forme. Le code reste indépendant de la machine sur laquelle il s'exécute. Il est possible d'exécuter des programmes Java sur tous les environnements qui possèdent une Java Virtual Machine [4]

5 Cette indépendance fait que Java peut être un petit peu plus lent que du code natif, mais, avec les avancées du compilateur et de la machine virtuelle, les performances s approchent du code natif, en conservant la portabilité. Orienté-objet Comme la plupart des langages de programmation récents, Java est orienté-objet. Toutefois, contrairement aux langages purement orientés objet comme SmallTalk, où tout est objet, Java définit des types primitifs qui ne sont pas des objets. Simple Les auteurs de Java ont volontairement abandonné les éléments mal compris ou mal exploités des autres langages de programmation, comme les pointeurs ou l allocation de la mémoire. Le langage est plus simple et il y a moins de risque de bug dû à une mauvaise utilisation du langage. Fortement typé Java est fortement typé : toute variable a un type et il n y a pas de conversion automatique, le développeur est donc en quelque sorte contraint de mieux maîtriser ses variables. Gestion de la mémoire automatique L'allocation de la mémoire pour un objet est automatique lors sa création et Java récupère automatiquement la mémoire inutilisée grâce au garbage collector qui restitue les zones de mémoire laissées libres suite à la destruction des objets. Multi-tâche Il permet l'utilisation de threads qui sont des unités d'exécutions isolées. La JVM, elle même, utilise plusieurs threads [5]

6 2.3. Différentes éditions et versions Ces différents environnements peuvent être téléchargés librement. JRE - Java Runtime Environment Le JRE contient l environnement d exécution pour Java, en particulier la JVM. Il doit être installé sur les machines où Java sera exécuté. JDK - Java Development Kit Le JDK inclus un JRE. Il s agit d un ensemble d outils, à commencer par le compilateur javac, et d API pour permettre le développement de programme Java. J2SE / Java SE - Java Standard Edition Environnement d exécution et ensemble d API pour le développement d application standard, comprendre d application desktop. J2EE / Java EE - Java Enterprise Edition Environnement d exécution et ensemble d API, reposant sur Java SE, pour le développement d application d entreprise. J2ME / Java ME - Java Micro Edition Environnement d exécution et ensemble d API pour le développement d application sur des appareils mobiles ou des systèmes embarqués dont la capacité mémoire ne permet pas l utilisation de Java SE La numérotation des versions Le principe de numérotation des versions a été modifié plusieurs fois, donc il est parfois difficile de s y retrouver. Nom Version Année Modifications L API comporte seulement 8 packages Introduction de nombreuses fonctionnalités, JDBC pour l accès aux bases de données, le support de l internationalisation, etc. J2SE Introduction des différentes éditions J2SE, J2EE, J2ME. - J2SE : JDBC2.0, Swing - J2EE : EJB, Servlets et JSP J2SE Amélioration des performances 1.3 J2SE JDBC3.0, Jaxp pour le XML, Jaas pour la sécurité, Java Web Start, Assertions J2SE Grosse évolution du langage Introduction des génériques, des types énumérés, des annotations, etc. Nombreuses nouvelles API et en particulier pour le monitoring et le management de la JVM. Java SE Amélioration du support XML, JDBC4.0, webservices, scripting, etc [6]

7 Java SE Première version depuis le rachat par Oracle. Amélioration du langage : try with resource, multi catch exception. L API Java a désormais 209 packages 2.5. La communauté Java La communauté Java est formée de tous les acteurs du monde Java. L éditeur de Java : d abord Sun, désormais Oracle. Le JCP - Java Community Process : c'est le processus de traitement des évolutions de Java. Chaque évolution est traitée dans une JSR (Java Specification Request) par un groupe de travail constitué de différents acteurs du monde Java Acteurs commerciaux : tous les grands acteurs commerciaux de l informatique mondiale, à l exception notable de Microsoft. Les communautés libres : qui produisent un très grand nombre d API et d outils pour Java. Les JUG - Java User Groups : les communautés locales d utilisateurs de Java. A Lausanne, le JUGL se réunit une fois par mois : jugl.myxwiki.org/ 2.6. Les API, les outils, les frameworks Il existe de très nombreux API/outils/framework autour de Java. La communauté est énorme et évolue très rapidement. Si bien qu il est impossible, même pour un développeur qui travaille tous les jours avec Java de tous les connaître. Certaines API sont standards, d autres ne sont pas standards mais deviennent tout de même des standards de facto tellement elles sont courantes. L API standard de Java : ce sont les packages fournis par défaut avec Java. Cela comprend toutes les API de base du langage, comme par exemple les collections. Nous passerons en revue les principales plus tard dans le cours. L API avancées de Java : JDBC, JPA, EJB, Servlets, JAXP, JAXB, etc. Les outils du JDK : Jar, Javadoc, etc. Les API et framework de la communauté : Hibernate, Spring, GWT, etc. Les outils de la communauté : JBoss, Apache Tomcat, Apache Maven, etc [7]

8 3. Le concept orienté-objet en Java Si vous n avez jamais utilisé de langage de programmation orienté-objet, vous avez besoin de comprendre le concept de base avant de commencer à écrire vos premières lignes de code Les objets Les objets sont des entités logicielles regroupant un état et un comportement. Les objets sont utilisés pour modéliser des objets du monde réel, cela permet notamment l encapsulation des données. Regardez autour de vous, tout est un objet : votre chien, votre bureau, votre vélo. Ils ont tous un état et un comportement. Le chien a un état (son nom, sa couleur, sa race, etc) et un comportement (aboyer, va chercher, remuer la queue). Le vélo a un état (la vitesse courante, la cadence des pédales) et un comportement (changer la vitesse, freiner). En attribuant un état à l objet et des méthodes (comportement) qui changent l état de cet objet, l objet garde le contrôle de la manière dont le monde extérieur peut l utiliser. Par exemple, si le vélo a 6 vitesses, alors la méthode pour changer de vitesse rejettera les valeurs qui ne sont pas entre 1 et 6. Construire du code en modélisant des objets a des avantages : - Modularité : le code qui décrit un objet peut être écrit et maintenu indépendamment du code des autres objets. Une fois créé un objet peut facilement être transmis dans le système [8]

9 - Cacher le détail d implémentation : en interagissant uniquement avec les méthodes, les détails de l implémentation de l objet sont cachés, ne sont pas accessibles à l extérieur de l objet. - Réutilisation du code : si un objet a déjà été cérit par un autre programmeur, vous pouvez probablement le réutiliser dans votre programme. - Pluggable : un objet peut facilement être «pluggé» dans un système, puis remplacé par un autre objet au besoin Les classes Dans le monde réel, vous trouverez souvent plusieurs objets individuels du même type. Il peut y avoir des milliers de vélo identiques, de la même marque et du même modèle. En termes orientés-objet, on dirait alors que votre vélo est une instance de la classe d objet vélo. Une classe est donc le canvas qui décrit l objet, ou les plans pour construire le vélo. La classe Bicycle publicclassbicycle{ intcadence=0; intspeed=0; intgear=1; voidchangecadence(intnewvalue){ cadence=newvalue; voidchangegear(intnewvalue){ gear=newvalue; voidspeedup(intincrement){ speed=speed+increment; voidapplybrakes(intdecrement){ speed=speedbdecrement; voidprintstates(){ System.out.println( "cadence:"+cadence+ "speed:"+speed+ "gear:"+gear); Ne vous attardez pas trop sur la syntaxe pour l instant. La classe ci-dessus reprend la description de la classe d objet vélo discutée jusqu ici. Les attributs «cadence», «speed» et «gear» représentent l état de l objet, et les méthodes «changecadence», «changegear», «speedup», «applybrekes» et «printstates» représentent le comportement de l objet [9]

10 Nb : dans le langage courant, on entend souvent parler des «champs d un objet» (cela vient de l anglais «fields») ou des «propriétés d un objet»ou encore «des membres d une classe» - ce sont tous des synonymes pour parler des «attributs». Vous remarquerez que la classe ne comporte pas de méthode «main». Elle n est donc pas exécutable en tant que telle. C est parce que dans une application Java complète, ce sont d autres classes que ont la responsabilité de créer un objet, de l utiliser et d exécuter ses méthodes. La classe BicycleDemo instancie deux objets Bicycle et exécute leurs méthodes. BicycleDemo Utilisation de la classe Bicycle staticclassbicycledemo{ publicstaticvoidmain(string[]args){ //Createtwodifferent //Bicycleobjects Bicyclebike1=newBicycle(); Bicyclebike2=newBicycle(); //Invokemethodson //thoseobjects bike1.changecadence(50); bike1.speedup(10); bike1.changegear(2); bike1.printstates(); bike2.changecadence(50); bike2.speedup(10); bike2.changegear(2); bike2.changecadence(40); bike2.speedup(10); bike2.changegear(3); bike2.printstates(); L exécution de se programme doit afficher : BicycleDemo - ouptut cadence:503speed:103gear:23 cadence:403speed:203gear: L héritage Des objets différents ont souvent certaines propriétés communes. Un moutain-bike, un vélo de route ou un tandem sont tous des vélos et partagent les mêmes caractéristiques «speed», «cadence» et «gear». Mais chacun définit également des caractéristiques supplémentaires qui leur sont propres : le tandem a deux sièges et deux guidons, le moutain-bike a peut-être un plateau de plus et le vélo de route un guidon différent. En orienté-objet, les classes peuvent hériter leur état et leur comportement d une classe parente. Attention en Java, une classe ne peut hériter que d un seul parent. Contrairement à d autres langages, l héritage multiple n est pas supporté [10]

11 La syntaxe pour hériter d une classe parente est la suivante : Héritage classmountainbikeextendsbicycle{ //newfieldsandmethodsdefining //amountainbikewouldgohere Cela permet à la classe «MoutainBike» d hériter tous les attributs et toutes les méthodes de la classe parente «Bicycle» Les interfaces On a vu que les objets définissent leurs interactions avec le monde extérieur avec les méthodes qu ils exposent. Ces méthodes sont l interface de l objet. Par exemple, les boutons «on» et «off» sur la télévision sont l interface de la télévision entre le monde extérieur et l électronique interne. En Java, une interface est donc un ensemble de déclaration de méthodes, sans corps. Interface Bicycle interfacebicycle{ //wheelrevolutionsperminute voidchangecadence(intnewvalue); voidchangegear(intnewvalue); voidspeedup(intincrement); voidapplybrakes(intdecrement); [11]

12 Pour implémenter une interface, on utilise la syntaxe suivante. Implémentation d une interface 3 classacmebicycleimplementsbicycle{ //remainderofthisclass //implementedasbefore Les interfaces définissent un contrat entre la classe et le monde extérieur. Ce contrat est vérifié par le compilateur : si une classe implémente une interface, elle est obligée de définir l implémentation de chaque méthode, c'est-à-dire qu elle est obligée de définir le code source de chaque méthode Les packages Un «package» est un espace nommé pour organiser un ensemble de classes et d interfaces. Conceptuellement, les packages sont similaires aux répertoires sur votre disque dur. Vous organiser des répertoires différents pour vos images, vos documents, vos pages HTML, etc. De manière similaire en Java, vous organiserez vos classes et interfaces qui sont liées entre elles dans des mêmes packages. Nb : dans la pratique le terme anglais «package» est plus utilisé que le terme français «paquetage». Java fourni de nombreuses librairies de classes, organisées en packages, que vous pouvez utiliser dans vos applications. Cette librairie est l API Java (Application Programming Interface). Vous y trouverez des classes permettant de réaliser les tâches les plus courantes, par exemple : String la classe pour représenter une chaîne de caractères, File la classe représentant un fichier, List la classe représentant une structure de donnée sous forme de liste, etc. Quelques remarques sur l utilisation des packages : - Le nom d un package doit commencer par le nom de domaine inversé de l entreprise : si vous travaillez pour le canton de vaud nom de domaine «vd.ch» - vos packages commenceront par «ch.vd». Si vous voyez un extrait de code utilisant une classe «org.apache.commons.lang.stringutils», vous pouvez en déduire que vous trouvererez des informations ou de la documentation en vous adressant au projet «commons-lang» de la fondation apache «apache.org». - Il n est pas nécessaire d importer les classes qui se trouvent dans le même package. De même, il n est pas nécessaire d importer les classes du package standard «java.lang». - L API de Java est l ensemble des packages commençant par «java» ou «javax». La documentation de l API de Java est disponible ici : Questions - Un objet est défini par un et un. - L état d un objet est conservé dans ses. - Le comportement d un objet est exposé au travers de ses [12]

13 - Cacher les données internes et y accéder uniquement au travers des méthodes exposées publiquement s appelle des données. - Le canvas d un objet est définit par une. - Le comportement commun peut être défini dans une et hérité dans une en utilisant le mot clé. - Une ensemble de méthodes sans implémentation est appelé une. - Un espace nommé pour organiser les classes et les interfaces est appelé un. - API signifie [13]

14 4. Éléments de base Ce chapitre présente la syntaxe de base du langage Java, ainsi que les éléments et types de base Les variables Comme vous l'avez appris dans le chapitre précédent, un objet stocke son état dans les attributs. Attributs intcadence=0; intspeed=0; intgear=1; Mais quels sont les règles de syntaxes, les conventions de nommage, à part «int» quels sont les types de données disponibles? Nous allons explorer les réponses à ces questions dans ce chapitre, mais avant cela, il ya quelques différences techniques, dont vous devez d'abord prendre conscience. Dans le langage de programmation Java, les termes «attributs» et «variable» sont utilisés, ce qui est une source fréquente de confusion chez les nouveaux développeurs, puisque les deux semblent souvent se référer à la même chose. Le langage de programmation Java définit les types de variables suivants : - Les variables d'instance (attributs non statiques) Les objets stockent leurs états individuels dans des attributs non statiques, déclarés sans le mot-clé static. Des attributs non statiques sont aussi appelés variables d'instance, car leurs valeurs sont uniques pour chaque instance d'une classe, donc pour chaque objet. La vitesse d un vélo n est pas la même que la vitesse d un autre. - Les variables de classe (champs statiques) Une variable de classe est un attribut déclaré avec le modificateur static, ce qui indique au compilateur qu'il y a exactement une seule copie de cette variable, quel que soit le nombre de fois que la classe a été instanciée. Un attribut pourrait définir le nombre de vitesses pour un type particulier de vélo comme static, dans ce cas le même nombre de vitesses s'applique à toutes les instances. Variables de classe publicclassbicycle{ intcadence=0; intspeed=0; staticintgear=6; En outre, le mot-clé final peut être ajouté pour indiquer que le nombre de rapports ne changera jamais. - Les variables locales De la même façon qu un objet stocke son état dans les attributs, une méthode stocke son état temporaire dans des variables locales. La syntaxe pour déclarer une variable locale est similaire celle pour déclarer un champ (par exemple, int count = 0 ;). Il n'ya pas de mot-clé spécial désignant une variable locale; c est simplement l'emplacement dans lequel la variable est déclarée qui fait que c est une variable locale - ce qui est entre les [14]

15 accolades d'ouverture et de fermeture d'une méthode. En tant que tels, les variables locales ne sont visibles que les méthodes dans lesquelles ils sont déclarés, ils ne sont pas accessibles à partir du reste de la classe. - Les paramètres Les paramètres des méthodes. La chose importante à retenir est que les paramètres sont toujours classés comme des «variables» et non «attributs». Ce paramètre s'applique à d'autres acceptant les constructions ainsi (comme les constructeurs et les gestionnaires d'exceptions), que vous découvrirez un peu plus tard dans ce document Les noms des variables Chaque langage de programmation possède son propre ensemble de règles et de conventions pour les types de noms que vous êtes autorisé à utiliser, et le langage de programmation Java n'est pas différent. Les règles et les conventions pour nommer vos variables peuvent être résumées comme suit: Les règles (ce que le compilateur permet) : - Les noms de variables sont sensibles à la casse. - Le nom d'une variable peut être n'importe quel identifiant légal - une séquence de longueur illimitée de lettres et de chiffres Unicode, en commençant par une lettre, le signe dollar "$", ou le caractère de soulignement «_». On peut donc donner n importe quel nom à une variable pour autant que l on respecte les règles de syntaxe précédente et à l exception des mots réservés du langage Java (voir chapitre suivant). Les conventions (ce qui est fait dans la pratique) : - La convention, cependant, est de toujours commencer vos noms de variables avec une lettre, et non "$" ou "_". En outre, le caractère de signe dollar, par convention, n'est jamais utilisée du tout. - Les caractères suivants peuvent être des lettres, des chiffres, des signes de dollar, ou des caractères de soulignement. Les conventions (et le bon sens) s'appliquent au présent article ainsi. Lors du choix d'un nom pour vos variables, utilisez des mots complets plutôt que des abréviations cryptiques. Cela rendra votre code plus facile à lire et à comprendre. Dans de nombreux cas, il sera également possible de rendre votre code auto-documenté. - Si le nom que vous choisissez est constitué d'un seul mot, épeler ce mot en lettres minuscules. Si il se compose de plus d'un mot, mettre en majuscule la première lettre de chaque mot suivant. C est le «camel case». - Si votre variable stocke une valeur constante, la convention est différente. Capitaliser chaque lettre et séparer les mots suivants avec le caractère de soulignement. Par convention, le caractère de soulignement n'est jamais utilisé ailleurs. Les identificateurs packagech.gri.cours.ch4; publicclassidentifierrules{ [15]

16 //Laconventionpourlesconstantesestdifférentes private3static3final3int3nb_jour_semaine3=37; //'_ et'$'sontdéconseillés privatedouble_tauxinteret; privatestring$nomclient; privateint_abstract; publicvoididentificateursnonparlants(){ StringuneString="Michel"; inti=42; publicvoididentificateursparlants(){ Stringprenom="Michel"; intage=42; Types de base (types primitifs) Les types élémentaires ont une taille identique quelque soit la plate-forme d'exécution : c'est un des éléments qui permet à Java d'être indépendant de la plate-forme sur laquelle le code s'exécute. Type Désignation Longueur Valeurs Commentaires boolean Valeur logique booléenne 1 bit false true Pas de conversion possible vers un autre type. byte Octet signé 8 bits (1byte) -128 à +127 short Entier court signé 16 bits à char Caractère Unicode 16 bits \u0000 à \uffff Entouré de simples cotes dans le code Java. int Entier signé 32 bits à Type par défaut pour les nombres entiers. float Virgule flottante simple précision (IEEE754) 32 bits 1.401e-045 à e+038 double virgule flottante 64 bits e-308 à Type par défaut pour les nombres [16]

17 double précision (IEEE754) e+308 réels. long Entier long signé 64 bits à String3 Chaîne de caractères Objet Le type String n est pas un type primitif, mais un objet Mais, il est particulier car on peut lui affecter une valeur littérale, sans avoir à créer une nouvelle instance de l objet avec new. Les types primitifs ont tous une valeur par défaut de 0 (ou false pour le type booléen), lorsqu ils ne sont pas initialisés Valeurs littérales Une valeur littérale («literals» en anglais) est la représentation en code source Java d une valeur fixe. Valeurs littérales booleanresult=true; charcapitalc='c'; byteb=100; shorts=10000; inti=100000; Stringtxt="texte"; //Thenumber26,indecimal intdecval=26; //Thenumber26,inhexadecimal inthexval=0x1a; //Thenumber26,inbinary intbinval=0b11010; doubled1=123.4; //samevalueasd1,butinscientificnotation doubled2=1.234e2; floatf1=123.4f; //Utiliserle _ danslesexpressionslittéralesnumériques longcreditcardnumber=1234_5678_9012_3456l; longsocialsecuritynumber=999_99_9999l; floatpi=3.14_15f; longhexbytes=0xff_ec_de_5e; [17]

18 longhexwords=0xcafe_babe; longmaxlong=0x7fff_ffff_ffff_ffffl; bytenybbles=0b0010_0101; longbytes=0b _ _ _ ; charcmajusculecirconflexe='\u0108'; StringsiSenior="S\u00EDSe\u00F1or";//SíSeñorinSpanish charbackspace='\b'; chartab='\t'; charlinefeed='\n'; StringcarriageReturn="\r"; StringdoubleQuote="\""; StringsingleQuote="\'"; Stringbackslash="\\"; StringtexteNull=null; ClassstringClass=String.class; Une expression littérale de type char ou String peut utiliser n importe quel caractère UNICODE (UTF-16). Si votre éditeur le permet, vous pouvez utiliser n importe quel caractère directement dans votre code Java. Sinon, il faut utiliser un caractère d échappement «\» pour écrire le caractère. On utilise toujours des simples cotes (single quotes) pour des expressions littérales de type char. Et toujours des doubles cotes (double quotes) pour les expressions de type String. Java supporte également des séquences d échappement pour certains caractères spécaux à utiliser dans les char et les String. La valeur null est également une expression littérale. Le mot clé class est aussi utilisé pour écrire un class litteral qui est une expression permettant d obtenir l objet (de type Class) qui représente le type Les tableaux Un tableau (array, en anglais) est un espace permettant de stocker un nombre déterminé de valeur du même type. La taille (la longueur) du tableau est fixée lors de sa création et ne peut plus être modifiée. Chaque valeur du tableau est appelée un élément. Les éléments sont numérotés à partir de 0, donc le neuvième élément se trouve à la position 8. Les tableaux [18]

19 publicclassarraydemo{ publicstaticvoidmain(string[]args){ //declaresanarrayofintegers int[]anarray; //allocatesmemoryfor10integers anarray=newint[10]; //initializefirstelement anarray[0]=100; //initializesecondelement anarray[1]=200; //etc. anarray[2]=300; anarray[3]=400; anarray[4]=500; anarray[5]=600; anarray[6]=700; anarray[7]=800; anarray[8]=900; anarray[9]=1000; System.out.println("Elementatindex0:"+anArray[0]); System.out.println("Elementatindex1:"+anArray[1]); System.out.println("Elementatindex2:"+anArray[2]); System.out.println("Elementatindex3:"+anArray[3]); System.out.println("Elementatindex4:"+anArray[4]); System.out.println("Elementatindex5:"+anArray[5]); System.out.println("Elementatindex6:"+anArray[6]); System.out.println("Elementatindex7:"+anArray[7]); System.out.println("Elementatindex8:"+anArray[8]); System.out.println("Elementatindex9:"+anArray[9]); Element3at3index30:31003 Element3at3index31:32003 Element3at3index32:33003 Element3at3index33:34003 Element3at3index34:35003 Element3at3index35:36003 Element3at3index36:37003 Element3at3index37:38003 Element3at3index38:39003 Element3at3index39: Dans la pratique, les tableaux sont généralement manipulés à l aide d instructions de contrôle, telle que des boucles, plutôt que d écrire une ligne de code pour chaque élément comme ci-dessus. Un tableau peut contenir des éléments de n importe quel type (mais tous les éléments doivent être du même type), cela peut être un type primitif ou un objet. Déclaration de tableaux byte[]anarrayofbytes; short[]anarrayofshorts; long[]anarrayoflongs; float[]anarrayoffloats; double[]anarrayofdoubles; boolean[]anarrayofbooleans; [19]

20 char[]anarrayofchars; String[]anArrayOfStrings; Object[]anArrayOfObjects; //thisformisdiscouraged floatanarrayoffloats[]; Pour créer un tableau, on utilise soit l opérateur new, soit la syntaxe abrégée entre {, dans ce cas la longueur du tableau est déterminée par le nombre d éléments présents dans la déclaration. Création de tableaux //Créationavecnew int[]anarray=newint[10]; //Créationabbrégée int[]anarray={ 100,200,300, 400,500,600, 700,800,900,1000 ; Les tableaux peuvent avoir plusieurs dimensions. Tableaux multi-dimensionnels classmultidimarraydemo{ publicstaticvoidmain(string[]args){ String[][]names={{"Mr.","Mrs.","Ms.", {"Smith","Jones"; //Mr.Smith System.out.println(names[0][0]+names[1][0]); //Ms.Jones System.out.println(names[0][2]+names[1][1]); Mr.Smith Ms.Jones Pour connaître la longueur d un tableau, vous pouvez utiliser la propriété length. Longueur du tableau System.out.println(anArray.length); Questions - Le terme «variable d instance» est un autre nom pour. - Le terme «variable de classe» est un autre terme pour. - Une variable locale stocke un état temporaire : elle est déclarée dans une. - Une variable déclarée entre les parenthèses de la signature d une méthode est un. - Quels sont les 8 types primitifs de Java?. - Les chaînes de caractères sont représentées par quelle classe? :. - Un est un espace permettant de stocker un nombre défini de valeurs du même type [20]

21 4.2. Les opérateurs Maintenant que vous avez appris comment déclarer et initialiser des variables, vous voulez probablement savoir comment faire quelque chose avec elles. Les opérateurs du langage de programmation Java est un bon endroit pour commencer. Les opérateurs sont des symboles spéciaux qui effectuent des opérations spécifiques sur un, deux ou trois opérandes, puis renvoient un résultat. Les opérateurs ont un ordre de priorité. Les opérateurs figurant dans le tableau ci-dessous sont énumérés de la plus haute priorité à la plus basse. Les opérateurs sur une même ligne ont la même priorité. Lorsque les opérateurs de même priorité apparaissent dans la même expression, ils sont évalués de gauche à droite. Opérateurs Opérateur postfixé expr++ expr-- Opérateur unaire ++expr --expr +expr -expr ~ Multiplications, divisons * / % Aditions + - Décalage << >> >>> Opérateurs relationnels < > <= >= instanceof Egalité == = ET binaire & OU excusif binaire ^ OU binaire ET logique && OU logique Opérateur ternaire? : Affectation = += -= *= /= %= &= ^= = <<= >>= >>>= Certains de ces opérateurs sont utilisés très fréquemment, certains autres peuvent être tout de suite oubliés, car ils ne sont que très rarement utilisés. Ceux qu il faut connaître sont détaillés dans ce qui suit. L opérateur d affectation «=» permet d assigner une valeur à une variable. Il permet également d affecter une référence à un objet à une variable. Opérateur d affectation «=» intcadence=0; intspeed=0; intgear=0; Bicyclebike1=newBicycle(); Bicyclebike2=newBicycle(); Les opérateurs arithmétiques permettent d effectuer les opérations arithmétiques suivantes. +3 Addition T3 Soustraction *3 Multiplication /3 Division %3 Reste de la division Opérateur arithmétiques classarithmeticdemo{ publicstaticvoidmain(string[]args){ [21]

22 //resultisnow3 intresult=1+2; System.out.println(result); //resultisnow2 result=resultb1; System.out.println(result); //resultisnow4 result=result*2; System.out.println(result); //resultisnow2 result=result/2; System.out.println(result); //resultisnow10 result=result+8; //resultisnow3 result=result%7; System.out.println(result); L opérateur d addition «+» peut aussi être utilisé pour concaténer des chaines de caractères. Les opérateurs arithmétiques peuvent être combinés avec l opérateur d affectation dans une syntaxe abrégée. Cette pratique est peu répandue. Opérateur arithmétiques (remarques) StringfirstString="Voici"; StringsecondString="unechaîneconcaténée"; StringthirdString=firstString+secondString; System.out.println(thirdString); intx=0; x+=1;//équivalentdex=x+1; //xvaut1 Les opérateurs unaires ont besoin d un seul opérande. Ils permettent d incrémenter ou de décrémenter une variable, ou d inverser la valeur d un booléen ou d un nombre. +3 Indique une valeur positive. T3 Inversion ++3 Incrément TT3 Décrément 3 Inversion booléenne Les opérateurs d incrément ou de décrément peuvent être appliqués avant ou après l opérande. Si on place l opérateur d incrément avant l opérande, alors la valeur de la variable est d abord incrémentée, puis évaluée. Si on place l opérateur après l opérande, alors la variable est d abord évaluée, avant que sa valeur soit incrémentée [22]

23 Opérateurs unaires //resultisnow1 intresult=+1; //resultisnow0 resultbb; //resultisnow1 result++; //resultisnowb1 result=bresult; booleansuccess=false; //false System.out.println(success); //true System.out.println(success); inti=3; i++; //prints4 System.out.println(i); ++i; //prints5 System.out.println(i); //prints6 System.out.println(++i); //prints6 System.out.println(i++); //prints7 System.out.println(i); Les opérateurs d égalité et les opérateurs relationnels sont les suivants : ==3 Egal à =3 Différent de >3 Plus grand que >=3 Plus grand ou égal à <3 Plus petit que <=3 Plus petit ou égal à Opérateurs d égalité et opérateurs relationnels intvalue1=1; intvalue2=2; if(value1==value2) System.out.println("value1==value2"); if(value1=value2) System.out.println("value1=value2"); if(value1>value2) System.out.println("value1>value2"); if(value1<value2) System.out.println("value1<value2"); if(value1<=value2) System.out.println("value1<=value2"); Les opérateurs conditionnels «&&» et permettent d effectuer des opérations conditionnelles sur deux expressions booléennes. Ces opérations n évaluent pas la seconde expression si ce n est pas nécessaire. &&3 ET conditionnel [23]

24 3 OU conditionnel Opérateurs conditionnels intvalue1=1; intvalue2=2; if((value1==1)&&(value2==2)) System.out.println("value1is1ANDvalue2is2"); if((value1==1) (value2==1)) System.out.println("value1is1ORvalue2is1"); Un autre opérateur conditionnel est l opérateur ternaire «? :» qui peut être compris comme une version abrégée du «if then else». Opérateur ternaire intvalue1=1; intvalue2=2; intresult; booleansomecondition=true; result=somecondition?value1:value2; System.out.println(result); L opérateur de comparaison de type «instanceof». instanceof publicstaticvoidmain(string[]args){ Parentobj1=newParent(); Parentobj2=newChild(); System.out.println("obj1instanceofParent:" +(obj1instanceofparent)); System.out.println("obj1instanceofChild:" +(obj1instanceofchild)); System.out.println("obj1instanceofMyInterface:" +(obj1instanceofmyinterface)); System.out.println("obj2instanceofParent:" +(obj2instanceofparent)); System.out.println("obj2instanceofChild:" +(obj2instanceofchild)); System.out.println("obj2instanceofMyInterface:" +(obj2instanceofmyinterface)); classparent{ classchildextendsparentimplementsmyinterface{ interfacemyinterface{ obj1instanceofparent:true obj1instanceofchild:false obj1instanceofmyinterface:false obj2instanceofparent:true obj2instanceofchild:true obj2instanceofmyinterface:true [24]

25 Les opérateurs de décalage et les opérateurs binaires ne seront pas traités, car ils sont peu utilisés. &3 ET binaire 3 OU binaire ^3 OU exclusif binaire ~3 Complément binaire (change les 0 en 1 et inversément) <<3 Décalage de bits à gauche >>3 Décalage de bits à droite >>>3 Décalage de bits à droite sans tenir compte du signe 4.3. Les expressions, les instructions et les blocs Les expressions sont constituées de variables, d opérateurs et d invocation de méthodes. Une expression peut être évaluée en une valeur. Exemples d expressions 1*2*3 x+y/100 System.out.println("value1==value2") Les instructions sont l équivalent des phrases dans la langue naturelle. C est en gros toutes les constructions qui se terminent par un «;». Exemple d instructions //assignmentstatement avalue= ; //incrementstatement avalue++; //methodinvocationstatement System.out.println("HelloWorld"); //objectcreationstatement BicyclemyBike=newBicycle(); Les blocs sont des groupes d instructions entre accolades «{». Exemple de blocs d instructions 3 classblockdemo{ publicstaticvoidmain(string[]args){ booleancondition=true; if(condition){//beginblock1 System.out.println("Conditionistrue."); //endblockone else{//beginblock2 System.out.println("Conditionisfalse."); //endblock Les instructions de contrôle Les instructions dans votre code source sont généralement exécutées séquentiellement de haut en bas. Les instructions de contrôles vous permettent d effectuer des conditions, des embranchements, des boucles afin que votre programme exécute conditionnellement certains blocs de code [25]

26 L instruction «if-then» permet d exécuter un bloc d instructions uniquement si une condition est satisfaite. Par exemple, la classe Bicycle pourrait vouloir freiner uniquement si le vélo est en mouvement. If-then voidapplybrakes(){ //the"if"clause:bicyclemustbemoving if(ismoving){ //the"then"clause:decreasecurrentspeed currentspeedbb; Si le bloc d instruction à exécuter contient une seule instruction, il est possible de ne pas mettre les accolades. Ce que je vous le déconseille, car c est un risque d erreur important, et cela rend le code moins lisible. If-then voidapplybrakes(){ //saveasabovebutwithoutbraces if(ismoving) currentspeedbb; L instruction «if-then-else» permet d ajouter un bloc d instructions à exécuter lorsque la condition n est pas satisfaite. If-then-else voidapplybrakes(){ if(ismoving){ currentspeedbb; else{ System.err.println("Thebicyclehas"+"alreadystopped"); Il est possible de chaîner les «if-then-else». If-then-else inttestscore=76; chargrade; if(testscore>=90){ grade='a'; elseif(testscore>=80){ grade='b'; elseif(testscore>=70){ grade='c'; elseif(testscore>=60){ grade='d'; else{ grade='f'; System.out.println("Grade="+grade); //équivalentà if(testscore>=90){ grade='a'; else{ [26]

27 if(testscore>=80){ grade='b'; else{ if(testscore>=70){ grade='c'; else{ if(testscore>=60){ grade='d'; else{ grade='f'; L instruction «switch» permet également de définir différents chemins d exécution. Attention cette instruction ne fonctionne qu avec les types byte, short, char, int. Depuis J2SE 5, également avec les types énumérés (voir plus loin) et depuis Java SE 7 avec les String. Switch publicclassswitchdemo{ publicstaticvoidmain(string[]args){ intmonth=8; StringmonthString; switch(month){ case1: monthstring="january"; break; case2: monthstring="february"; break; case3: monthstring="march"; break; case4: monthstring="april"; break; case5: monthstring="may"; break; case6: monthstring="june"; break; case7: monthstring="july"; break; case8: monthstring="august"; break; case9: monthstring="september"; break; case10: monthstring="october"; break; case11: monthstring="november"; [27]

28 break; case12: monthstring="december"; break; default: monthstring="invalidmonth"; break; System.out.println(monthString); L instruction «break ;» a toute son importance, car si elle n est pas présente l exécution se poursuit séquentiellement avec les «case» suivants. classswitchdemofallthrough{ publicstaticvoidmain(stringargs[]){ java.util.arraylist<string>futuremonths= newjava.util.arraylist<string>(); 3 3 intmonth=8; switch(month){ case1: futuremonths.add("january"); case2: futuremonths.add("february"); case3: futuremonths.add("march"); case4: futuremonths.add("april"); case5: futuremonths.add("may"); case6: futuremonths.add("june"); case7: futuremonths.add("july"); case8: futuremonths.add("august"); case9: futuremonths.add("september"); case10: futuremonths.add("october"); case11: futuremonths.add("november"); case12: futuremonths.add("december"); break; default: break; if(futuremonths.isempty()){ System.out.println("Invalidmonthnumber"); else{ for(stringmonthname:futuremonths){ [28]

29 System.out.println(monthName); Techniquement, le dernier «break» ne serait pas nécessaire, car de toute façon l exécution se poursuit en quittant le bloc «switch». Il est aussi possible de grouper les «case». classswitchdemo2{ publicstaticvoidmain(string[]args){ intmonth=2; intyear=2000; intnumdays=0; switch(month){ case1: case3: case5: case7: case8: case10: case12: numdays=31; break; case4: case6: case9: case11: numdays=30; break; case2: if(((year%4==0)&&(year%100==0)) (year%400==0)) numdays=29; else numdays=28; break; default: System.out.println("Invalidmonth."); break; System.out.println("NumberofDays="+numDays); L instruction «while» permet de d exécuter continuellement un bloc de code tant qu une expression est satisfaite. L instruction «do..while» également, sauf que l expression est évaluée après le bloc de code à exécuter, de sorte que le bloc de code est exécuté au moins une fois. while et do..while //countfrom1to10 intcount=1; [29]

30 while(count<11){ System.out.println("Countis:"+count); count++; //ininiteloop while(true){ //yourcodegoeshere //do...while do{ //yourcodegoeshere while(true); L instruction «for» permet d itérer sur un intervalle de valeur. La forme générale est la suivante : For for (initialization; termination; increment) { statement(s) L initialisation est exécutée une fois au démarrage de la boucle. Lorsque que l expression de terminaison est évaluée à «false» alors la boucle se termine. L expression d incrément (ou décrément) est exécutée après chaque itération. For for(inti=1;i<11;i++){ System.out.println("Countis:"+i); Notez que l instruction «for» comporte une déclaration de variable (la variable «i» en l occurrence). Cette variable est locale par rapport au bloc d instruction du for. Les trois expressions d un «for» sont optionnelles. On peut donc créer une boucle infinie avec un «for». For //infiniteloop for(;;){ //yourcodegoeshere L instruction «for» peut aussi prendre une autre forme spécialement conçue pour itérer au travers des éléments d un tableau ou d une collection (voir plus loin). For..each int[]numbers={1,2,3,4,5,6,7,8,9,10; for(intitem:numbers){ System.out.println("Countis:"+item); Pour plus de lisibilité du code, il est recommandé d utiliser cette forme lorsque cela est possible. L instruction «break» peut être utilisée, on l a vu dans les «switch», et aussi dans toutes les instructions de boucles «while», «do..while» ou «for» afin de quitter l itération en cours [30]

31 Instruction break classbreakdemo{ publicstaticvoidmain(string[]args){ int[]arrayofints={32,87,3,589,12,1076,2000,8,622,127; intsearchfor=12; inti; booleanfoundit=false; for(i=0;i<arrayofints.length;i++){ if(arrayofints[i]==searchfor){ foundit=true; break; if(foundit){ System.out.println("Found"+searchfor+"atindex"+i); else{ System.out.println(searchfor+"notinthearray"); Une instruction «break» permet de quitter la boucle dans laquelle elle se situe. Dans le cas où il y a plusieurs niveaux de boucles imbriquées et que le «break» doit quitter la boucle de niveau supérieur, dans ce cas il est nécessaire d utiliser un label auquel le «break» va se référer. Instruction break avec label classbreakwithlabeldemo{ publicstaticvoidmain(string[]args){ int[][]arrayofints={{32,87,3,589,{12,1076,2000,8, {622,127,77,955; intsearchfor=12; inti; intj=0; booleanfoundit=false; search:for(i=0;i<arrayofints.length;i++){ for(j=0;j<arrayofints[i].length;j++){ if(arrayofints[i][j]==searchfor){ foundit=true; breaksearch; if(foundit){ System.out.println("Found"+searchfor+ "at"+i+","+j); else{ System.out.println(searchfor+"notinthearray"); [31]

32 L instruction «continue» permet de terminer l itération en cours et passer immédiatement à l itération suivante. Elle peut être utilisée dans les instructions de boucle «while», «do..while» et «for». Instruction continue classcontinuedemo{ publicstaticvoidmain(string[]args){ StringsearchMe="peterpiperpickeda" +"peckofpickledpeppers"; intmax=searchme.length(); intnumps=0; for(inti=0;i<max;i++){ //interestedonlyinp's if(searchme.charat(i)='p') continue; //processp's numps++; System.out.println("Found"+numPs+"p'sinthestring."); De même que l instruction «break», l instruction «continue» peut être utilisée avec un label, nécessaire lorsqu on est en présence de boucles imbriquées. Il y a encore une dernière instruction qui peut intervenir dans les itérations : l instruction «return» qui permet de quitter une méthode, quittera également l instruction de contrôle en cours [32]

33 5. Les classes et les objets Nous avions déjà vu la classe «Bicycle». Bicycle.java packagech.gri.cours.ch6; publicclassbicycle{ //thebicycleclasshas //threefields publicintcadence; publicintgear; publicintspeed; //thebicycleclasshas //oneconstructor publicbicycle(intstartcadence,intstartspeed,intstartgear){ gear=startgear; cadence=startcadence; speed=startspeed; //thebicycleclasshas //fourmethods publicvoidsetcadence(intnewvalue){ cadence=newvalue; publicvoidsetgear(intnewvalue){ gear=newvalue; publicvoidapplybrake(intdecrement){ speedb=decrement; publicvoidspeedup(intincrement){ speed+=increment; Et une sous-classe «MountainBike». MountainBike.java packagech.gri.cours.ch6; publicclassmountainbikeextendsbicycle{ //themountainbikesubclasshas //onefield publicintseatheight; //themountainbikesubclasshas //oneconstructor [33]

34 publicmountainbike(intstartheight,intstartcadence,intstartspeed, intstartgear){ super(startcadence,startspeed,startgear); seatheight=startheight; //themountainbikesubclasshas //onemethod publicvoidsetheight(intnewvalue){ seatheight=newvalue; La classe «MountainBike» hérite de tous les attributs et de toutes les méthodes de «Bicycle». Cette sousclasse ajoute également un attribut supplémentaire «seatheight» et une méthode supplémentaire «setheight()» qui lui sont propres Les classes Une classe a une déclaration et un corps (body) entre les accolades «{». Une déclaration de classe a la syntaxe suivante. Déclaration d une classe [public private protected] class ClassName [extends ParentClassName] [implements Interface1Name,Interface2Name,InterfaceNName] - Zéro ou un modificateur d accessibilité. - Le mot clé class. - Le nom de la classe, par convention en «camel case», débuttant par une majuscule. - S il y a une classe parente, le mot clé extends3suivi du nom de la classe parente. - S il y a des interfaces parentes, le mot clé implements3 suivi d une liste de nom d interfaces séparées par des virgules. Dans le corps d une classe, on trouvera les éléments suivants : - Des attributs - Des constructeurs - Des méthodes Un attribut est déclaré comme suit : Déclaration d un attribut de classe [public private protected]typenom_de_variable; - Zéro ou un modificateur d accessibilité. - Le type de l attribut. Un type primitif ou une classe. - Le nom de la variable (convention de nommage) [34]

35 Un constructeur est invoqué pour construire une nouvelle instance. La syntaxe ressemble à la déclaration d une méthode, excepté qu on utilise le nom de la classe et que le constructeur n a pas de type de retour. Un constructeur est déclaré comme suit : Déclaration d un constructeur [public private protected]classname(liste_de_paramètres){ - Zéro ou un modificateur d accessibilité. - Le nom de la classe. - Zéro à N paramètres. Vous pouvez déclarer de zéro à plusieurs constructeurs dans une même classe, mais chacun doit avoir une signature différente, donc une liste de paramètres différents. Si vous ne déclarez aucun constructeur, alors le compilateur fournit automatiquement un constructeur par défaut sans paramètres qui appelle le constructeur par défaut de la super-classe. Si une classe n a pas de super-classe, alors elle est tout de même implicitement une sous-classe de java.lang.object. Si une classe ne peut pas avoir accès au constructeur d une autre classe, alors ne peut jamais l instancier. Une méthode est déclarée comme suit : Déclaration d une méthode [public private protected]typederetour voidmethodname(liste_de_paramètres){ - Zéro ou un modificateur d accessibilité. - Un type de retour qui peut être un type primitif, une classe ou void, si la méthode ne retourne pas de résultat. - Le nom de la méthode. Selon les conventions de nommage, en général, une méthode commence par un verbe. - Zéro à plusieurs paramètres séparés par des virgules La signature d une méthode est constituée du nom de la méthode et de la liste des ses paramètres. Dans une classe, le nom de la méthode n est pas nécessairement unique, mais la signature d une méthode doit être unique. Ce qui signifie que vous pouvez déclarer deux méthodes avec le même nom pour autant qu elles n aient pas les mêmes paramètres. Attention, le type de retour n est pas pris en considération il n est pas possible de définir deux méthodes du même nom, avec les mêmes paramètres, mais avec des types de retour différents. Les paramètres d un constructeur ou à une méthode peuvent être de n importe quel type : types primitifs, classes, tableaux ou arguments variables (ci-dessous). Par contre, contrairement à d autres langages, il n est pas possible de passer une méthode en paramètre à une autre méthode. Le nom d un paramètre doit être unique dans le bloc de code dans lequel il est visible. Le paramètre d un constructeur ou d une méthode est visible uniquement dans le corps du constructeur ou de la méthode. Le compilateur ne vous empêche pas d utiliser, comme nom de paramètre, le nom d un attribut de la classe. Mais, attention, dans ce cas, le paramètre masque l attribut. Paramètres et attributs [35]

36 classcircle{ privateintx,y,radius; publicvoidsetorigin(intx,inty){ System.out.println(x); //AffichelePARAMETREx System.out.println(this.x);//Affichel'ATTRIBUTx Les arguments variables (varargs) peuvent être utilisés lorsque vous ne savez pas combien de paramètres d un certain type vous devez passer à une méthode. En fait, il s agit d un tableau. Arguments variables publicpolygonpolygonfrom(point...corners){ intnumberofsides=corners.length; Pointpoint1=corners[0]; Pointpoint2=corners[1]; Les types primitifs sont passés par valeur. Cela signifie que les modifications de paramètres sont visibles uniquement dans le corps de la méthode. Lorsque la méthode retourne, les modifications sont perdues. Types primitifs = passage par valeur publicclasspassprimitivebyvalue{ publicstaticvoidmain(string[]args){ intx=3; //invokepassmethod()with //xasargument passmethod(x); //printxtoseeifits //valuehaschanged System.out.println("AfterinvokingpassMethod,x="+x); //changeparameterinpassmethod() publicstaticvoidpassmethod(intp){ p=10; Les classes, les références à des types, sont aussi passés par valeur, mais la valeur est la référence à l objet. Donc même si vous modifiez l instance de l objet dans une méthode, sa référence reste identique et les changements seront visibles par l appelant. Mais si la référence est modifiée dans la méthode, ce changement ne sera pas visible par l appelant. Classe passage par valeur publicvoidmovecircle(circlecircle,intdeltax,intdeltay){ //codetomoveoriginofcircletox+deltax,y+deltay circle.setx(circle.getx()+deltax); circle.sety(circle.gety()+deltay); //codetoassignanewreferencetocircle [36]

37 circle=newcircle(0,0); movecircle(mycircle,23,56) Une méthode retourne lorsque : - Toutes les instructions ont été exécutées. - Elle atteinte l instruction return - Une exception est levée (voir plus tard) 5.2. Les objets Un programme Java manipule des objets. Ces objets doivent d abord être instanciés via un constructeur. Pour un déclarer un objet, on utilise la syntaxe suivante. Déclarer un objet PointoriginOne=newPoint(23,94); RectanglerectOne=newRectangle(originOne,100,200); RectanglerectTwo=newRectangle(50,100); - Une déclaration d une variable et un opérateur d affectation. - Le mot clé new3qui est l opérateur Java qui créé l objet. - L appel au constructeur qui permet d initialiser l objet. Il n est pas obligatoire d affecter le résultat de l appel au constructeur à une variable. Utiliser un constructeur sans affecter à une variable intheight=newrectangle().height; callmethod(newrectangle()); Une fois qu un objet est créé, vous pouvez l utiliser en faisant référence à ses attributs ou en appelant une de ses méthodes. Référence aux attributs et aux méthodes System.out.println("WidthofrectOne:"+rectOne.width); System.out.println("HeightofrectOne:"+rectOne.height); System.out.println("AreaofrectOne:"+rectOne.getArea());... recttwo.move(40,72); Un des grands avantages du langage Java est que le programmeur n a pas a se soucier de l allocation de la mémoire lors de la création des objets. Et surtout pas à se soucier de libérer la mémoire qui n est plus utilisée, car le Garbage Collector de la JVM s en charge à notre place. Il libère donc la mémoire lorsqu il peut déterminer qu un objet n est plus utilisé, c'est-à-dire lorsqu il n y a plus de références sur cet objet [37]

38 5.3. Le mot clé «this» Le mot clé thispermet de référencer l instance courante de la classe.. Il peut être utilisé dans un constructeur ou une méthode pour référencer un attribut de l instance, souvent parce qu un attribut est masqué par un paramètre. Il peut aussi être utilisé pour permettre l appel à un constructeur de la même classe. Utilisation de this publicclassrectangle{ privateintx,y; privateintwidth,height; publicrectangle(){ this(0,0,0,0); publicrectangle(intwidth,intheight){ this(0,0,width,height); publicrectangle(intx,inty,intwidth,intheight){ this.x=x; this.y=y; this.width=width; this.height=height; Le mot clé this ne peut donc pas être utilisé dans des méthodes static, car une instance courante doit exister Contrôler l accès Les modificateurs d accessibilités permettent de contrôler l accès aux classes, aux attributs ou aux méthodes. Modificateurs d accessibilités public Accès au monde entier protected Accès limité aux classes du même package ou aux sous-classes. private Accès limité à la classe même. T3 Pas de modificateur, on appelle cela «package private». Accès aux classes du même package. Pour les attributs, dans le doute, vous devez toujours attribuer le niveau d accessibilité le plus bas, c'est-à-dire private, à moins d avoir une bonne raison de donner plus de visibilité. A l exception des constantes. Notez qu une classe ne peut pas être déclarée private ou protected, à moins d être une classe interne, ce que nous verrons plus loin dans le cours Le mot clé «static» Nous avons vu qu il y existait des variables d instance (les attributs de la classe) et des variables de classe. Chaque instance d une classe, chaque différent objet, possède donc ses propres variables d instance. A l inverse, toutes les instances d une même classe partagent les mêmes variables de classe [38]

39 Une variable de classe est déclarée avec le mot clé static. Variable de classe publicclassbicycle{ privateintcadence; privateintgear; privateintspeed; privateintid; privatestaticintnumberofbicycles=0; publicbicycle(intstartcadence,intstartspeed,intstartgear){ gear=startgear; cadence=startcadence; speed=startspeed; //incrementnumberofbicycles //andassignidnumber id=++numberofbicycles; //newmethodtoreturntheidinstancevariable publicintgetid(){ returnid; Pour référencer une variable de classe, on utilise le nom de la classe, ce qui permet de les distinguer des variables d instance. Il est aussi possible de référencer une variable de classe avec une instance, mais cela est découragé, car cela rend le code moins lisible. D ailleurs vous aurez un warning dans Eclipse : The static field Bicycle.numberOfBicycles should be accessed in a static way Variable de classe BicyclemyBike=newBicycle(10,10,1); System.out.println(myBike.numberOfBicycles); System.out.println(Bicycle.numberOfBicycles); Les méthodes également peuvent être déclarées static. Les méthodes statiques peuvent être appelées directement en utilisant le nom de la classe, sans avoir à passer par l instanciation d un objet. Variable de classe publicstaticintgetnumberofbicycles(){ returnnumberofbicycles; System.out.println(Bicycle.getNumberOfBicycles()); Comme pour l accès aux attributs statiques, une méthode statique peut également être appelée à partir d une instance d un objet, mais cela est découragé et génère un warning. Pour résumer : - Une méthode d instance peut accéder directement à une variable d instance [39]

40 - Une méthode d instance peut accéder directement à une variable de classe ou à méthode de class (méthode statique). - Une méthode de classe (statique) peut accéder directement à une variable de classe et à une méthode de classe. - Mais les méthodes de classes (statique) ne peuvent pas accéder aux variables d instance ou aux méthodes d instance. Elles doivent utiliser une référence à un objet, donc définir une instance. Aussi les méthodes de classes ne peuvent pas utiliser le mot clé this. Le mot clé static combiné avec finalest utilisé pour définir des constantes. Le mot clé finalindique que la valeur ne peut pas changer. Constantes staticfinaldoublepi= ; Les constantes s écrivent, par convention, tout en majuscules et en séparant les mots par des caractères de soulignement (underscore). Finalement, le mot clé static peut être utilisé pour créer un bloc d initialisation statique. Un bloc d initialisation peut être déclaré static ou non. Cela ne s utilise pas très souvent. Bloc d initialisation publicclassinitializationdemo{ privateintnumber; privateintlongueur; { number=...; longueur=...; privatestaticinttaille; static{ taille=...; 5.6. Les classes internes Java vous permet de définir une classe à l intérieur d une autre classe : c est une classe interne (nested class). Une classe interne peut être déclarée «static» ou non. Cela peut être utile dans certains cas : - Faire un regroupement logique de classes - Pour l encapsulation des données - Pour la lisibilité, il peut être judicieux de placer une petite classe proche de l endroit où elle est utilisée [40]

41 5.7. Les types énumérés Un type énuméré est type de données particulier qui permet de définir un ensemble de constantes. Une variable d un type énuméré pourra prendre n importe quelle valeur parmi cet ensemble de constante. Par exemple, les quatre points cardinaux : NORD, OUEST, SUD, EST ou les jours de la semaine. Comme ce sont des constates les valeurs d un type énuméré s écrivent en majuscules. Un type énuméré se déclare comme suit. Type énuméré publicenumday{ SUNDAY,MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY Un type énuméré peut notamment être utilisé dans une instruction switch. En fait, en Java, un type énuméré est une sorte de class particulière. Comme une classe, un type énuméré peut définir des attributs et des méthodes. Mais en plus, le compilateur y ajoute des méthodes prédéfinies, par exemple «values()» qui s utilise généralement dans une itération «for» pour parcourir les constantes du type énuméré. Toutes les classes héritent par défaut de «java.lang.object», et tous les types énuméré de «java.lang.enum». Exemple publicenumplanet{ MERCURY(3.303e+23,2.4397e6), VENUS(4.869e+24,6.0518e6), EARTH(5.976e+24, e6), MARS(6.421e+23,3.3972e6), JUPITER(1.9e+27,7.1492e7), SATURN(5.688e+26,6.0268e7), URANUS(8.686e+25,2.5559e7), NEPTUNE(1.024e+26,2.4746e7); privatefinaldoublemass;//inkilograms privatefinaldoubleradius;//inmeters Planet(doublemass,doubleradius){ this.mass=mass; this.radius=radius; privatedoublemass(){returnmass; privatedoubleradius(){returnradius; //universalgravitationalconstant(m3kgb1sb2) publicstaticfinaldoubleg= eb11; doublesurfacegravity(){ returng*mass/(radius*radius); doublesurfaceweight(doubleothermass){ returnothermass*surfacegravity(); publicstaticvoidmain(string[]args){ if(args.length=1){ System.err.println("Usage:javaPlanet<earth_weight>"); [41]

42 System.exit(B1); doubleearthweight=double.parsedouble(args[0]); doublemass=earthweight/earth.surfacegravity(); for(planetp:planet.values()) System.out.printf("Yourweighton%sis%f%n", p,p.surfaceweight(mass)); 5.8. Les annotations Les annotations permettent d apporter des données ou des informations à un programme sans toutefois faire partie du programme. Une annotation n a pas d effet direct sur le code exécuté. Les annotations sont utilisées pour : - Ajouter des informations pour la compilation : par exemple pour demander au compilateur de supprimer un warning. - Des outils ou framework utilisent des annotations pour générer du code ou des fichiers XML, lors de la compilation ou lors d une phase de configuration. - Certaines annotations sont disponibles lors de l exécution Voici la déclaration d une annotation. Annotation : déclaration public@interfaceclasspreamble{ Stringauthor(); Stringdate(); intcurrentrevision()default1; StringlastModified()default"N/A"; StringlastModifiedBy()default"N/A"; //Noteuseofarray String[]reviewers(); Et son utilisation. Annotation : author="johndoe", date="3/17/2002", currentrevision=6, lastmodified="4/12/2004", lastmodifiedby="janedoe", //Notearraynotation reviewers={"alice","bob","cindy") publicclassexample{ //classcodegoeshere [42]

43 Finalement, il existe 3 annotations prédéfinies par le langage Java. Annotations voidusedeprecatedmethod(){ //deprecationwarning //Bsuppressed objectone.deprecatedmethod(); [43]

44 6. Liste des mots réservés Voici la liste des mots réservés (ou mots clés = keywords) du langage Java. Une première liste avec les mots réservés dont vous devez connaître la signification et l utilité. Nous verrons chacun de ces mots réservés plus en détails dans les prochains chapitres de ce cours. Mot clé Description void Utilisé pour indiquer qu une méthode ne retourne pas de valeur. null Utilisé pour indiquer une référence nulle. package Permet de définir un paquetage qui permet de regrouper des types (classes ou interfaces). import Permet de spécifier des classes ou des packages entiers qui sont référencés dans une classe. Un instruction d import peut être static. class Mot clé permettant de définir une classe Java. interface Utilisé pour déclarer une interface. extends Utilisé dans la déclaration d une classe pour spécifier la classe parente ou dans la déclaration d une interface pour déclarer une ou plusieurs interfaces parentes. implements Utilisé dans la déclaration d une classe pour spécifier une ou plusieurs interfaces implémentées par cette classe. super Utilisé pour accéder aux variables d instances, aux méthodes et aux constructeurs hérités par une classe. this Utilisé pour représenter l instance courante d une classe, et également dans un constructeur pour appeler un autre constructeur de la même classe. return Utilisé pour terminer l exécution d une méthode. Peut être suivi d une valeur si la méthode le requiert ou non si la méthode est déclarée void. new Utilisé pour créer une nouvelle instance d un objet [44]

45 abstract Indique qu une classe ou une méthode est abstraite. final Utilisé pour définir un élément qui ne peut plus être modifié par la suite. On ne peut pas hériter d une classe finale, et toutes ses méthodes sont implicitement finales. On ne peut pas surcharger une méthode finale. Une variable finale ne peut être affectée qu une seule fois. static Utilisé pour définir une variable de classe (ou une méthode ou une classe interne), private Utilisé pour déclarer une variable, méthode ou classe interne qui ne peut être accédée que par des autres membres de la classe dans laquelle elle est déclarée. protected Utilisé pour déclarer une variable, méthode ou classe interne qui ne peut être accédée que par des membres de la même classe, y compris les sous-classes ou les classes du même package. public Utilisé pour déclarer une variable, méthode ou classe qui peut être accéder par n importe quelle autre classe. if Test conditionnel if.. else. else switch Utilisé pour définir une instruction conditionnelle switch.. case.. default. case default for Itération for. do Itération do.. while. while Itérationwhile ou itérationdo..while. break Permet de quitter une itération. continue Permet de poursuivre l exécution d une itération [45]

46 boolean Type booléen, une variable booléenne peut prendre les valeurs true ou false. false true byte Type de base. Un byte est un nombre entier (8 bits). char Type de base. Un char représente un caractère (16 bits) double Type de base. Un double est un nombre réel double précision (64 bits). float Type de base. Un float est un nombre réel (32 bits). int Type de base. Un int est un nombre entier (32 bits). long Type de base. Un long est un nombre entier (64 bits). short Type de base. Un short est un nombre entier (16 bits). throw Permet de lancer une exception. throws Utilisé dans la déclaration d une méthode pour indiquer les exceptions qui ne sont pas gérées dans cette méthode, mais sont passées à l appelant. try Utilisé pour déclarer un bloc d instruction avec gestion des erreurs. S utilise obligatoirement avec catch et éventuellement avec finally. catch S utilise dans un bloc try.. catch afin d attraper une exception pour la traiter. finally Définit un bloc d instructions à exécuter dans tous les cas après l exécution du bloc try, et de l éventuel bloc catch, qu il y ait eu une erreur ou non. synchronized Utilisé dans une déclaration de méthode ou dans un bloc de code pour garantir qu un seul processus à la fois exécute le code de la méthode ou du bloc de code. instanceof Opérateur binaire qui prend une référence objet comme première opérande et une classe ou interface comme seconde opérande. L instruction retourne true si [46]

47 le type de l objet référencé est compatible avec la classe indiquée. enum A parti de J2SE 1.5 : permet de déclarer un type énuméré. assert A parti de J2SE 1.5 : indique une instruction d assertion. Cette seconde liste présente les mots réservés moins souvent utilisés, vous devez savoir qu ils existent et savoir retrouver leur signification au besoin dans la documentation. Mot clé Description const Ce mot réservé n est pas utilisé par le langage java. goto Ce mot réservé n est pas utilisé par le langage java. native Permet de déclarer qu une méthode n est pas implémentée dans le fichier source Java, mais plutôt dans un autre langage. strictfp Permet de restreindre la précision et l arrondi des calculs en virgule flottante pour assurer la portabilité. transient Permet de déclarer qu une variable s instance n est pas serialisable. volatile Permet de déclarer qu une variable d instance est modifiable de façon asynchrone par des processus concurrents [47]

48 7. Les interfaces et l héritage Il y a un certain nombre de situations dans le génie logiciel où il est important pour les groupes disparates de programmeurs de se mettre d'accord sur un «contrat» qui précise comment leur logiciel interagit. Chaque groupe devrait être en mesure d'écrire leur code sans aucune connaissance de la façon dont le code de l'autre groupe est écrit. De manière générale, les interfaces sont de tels contrats Les interfaces Dans le langage de programmation Java, une interface est un type référence, similaire à une classe, qui peut contenir des constantes, signatures de méthode, et les types imbriqués, sauf qu il n'y a pas de corps de méthode. Les interfaces ne peuvent pas être instanciées, elles peuvent uniquement être implémentées par les classes ou prolongées (héritées) par d'autres interfaces. Exemple d interface publicinterfaceoperatecar{ //constantdeclarations,ifany //methodsignatures //AnenumwithvaluesRIGHT,LEFT intturn(directiondirection, doubleradius, doublestartspeed, doubleendspeed); intchangelanes(directiondirection, doublestartspeed, doubleendspeed); intsignalturn(directiondirection, booleansignalon); intgetradarfront(doubledistancetocar, doublespeedofcar); intgetradarrear(doubledistancetocar, doublespeedofcar);... //moremethodsignatures Pour utiliser une interface, il est donc nécessaire de créer une classe qui implémente l interface. Exemple d implémentation d une interface publicclassoperatebmw760iimplementsoperatecar{ //theoperatecarmethodsignatures,withimplementationbb //forexample: intsignalturn(directiondirection,booleansignalon){ //codetoturnbmw'sleftturnindicatorlightson //codetoturnbmw'sleftturnindicatorlightsoff //codetoturnbmw'srightturnindicatorlightson //codetoturnbmw'srightturnindicatorlightsoff //othermembers,asneededbbforexample,helperclassesnot [48]

49 //visibletoclientsoftheinterface Le langage de programmation Java ne permet pas l'héritage multiple, une classe peut hériter d'une seule classe, mais les interfaces fournissent une alternative. Par contre, une classe peut implémenter plus d'une interface. Par conséquent, les objets peuvent avoir plusieurs types: le type de leur propre classe et les types de toutes les interfaces qu'ils implémentent. Cela signifie que si une variable est déclarée être le type d'une interface, sa valeur peut faire référence à n'importe quel objet qui est instancié à partir de n'importe quelle classe qui implémente l'interface. - Une interface peut hériter d une ou plusieurs interfaces. - Une interface peut définir des constantes et des méthodes sans corps. Elle peut aussi être vide. Exemple publicinterfacegroupedinterfaceextendsinterface1,interface2,interface3{ //constantdeclarations //baseofnaturallogarithms staticfinaldoublee= ; //methodsignatures voiddosomething(inti,doublex); intdosomethingelse(strings); Imaginons qu après coup, vous vouliez rajouter une troisième méthode à l interface ci-dessus. Si vous le faites, alors toutes les classes qui implémentent déjà cette interface auront une erreur de compilation car elles n implémentent pas la nouvelle méthode ajoutée. Par conséquent, il est préférable d ajouter une nouvelle interface qui hérite de la première (une «sous-interface»). Exemple interfacegroupedinterfaceplusextendsgroupedinterface{ voiddosomethingmore(inti); Maintenant, les utilisateurs de votre interface pourront choisir de continuer à utiliser l ancienne version ou la nouvelle interface avec la méthode supplémentaire L héritage Une classe qui hérite d une autre est appelée une «sous-classe» (mais aussi une classe dérivée, une classe étendue ou une classe enfant). La classe à partir de laquelle on hérite est appelée une «super-classe» (mais aussi classe de base ou classe parente). Excepté Object qui n a pas de classe parente, tous les objets du langage Java ont une (et une seule) superclasse. Par défaut, la super-classe de tout objet est java.lang.object. L idée de l héritage est simple et puissante. Si vous voulez créer une classe et qu il existe déjà une classe qui contient une partie du code que vous voulez, alors vous pouvez hériter de cette classe afin de réutiliser le code déjà écrit sans avoir le récrire ni à la tester ou débugger [49]

50 Une sous-classe hérite de tous les membres de la super-classe, ce sont les attributs, les méthodes et les classes internes. Mais elle n hérite pas des constructeurs. Cela dit une sous-classe peut appeler un constructeur de la super-classe, donc il n est pas nécessaire de les récrire. Une classe peut avoir un parent, qui lui-même a un parent, qui lui-même a un parent, etc. Il n y a pas de limites. Plus une classe est haute dans la hiérarchie de classe, plus son comportement est général. Plus une classe est basse dans la hiérarchie et plus son comportement est spécialisé. Une super-classe publicclassbicycle{ //thebicycleclasshasthreefields publicintcadence; publicintgear; publicintspeed; //thebicycleclasshasoneconstructor publicbicycle(intstartcadence,intstartspeed,intstartgear){ gear=startgear; cadence=startcadence; speed=startspeed; //thebicycleclasshasfourmethods publicvoidsetcadence(intnewvalue){ cadence=newvalue; publicvoidsetgear(intnewvalue){ gear=newvalue; publicvoidapplybrake(intdecrement){ speedb=decrement; publicvoidspeedup(intincrement){ speed+=increment; [50]

51 Voici un exemple de sous-classe. Une sous-classe publicclassmountainbikeextendsbicycle{ //themountainbikesubclassaddsonefield publicintseatheight; //themountainbikesubclasshasoneconstructor publicmountainbike(intstartheight,intstartcadence,intstartspeed, intstartgear){ super(startcadence,startspeed,startgear); seatheight=startheight; //themountainbikesubclassaddsonemethod publicvoidsetheight(intnewvalue){ seatheight=newvalue; Une sous-classe hérite de tous les attributs et toutes les méthodes public3ou protected de son parent. Si la sous-classe se trouve dans le même package que son parent, alors elle hérite également des attributs et méthode «package private». Dans la sous-classe vous pouvez : - Utiliser un attribut ou une méthode héritées. - Remplacer un attribut ou une méthode héritées. - Cacher un attribut ou surcharger une méthode héritées : pour cela, il faut déclarer un attribut ou une méthode avec le même nom ou la même signature que dans la classe parente. - Ajouter un nouvel attribut ou une nouvelle méthode. En général, les attributs d une classe sont déclarés private. Par conséquent, ils ne sont pas visibles par les sous-classes. Pour cela, on définit en principe des méthodes public3ou protecteddans la classe parente qui permettent d accéder aux attributs, de sorte que bien que les attributs ne soient pas visibles, les méthodes permettant d y accéder le sont. Pour convertir, une variable dans un autre type, on peut utiliser un «cast». Exemple de Cast publicstaticvoidmain(string[]args){ //LavariablemyBikeestàlafoisdetypeBicycleetdetype //MountainBike BicyclemyBike=newMountainBike(1,2,3,4); System.out.println(myBikeinstanceofMountainBike);//true System.out.println(myBikeinstanceofBicycle);//true //Erreurdecompilation: //MountainBikemyMountainBike=myBike; MountainBikemyMountainBike=(MountainBike)myBike; mymountainbike.setheight(56); System.out.println(myBikeinstanceofMountainBike);//true [51]

52 System.out.println(myBikeinstanceofBicycle);//true 7.3. Surcharger une méthode Une sous-classe peut surcharger une méthode de sa classe parente. Mais il faut distinguer deux cas de figure : - Surcharger une méthode d instance. - Cacher une méthode de classe (méthode de classe = méthode static) Exemple publicclassanimal{ publicstaticvoidtestclassmethod(){ System.out.println("TheclassmethodinAnimal."); publicvoidtestinstancemethod(){ System.out.println("TheinstancemethodinAnimal."); classcatextendsanimal{ publicstaticvoidtestclassmethod(){ publicvoidtestinstancemethod(){ System.out.println("TheinstancemethodinCat."); publicstaticvoidmain(string[]args){ CatmyCat=newCat(); AnimalmyAnimal=myCat; Animal.testClassMethod(); Cat.testClassMethod(); myanimal.testclassmethod(); mycat.testclassmethod(); mycat.testinstancemethod(); myanimal.testinstancemethod(); TheclassmethodinAnimal. TheclassmethodinCat. TheclassmethodinAnimal. TheclassmethodinCat. TheinstancemethodinCat. TheinstancemethodinCat.3 Une méthode surchargée peut changer le modificateur d accessibilité, mais elle ne peut que rendre la méthode plus visible, mais pas moins. Donc une méthode protectedpeut être surchargée et rendue public3dans la sous-classe, par exemple. Si vous essayez de la rendre private, ce sera une erreur de compilation [52]

53 Le mot clé «super» permet de faire appel à la méthode de la super-classe depuis la méthode surchargée. Il permet également de faire appel à un constructeur de la super-classe depuis un constructeur de la sous-classe Polymorphisme Le polymorphisme est la capacité qu a un objet d avoir plusieurs formes possibles. En Java, cela va se concrétiser lorsque qu une classe parente est utilisée pour référencer un objet d une classe enfant. Tout objet pour lequel on peut dire «est un» peut être considéré comme étant polymorphique : «un chat est un animal un animal est un animal un lion est un animal un animal est un Object». classanimal{ publicvoidsayhello(){ System.out.println("Jenesaispasquijesuis.."); 3 classcatextendsanimal{ privatestringname; publiccat(stringname){ publicvoidsayhello(){ System.out.println("Miaou"); publicvoidsayhello(){ System.out.println("Roarrrrr"); 3 classpolymorphisme{ publicstaticvoidmain(string[]args){ Animalanimal1=newCat("Minou"); Animalanimal2=newLion(); animal1.sayhello(); animal2.sayhello(); Miaou Roarrrrr Dans l exemple ci-dessus, la variable animal1 est une référence de type «Animal», mais est un objet de type «Cat». Donc le compilateur sait qu il doit appeler la méthode surchargée «sayhello()» de la classe «Cat» et non de la classe «Animal». Pour appeler la méthode «sayhello()» de la classe «Animal», il faut que l objet soit de type «Animal», donc il faudrait avoir instancié un objet «new Animal()» Le mot clé final Le mot clé finalpeut être utilisé pour : [53]

54 - Indiquer qu une class3 ne peut pas être héritée par une sous-classe. On parle alors de classe immutable. C est le cas de la classe String. - Indiquer qu une méthode ne peut pas être surchargée par une sous-classe. Utile s il est important que le comportement décrit par la méthode ne soit jamais changé, car cela serait critique pour la consistance de l état de l objet Le mot clé abstract Le mot clé abstractpeut être utilisé pour : - Indiquer une classe abstraite. - Indiquer une méthode abstraite. Classes abstraites Une classe abstraite ne peut pas être instanciée, l appel à un constructeur de cette classe génère une erreur de compilation. Elle peut contenir ou non des méthodes abstraites. Son but est d être sous-classée. On utilise des classes abstraites pour définir des attributs ou des méthodes par défaut pour une hiérarchie de classe, en forçant l utilisation des sous-classes concrètes. Méthodes abstraites Une méthode abstraite est une méthode qui n a pas de corps. Si une classe définit au moins une méthode abstraite alors la classe doit être également abstraite. Une interface permet également de définir des méthodes sans corps. Alors dans quel cas utilise-t-on une interface et dans quel cas une classe abstraite? - Une interface ne peut contenir que des constantes et des déclarations de méthodes sans corps. - Une classe abstraite, elle, peut contenir des attributs, une partie de ses méthodes peuvent être concrètes, donc avoir une implémentation (un corps de méthode). Une classe abstraite permet donc de définir des classes partiellement implémentée. Exemple abstractclassgraphicobject{ intx,y;... voidmoveto(intnewx,intnewy){... abstractvoiddraw(); abstractvoidresize(); classcircleextendsgraphicobject{ voiddraw(){... voidresize(){... classrectangleextendsgraphicobject{ voiddraw(){ [54]

55 ... voidresize(){... Une classe abstraite peut également être une classe qui n implémente pas toute les méthodes d une interface. Exemple interfaceinterface{ voidx(); voidy(); abstractclassabstractclassimplementsinterface{ publicvoidx(){ System.out.println("X"); classconcreteclassextendsabstractclass{ publicvoidy(){ System.out.println("Y"); 8. Les nombres et les chaînes de caractères 8.1. Les nombres Nous avons vu que pour utiliser des nombres dans nos programmes Java, nous utilisons les types primitifs et que les types primitifs ne sont pas des objets. Mais, il y a parfois des raisons pour lesquelles, nous ne voulons pas utiliser des types primitifs, mais des objets. Pour cela, Java fournit une classe «Wraper» pour chacun des types primitifs. Il y a au moins deux cas de figure : - Vous devez passer un nombre en paramètre à une méthode qui prend un Object comme paramètre. Ou vous voulez stocker des nombres dans une collection de l API (les collections peuvent stocker uniquement des objets, pas des types primitifs). - Vous voulez bénéficiez des méthodes à disposition dans les casses wrapper pour faire des conversions, pour afficher ou formater [55]

56 Le compilateur permet ce qu on appelle autoboxing/unboxing. C'est-à-dire des conversions automatiques entre le type primitifs et la classe wrapper. - Autoboxing : une valeur d un type primitif peut être assignée à une variable d une classe wrapper. - Unboxing : une référence à un objet de type classe wrapper peut être assignée à une variable d une type primitif [56]

57 9. Les génériques Les génériques permettent de paramétrer des types (donc des classes ou des interfaces) ou des méthodes. Ils permettent de définir comment réutiliser le même code avec des inputs différents. La différence est qu un paramètre permet de passer une valeur, tandis qu un générique permet de passer un type. L usage des génériques permet de : - Améliorer le contrôle du typage par le compilateur. - D éliminer les «cast» de votre code source. - D implémenter des algorithmes génériques qui fonctionnent de manière identique quelque soit le type données traitées. Prenons cette classe Box, c est une boîte contenant un objet. Sans les génériques publicclassbox{ privateobjectobject; publicvoidset(objectobject){ this.object=object; publicobjectget(){ returnobject; On définit une classe générique de la manière suivante : Syntaxe classname<t1,t2,...,tn>{ En récrivant la classe Box en utilisant les génériques, notre boîte devient une «boîte contenant un objet d un type inconnu T». Avec les génériques publicclassbox<t>{ //Tstandsfor"Type" privatett; publicvoidset(tt){ this.t=t; publictget(){ returnt; Pour utiliser cette classe [57]

58 Usage Box<Integer>integerBox=newBox<Integer>(); integerbox.set(10); inti=integerbox.get(); integerbox.set(newobject());//themethodset(integer)inthetype Box<Integer>isnotapplicableforthearguments(Object) String s = integerbox.get(); // Type mismatch: cannot convert from IntegertoString Une méthode peut également contenir des génériques. Méthode générique publicvoidcopyfrom(box<t>anotherbox){ this.t=anotherbox.get(); On rencontre beaucoup l usage des génériques lorsque l on utilise l API Java des Collections. API Collections //ExempledeMap Map<Integer,String>map=newHashMap<Integer,String>(); map.put(1,"aaa"); map.put(2,"bbb"); map.put(3,"ccc"); Stringvalues=""; for(integerkey:map.keyset()){ values+=map.get(key); System.out.println(values); //ExempledeList List<Number>numberList=newArrayList<Number>(); numberlist.add(newinteger(1)); numberlist.add(newdouble(2.0)); numberlist.add(newlong(3l)); longsum=0l; for(numbernumber:numberlist){ sum+=number.longvalue(); System.out.println(sum); //ExempleavecBox<Integer> List<Box<Integer>>boxList=newArrayList<Box<Integer>>(); Box<Integer>box1=newBox<Integer>(); Box<Integer>box2=newBox<Integer>(); box1.set(newinteger(3)); box2.set(newinteger(4)); boxlist.add(box1); boxlist.add(box2); [58]

59 10. Les exceptions Une exception est l événement consécutif à une erreur dans un programme Java. On dit qu une exception est «lancée» («throw»). Lorsqu une exception survient dans un programme, l environnement d exécution remonte pas à pas la pile d appel du programme, pour rechercher si un des appelants peut traiter l erreur. Pour le bloc de code permettant de traiter une exception, on parle «d attraper une exception» («catch»). En Java, vous avez toujours deux possibilités avec les exceptions : - Soit vous l attrapez et la traitez. - Soit voit la spécifiez dans la déclaration de la méthode pour forcer les appelants à traiter l exception. Attraper et traiter une exception Exemple : traiter l exception publicvoidwritelist(listuneliste){ PrintWriterout=null; try{ System.out.println("Entering"+"trystatement"); out=newprintwriter(newfilewriter("outfile.txt")); for(inti=0;i<uneliste.size();i++){ out.println("valueat:"+i+"="+uneliste.get(i)); [59]

60 catch(ioexceptione){ System.err.println("CaughtIOException:"+e.getMessage()); finally{ if(out=null){ System.out.println("ClosingPrintWriter"); out.close(); else{ System.out.println("PrintWriternotopen"); Dans l exemple ci-dessus, l utilisation de «new FileWriter()» peut générer une exception «IOException». On a choisi de traiter l exception, donc le code pouvant générer une exception est placé à l intérieur d un bloc try. L exception «IOException», si elle se produit, sera traitée par le bloc catch. Et puis, que l exception se produise ou non, le bloc finally3sera de toute manière exécuté. Dans le scénario 1, une exception «IOException» est levée par «new FileWriter()». Seules les lignes en évidence sont exécutées. Scénario 1 : une exception est levée publicvoidwritelist(listuneliste){ PrintWriterout=null; try{ System.out.println("Entering"+"trystatement"); out=newprintwriter(newfilewriter("outfile.txt")); for(inti=0;i<uneliste.size();i++){ out.println("valueat:"+i+"="+uneliste.get(i)); catch(ioexceptione){ System.err.println("CaughtIOException:"+e.getMessage()); finally{ if(out=null){ System.out.println("ClosingPrintWriter"); out.close(); else{ System.out.println("PrintWriternotopen"); Dans le scénario 2, tout se déroule sans exceptions. Seules les lignes en évidence sont exécutées. Scénario 2 : pas d exception publicvoidwritelist(listuneliste){ PrintWriterout=null; try{ System.out.println("Entering"+"trystatement"); out=newprintwriter(newfilewriter("outfile.txt")); [60]

61 for(inti=0;i<uneliste.size();i++){ out.println("valueat:"+i+"="+uneliste.get(i)); catch(ioexceptione){ System.err.println("CaughtIOException:"+e.getMessage()); finally{ if(out=null){ System.out.println("ClosingPrintWriter"); out.close(); else{ System.out.println("PrintWriternotopen"); Propager une exception L autre possibilité est de déclarer qu une exception peut survenir lors du traitement de la méthode et laisser la responsabilité de traiter l erreur à l appelant. Déclarer une exception publicvoidwritelist(listuneliste)throwsioexception{ PrintWriterout=newPrintWriter(newFileWriter("OutFile.txt")); for(inti=0;i<uneliste.size();i++){ out.println("valueat:"+i+"="+uneliste.get(i)); if(out=null){ System.out.println("ClosingPrintWriter"); out.close(); else{ System.out.println("PrintWriternotopen"); Créer une exception Dans l exemple, ci-dessus, une méthode de l API était susceptible de lever une exception que nous devions gérer. Nous pouvons également lever nous-même une exception. Lever une exception publicvoidlogin(stringuser,stringpwd)throwsexception{ //Simauvaislogin if(...){ thrownewexception("invaliduserorpwd"); Voir également, créer notre propre classe d exception, qui dans ce cas doit hériter de java.lang.exception. Créer une classe Exception classloginexceptionextendsexception{ publicloginexception(stringuser,stringpwd){ super("invaliduser="+user+"orpwd="+pwd); [61]

62 publicvoidlogin(stringuser,stringpwd)throwsloginexception{ //Simauvaislogin if(...){ thrownewloginexception("invaliduserorpwd"); En fait, il existe trois catégories d exception : - Les «checked exception» que vous devez traiter sinon vous avez une erreur de compilation. Les checked exception doivent être utilisées pour les cas d erreur prévisibles. Suivant l erreur vous devez déterminer si c est de la responsabilité de la méthode courante ou de l appelant de traiter ce cas d erreur. - Les «unchecked exception» (aussi appelées «runtime exceptions», car elles héritent de RuntimeException) que vous n êtes pas obligés de traiter. Les unchecked exception sont levées suite à des erreurs de programmation, une référence nulle, un index de tableau trop grand, etc. Ni la méthode courante, ni l appelant ne peuvent traiter proprement ces cas d erreurs, qui ne devraient pas se produire. C est pourquoi, il n est pas nécessaire de les gérer. - Les «errors», qui sont liées à des événements extérieurs (file système, réseau, etc), que vous n êtes pas obligés de traiter. Unchecked Exception publicvoidlogin(stringuser,stringpwd){ //siuserestnullunenullpointerexceptionestlevée //Ils'agitd'uneuncheckedexcpetion,donciln'estpasnécessaire //delatraiter. if(user.equals(pwd)){ publicvoidautremethode(){ //Ils'agitd'uneuncheckedexcpetion,donciln'estpasnécessaire //deladéclarer [62]

63 thrownewnullpointerexception(); [63]

64 11. Les collections Les collections sont une API standard de Java fournie par le package java.util. Cette API met à disposition à peu près toutes les structures de données dont vous pourriez avoir besoin au travers d interfaces et de classes implémentant ces interfaces. En voici les principales interfaces : - Collection : interface de base représentant une collection d objets du même type. - Set (ensemble) : une collection ne pouvant pas contenir de doublons. (par exemple un jeu de cartes) - List : une collection pouvant contenir des doublons (la liste de vos notes) - Queue : une collection avec un comportement particulier pour insérer ou supprimer des elements (pour une file d attente) - Map : une structure permettant de stocker des paires clé-valeur. Et les implémentations : Interfaces Hash table Resizable array Tree Linked list Hash table + Linked list Set HashSet TreeSet LinkedHashSet List ArrayList LinkedList Queue Deque ArrayDeque LinkedList Map HashMap TreeMap LinkedHashMap [64]

65 12. Architecture Ce chapitre vous présente quelques notions de base sur l architecture des applications ou des systèmes et les modèles les plus courants. Dès le moment ou des bases de données ou des serveurs d applications doivent interagir avec votre application, il est nécessaire de déterminer la façon dont vous allez architecturer l application de manière à bien séparer les responsabilités des différentes parties. Idéalement, il doit être possible relativement simplement de changer une des parties de l application sans avoir d impact sur les autres modules. La principale tâche de l architecte logiciel est donc de s assurer que les modules qui constituent une application sont faiblement couplés, c est-à-dire minimiser les dépendances entre les modules Application simple Une application Java est dite «standalone» si elle ne nécessite pas de ressources supplémentaires pour s exécuter, ele est donc indépendante Application client-serveur Dans une application client-serveur, appelé également une appalication 2-tiers, la machine du client communique directement avec la base de données Le modèle 3-tiers Dans le modèle 3-tiers, les instructions entre le client et la base de données transitent par un «middle-tier». Ce middle-tier est hébergé sur un serveur. Dans un système d information, on privilégie généralement ce modèle, car le tiers serveur permet de maintenir un contrôle des accès aux données, vérifier les opérations effectuées, et garantir l intégrité des données. D autre part, cela simplifie le déploiement des applications, puisque le serveur peut être mis à jour une seule fois pour tous les clients [65]

66 [66]

67 13. Java et les bases de données JDBC L API de Java pour interagir avec une base de données relationnelle est JDBC (Java DataBase Connectivity). Il s agit des packages «java.sql.*» et «javax.sql.*». JDBC vous aide à écrire des applications qui peuvent : - Se connecter à une source de données, une base de données dans notre cas. - Envoyer des instructions pour éxécuter des requêtes ou des commandes sur la base de données. - Traiter les données obtenues L exemple de code ci-dessous effectue les opérations suivantes : - Obtenir une connexion à la base de données. Cela se réalise à l aide de la classe DriverManager, en précisant une URL jdbc, un nom d utilisateur et un mot de passe. - Créer une instruction de base de données (Statement en anlgais). - A l aide de cette instruction, effectuer une requête SQL select. Le résultat d une requête est un objet ResultSet. - Finalement, une itération sur toutes les valeurs du obtenues dans le ResultSet pour traiter les données obtenues en résultat de la requête. JDBC Exemple public void connectandquerydb(string username, String password) { Connection con = DriverManager.getConnection( "jdbc:mydriver:mydatabase", username, password); Statement stmt = con.createstatement(); ResultSet rs = stmt.executequery( "SELECT a, b, c FROM Table1"); while (rs.next()) { int x = rs.getint("a"); String s = rs.getstring("b"); float f = rs.getfloat("c"); Pour pouvoir utiliser JDBC, il faut utiliser un pilote JDBC (=un driver JDBC). Tous les éditeurs de base de données fournissent un driver JDBC pour permettre aux programmes Java d utiliser leur base. Il s agit donc d une librairie, donc un fichier jar, qui doit être placé dans le classpath de votre application. - Pour MySQL : - Pour postgresql : - Pour Oracle : L exemple ci-dessous est similaire au premier, mais avec traitement des exceptions, et un utilisant un driver JDBC pour mysql [67]

68 Exemple JDBC public static void main(string[] args) { try { Class.forName("com.mysql.jdbc.Driver"); catch (ClassNotFoundException e) { System.out.println( "Impossible de charger le driver. Vérifier le classpath."); System.exit(0); Connection connexion = null; try { connexion = DriverManager.getConnection( "jdbc:mysql://ec compute- 1.amazonaws.com:3306/pronostic", "jps_ch", "****"); catch (SQLException e) { System.out.println( "Impossible de se connecter à la DB. Vérifier les paramètres."); System.exit(0); try { System.out.println("Connection OK Readonly mode = " + connexion.isreadonly()); catch (SQLException e) { System.out.println("Erreur de la base de données : " + e.getmessage()); finally { try { connexion.close(); catch (SQLException e) { Architecture JDBC nous fournit une abstraction de la base de données. C est à dire, que vous pourriez à tout moment vouloir remplacer la base de données de votre application par une autre, passer de MySQL à PostgresQL par exemple, sans avoir à modifier quoique ce soit dans votre programme. Il faut bien entendu modifier certains paramètres de votre programme comme l URL de la base de données et le driver JDBC utilisé. Mais si on a pris garde à externaliser ces paramètres dans des fichiers de configuration, alors le changement de base de données peut être réalisé en minimisant les conséquences. En pratique, cela ne fonctionne pas toujours à 100%, car il peut toujours subsister une requêtes SQL dans votre programme dans laquelle vous avez utilisé une notation spécifique à une base de données qui ne pourra pas être reconnue par une seconde [68]

69 JDBC peut être utilisé indifféremment dans des applications avec une architecture selon le modèle 2-tiers ou selon le modèle 3-tiers Les limites de JDBC Dans la pratique, les drivers JDBC sont toujours utilisés pour se connecter aux bases de données, mais pour interagir avec la base de données d une application, on préfère désormais utiliser l API JPA. En fait, la manipulation des données devient vitre lourde avec JDBC. Supposer que vous voulez lire la table Bicycle. Vous devrez effectuer une requête SQL à l aide d un objet Statement. Puis vous devrez faire une itération pour parcourir toutes les lignes du ResultSet obtenu. Et pour chaque ligne vous devrez gérer les différences entre les types de données, et construire un nouvelle instance à chaque itération. Cette grande quantité de code Java qu il faut écrire pour lire et écrire des données dans la base de données est considérée comme une perte de temps, car cela n apporte pas de valeur à l application finale. En effet, dans un projet d une certain envergure, on s efforce de passer du temps sur le cœur du programme et d utiliser les bons outils ou framework pour gagner du temps sur les parties uniquement techniques [69]

70 13.1. JPA Java Persistence API L API Java (Java Persistence API) fournit au développeurs Java une facilité pour effectuer un mapping entre les données relationnelles (les données stockées dans une base de données relationnelle) et les données manipulées en Java par des objets. L utilisation d une technique de mapping O/R (object-relationnal) offre un niveau d abstraction plus élevé que la simple utilisation de l API JDBC. Ce mapping assure la transformation des objets en Java vers les tables de la base de données et vis versa, pour les opérations de lecture (SQL SELECT) ou pour les opérations d écriture (SQL : INSERT, UPDATE, DELETE). L API Java fait parie du package Java EE, mais peut très bien être mis en œuvre dans une application Java SE. On peut voir JPA comme étant une surcouche à JDBC, mais une surcouche qui cache si bien JDBC que le développeur qui utilise JPA n aura pas une seule ligne de code à écrire mettant en œuvre JDBC. Si ce n est peutêtre le fait de devoir déclarer une connection à la base de données au format JDBC. De la même façon que les bases de données proposent un langage pour effectuer des requêtes : SQL. Le JPA propose également son langage de requête, mais basé sur les objets et les attributs des objets, plutôt que basés sur les tables et colonnes de la base de données. L API repose principalement sur deux notions : Les entités : - Les entités : qui sont les objets persistents. - Un gestionnaire : le entitymanager. Une entité est un objet java persistent. Typiquement une entité représente une table de la base de données, et chaque instance de cette entité représente une ligne dans la table de la base de données. Une entité doit avoir : - Sa classe doit être annotée avec l annotation javax.persistence.entity - La classe doit avoir un constructeur public ou protected sans argument - La classe ne doit pas être final. Ni aucune méthode, ni aucun attribut persisté ne doit être final - Les attributs persistés doivent être déclaré private, protected ou package-protected (donc tout sauf public) Une entité public class Person { private String attribute; [70]

71 14. Interfaces utilisateurs graphiques Dès qu une application doit interagir avec un utilisateur, il est nécessaire de réaliser une interface utilisateur (GUI = Graphical User Interface). Cette interface graphique est appelée «le client» dans le modèle 2-tiers (clientserveur) et dans le modèle 3-tiers. On distingue deux catégories d applications clientes : - Les clients lourds sont des applications qui doivent être installées sur les postes de travail des utilisateurs clients. Eclipse, par exemple, est un client lourd écrit en Java. On utilise généralement des clients lourds lorsqu il est nécessaire d accéder à des ressources locales : système de fichier, périphériques (scanner, lecteur de code barre), etc. Pour réaliser un client lourd en Java, on utilise «Swing». Il s agit d un framework standard de java (packages javax.swing.*) qui fournit des classes pour tous les éléments d interface graphique utilisateur : panels, layouts, boutons, champs de saisies, listes de sélection, etc. - Les clients légers ou les clients web sont des applications qui s exécutent dans un navigateur Internet. Ce type d application présente l avantage de ne pas nécessiter d installation sur les postes des utilisateurs clients. Pour réaliser un client léger en Java, il existe de nombreux frameworks et outils sur le marché. Tous se basent sur la spécification des servlets de JEE. Un Servlet est un composant Java qui peut être accédé à distance via le réseau et peut répondre à des requêtes. Typiquement, un Servlet peut être appelé via une requête http et répondre en générant du contenu HTML, qui peut être enrichi en HTML/JS/CSS, pour être affiché dans un navigateur. Une application web client léger en Java nécessite donc l utilisation d un conteneur d application web (un serveur d application web Java), tel que Apache Tomcat [71]

72 Voici une liste non-exhaustives de possibilités : o o o o JSP : Java Server Pages. JSF : Java Server Faces. GWT ou Vaadin. Technologies natives comme du pur HTML/CSS/JS pour les navigateurs ou des applications natives pour smartphone et/ou tablettes [72]

73 14.1. Interfaces graphiques avec Swing L API de Swing est très riche, elle comprend notamment : - Swing GUI Component : tous les composants, du bouton à la table en passant par les différents panels. De nomreux composants sont capables de fonctionnalités avancées comme trier les éléments, imprimer le contenu, faire du drag and drop, etc. - Pluggable Look&Feel : l apparance des applications Swing est donnée par le Look&Feel, il est possible de changer le look&feel d une application sans avoir à modifier l application en soi. - API Accessibilité : les outils d accessibilités pour les personnes handicapées. - Java 2D Api : des outils avancés pour le traitement des images. - API Internationalisation : pour supporter différentes conventions de langues ou de culture. Un programme Swing se compile et s exécute comme une application Java standard. Swing faisant partie des librairies standard de Java, livrée avec le JDK, il n est donc pas nécessaire de disposer de fichiers Jar additionnels. Pour le développement d application Swing, il est préférable d utiliser l IDE Netbeans, qui propose en standard un éditeur graphique avec une palette de composants Swing. Si vous êtes habitué à Eclipse, vous pouvez y ajouter le plugin «WindowBuilder», qui est un plugin développé par la fondation Eclipse, mais qui n est pas livré en standard avec la version basique de Eclipse Le positionnement des composants Avec Swing les composants graphiques comme les boutons ou les champs de saisies doivent être placés dans des conteneurs. Toute application possède donc un conteneur racine (top level container) : un JFrame. - Pour apparaître à l écran, un composant doit avoir été rattaché à la hiérarchie de composants du conteneur. - Chaque composant ne peut apparaître qu une seule fois. Pour avoir deux boutons affichés, il faut créer deux instances de la classe JButton. - Chaque composant hérite du composant parent JComponent. Il hérite en particulier du comportement commun à tous les éléments d interface utilisateur : tooltip, bordures, look&feel, layout, accessibility, drag and drop, focus, raccourcis clavier, etc [73]

74 Tous les composants Swing qui peuvent en contenir des autres (JFrame, JDialog, JPanel,JTabbedPane, JScrollPane, etc) organisent leur contenu selon un Layout. Le layout par défaut est le BorderLayout. En voici une liste, non exhaustive, car il est également possible de créer son propre layout : BorderLayout : organise son contenu selon les points cardinaux : nord, sud, est, ouest, centre. BoxLayout : organise les composants en une seule dimension, ligne ou colonne, selon l espace disponible. CadrLayout : utilisé généralement avec une combo-box qui permet d afficher certaines parties conditionnellement FlowLayout : layout par défaut pour les JPanel, place les composants en ligne, et passe automatiquement à la ligne suivante s il n y a plus assez de place en largeur. GridBagLayout : est le layout l eplus sophistiqué et le plus flexible. Il aligne les composants en les placant dans une grille de cellule, et permettant aux composants de s étendre sur plusieurs cellules, avec des lignes et des [74]

75 colonnes de taille différentes les unes des autres. C est le layout qui est utilisé par les générateurs d interfaces graphiques lorsque le développeur peut placer librement les composants de la palette. GridLayout : rend les composants tous de la même taille et les affiche selon une grille de cellules. GroupLayout : ce layout groupe les composants horizontalement ou verticalement. Utilisé par les «GUI Builder». SpringLayout : ce layout flexible, utilisé par les «GUI Builder», permet de positionner les composants en précisant les relations entre les arrêtes des composants Les événements Votre interface graphique utilisateur doit répondre à des événements générés par les actions de l utilisateur sur l interface. Cette gestion par événement est systématiquement gérée par un mécanisme d événements (Event) et d observateurs (Listener). Dans l exemple ci-dessous, un bouton doit générer un «beep» lorsqu il est actionné. Events & Listeners [75]

76 public class Beeper... implements ActionListener { //where initialization occurs: button.addactionlistener(this); public void actionperformed(actionevent e) {... //Make a beep sound... Donc les composants qui doivent répondre a des actions utilisateur doivent ajouter des Listeners. Si l événement est déclanché, une méthode «actionperformed» est alors appelée. Dans l exemple ci-dessus, la classe elle même est un Listener (on enregistre le Listener «this») et propose donc elle-même la méthode permettant de traiter l événement. Vous trouverez donc de nombreux Listeners (qui héritent tous de EventListener) et Event (qui héritent tous de ComponentEvent) : - ActionListener/ActionEvent pour les événements des boutons (actionperformed). - MouseListener/MouseEvent pour les événements de la souris (mouseclicked, mousepressed, mousereleased, mouseentered, mouseexited) - KeyListener/KeyEvent pour les événements du clavier (keypressed, keyreleased, keytyped) - Etc Il y a plusieurs méthodes pour utiliser le mécanisme de Event/Listener. - On peut directement choisir d implémenter l interface Listener, comme dans l exemple ci-dessus. Si plusieurs boutons peuvent générer un événement, alors l objet ActionEvent possède une method getsource() permettant de retrouver quel bouton a été cliqué. - On peut utiliser une classe, appelée un adapteur, qui implémente l interface Listener. Notre composant devra alors hériter de cette classe adapteur. L API Swing propose déjà des Adapters pour les principaux Listeners. - On peut declarer une classe adapteur comme une classe interne. - On peut utiliser un EventHandler permettant de centraliser la gestion des événements dans une seule et unique classe. - On peut utiliser une classe anonyme. Listener implémenté dans une classe anonyme public class MyClass extends... { [76]

77 ... someobject.addactionlistener(new ActionListener () { public void actionperformed(actionevent e) {... //Event listener implementation goes here... ); Applications Web en Java Une application web Java se compose de : - WEB-INF/classes : des classes utilisées côté serveur (par exemple, une classe représentant un panier d achat sur un site marchand). - WEB-INF/lib : des librairies (des archives JAR) utilisées par le code côté serveur. - WEB-INF/web.xml : le descripteur de déploiement - À la racine : du code pour le côté client, pages html, css, js, images, etc. Cette structure de répertoires est ensuite regroupée au sein d une archive WAR (Web application ARchive). C est ensuite cette archive WAR qui est déployée dans un serveur d application, tel que Apache Tomcat ou Oracle Glassfish [77]

78 15.1. JSP Java Server Pages Une page JSP permet de mélanger des informations de présentation en HTML avec des informations qui doivent être traitées du côté serveur sous la forme de tag JSP. Ce sont donc des pages dont la syntaxe et le fonctionnement sont proches de PHP. Bien que l utilisation de pages JSP soit relativement simples, elles sont maintenant rarement utilisées pour le développement d applications complètes, car la présentation et le comportement ne sont pas clairement séparés, ce qui entraine des difficultés de maintenance lorsque la taille du projet devient importante. Exemple de page JSP <%@3page3import="java.util.Date"%>3 <html>3 <body>3 Date3du3jour3:3<%=3new3Date()3%>3 </body>3 </html> Une page JSP est compilée en un Servlet (donc en un fichier *.class) par le serveur d application. Donc, bien que la syntaxe puisse paraître similaire à PHP, une JSP n est pas interprétée par le serveur comme c est le cas pour PHP, mais elle est compilée JSF Java Server Faces Il s agit du framewok RIA fournit en standard par JEE. A partir de la version 2.0, JSF Une application JSF comprend les éléments suivants : - un ensemble de pages web, dans lesquelles les composants seront disposés - un ensemble de tags pour ajouter les composants dans les pages - un enesmble de «managed beans» qui sont des objets java gérés par le conteneur. - un descripteur de déploiement «web.xml» - un fichier de configuration des ressources de l application «faces-config.xml». Ce fichier définit les règles de navigation et configure les «managed beans» - facultativement un ensemble d objets créés par le développeur : des composants spécifiques, des validateurs, des convertisseurs (Converters), des Listeners, etc. - facultativement, des tags créés par le développeur Lors d une requête http par le navigateur du client, le serveur retourne une «vue» HTML. Le processus de rendu est le fait de généner la vue HTML. L un des avantages de JSF est d offrir une séparation claire entre la présentation et la logique métier. Cela permet une séparation claire des différents rôles des développeurs dans l équipe de projet [78]

79 15.1. Vaadin Il s agit d un framework basé sur GWT (Google Web Toolkit) qui permet de construire des interfaces utilisateurs graphique pour le web, de la même manière que l on construit un client lourd avec Swing. Le framework se chargeant de générer du code HTML/CSS/JS à afficher dans le navigateur. Il s agit d un framework de RIA (Rich Internet Application), les applications RIA sont généralement des applications «single page» Technologies natives Il est bien entendu possible de réaliser entièrement une interface utilisateur graphique avec les technologies bien connue du Web HTML/CSS/JS. On réalisera alors des requêtes Ajax (par exemple à l aide de Jquery) pour interagir avec la partie serveur via des webservices Soap ou Rest. Les données échangées alors entre le client (le navigateur du client exécutant le javascript Jquery) et le serveur (webservices Soap ou Rest) sont alors sérialisées sous forme de XML ou de JSON [79]