Initiation Java by Driss Essaadi

1040 - INITIATION AU LANGAGE JAVA 1.

INTRODUCTION 1.1. Progression hardware/software 1.2. Composants reels 1.3. Composants logiciels 1.4. Classe et objet 1.5. UML

INTRODUCTION JAVA 2.1. Historique 2.2. Comparaison Java/C++ 2.3. Fonctionnement de JAVA 2.4. JVM 2.5. JRE/JDK 2.6. Le célèbre HelloWorld

CONCEPT OBJETS 3.1. Instanciation 3.2. Encapsulation 3.3. Aggrégation 3.4. Composition 3.5. Héritage 3.6. Classe abstraite/concrete 3.7. Polymorphisme

DEFINITION DE CLASSE, ATTRIBUT, METHODE 4.1. Convention de nommage UML/Java 4.2. Syntaxe de definition de classe 4.3. Déclaration, initialization dʼattributs, de variables locales, de constantes 4.4. Types de bases 4.5. Impressions sur console 4.6. Conversion/initialisation des variables numériques 4.7. Méthodes, heritages, redefinition, surcharge

STRUCTURES DE BASES 5.1. Opérateurs dʼassignement 5.2. Opérateurs conditionnels 5.3. Structures alternatives 5.4. Boucles 5.5. Commentaires et Javadoc

CYCLE DE VIE DʼUN OBJET 6.1. Instanciation 6.2. Constructeur 6.3. Garbage collector 7. LES CLASSES CHAINES DE CARACTERE

7.1. 7.2. 8.

String StringBuffer

METHODES ET ATTRIBUTS STATIQUES 8.1. Attributs statiques 8.2. Constantes 8.3. Méthodes statiques 8.4. La méthode main PREMIER LABO: JEU DE HASARD

10. LES TABLEAUX 10.1. Spécification 10.2. Déclaration 10.3. Création 10.4. Initialisation/Affectation 10.5. Longueur des tableaux 10.6. Utilisation 11. DEUXIEME LABO: JEU DE HASARD ET TABLEAUX 12. LES PACKAGES 12.1. Utilité 12.2. Les packages de SUN 12.3. ”Packager” une classe 12.4. Importation de packages 12.5. Comprendre le processus de localisation des classes 13. L HERITAGE 13.1. Rappel 13.2. Le polymorphisme 13.3. Redéfinir une méthode 13.4. Etendre une méthode 13.5. Empecher la redefinition 13.6. Les constructeurs 13.7. Les methodes polymorphes 13.8. Les classes/methodes abstraites 14. LES INTERFACES 14.1. Lʼhéritage multiple 14.2. Définition 14.3. Polymorphisme 14.4. Les constants 14.5. Instanceof 15. LA CLASSE OBJET 15.1. Definition 15.2. La méthode equals

15.3. La méthode toString 16. KIOSQUE 1: PACKAGE & HERITAGE 17. KIOSQUE : AGGREAGATION 18. LES WRAPPERS 18.1. Definition 18.2. Instanciation 18.3. Convertir vers les types de base 18.4. Méthode statiques 19. LES COLLECTIONS 19.1. Definition – Interfaces Set, List, Map 19.2. Utilisation dʼun Set 19.3. Utilisation dʼune List 19.4. Utilisation dʼun Map 19.5. Iterator 19.6. Cas special 20. KIOSQUE : LES COLLECTIONS

CHAPITRE 1 - INTRODUCTION 1.1 - Progression hardware/software Le matériel informatique progresse plus vite que les logicielles... pourquoi? Parce que les concepteurs de matériel se basent toujours sur les composants de la génération précédente (disque dur, processeur, etc...) pour en créer de plus performants. Pourquoi ne pas faire de même avec les logiciels? Il suffit de décomposer le système en plusieurs "composants spécialisés"... 1.2 - Composants réels Sur base d'un même plan architectural, on peut construire deux maisons similaires, avec certains détails différents (couleur, taille fenêtre, etc..). Cela est possible car une maison est composée de différents éléments (briques, fenêtres,etc..) qui peuvent être agencés différemment. 1.3 - Composants logiciels La programmation orientée objet consiste à modéliser informatiquement un ensemble d'éléments d'une partie du monde réel (que l'on appelle domaine) en un ensemble d'entités informatiques. Ces entités informatiques sont appelés "objets". Il s'agit de données informatiques regroupant les principales caractéristiques des éléments du monde réel (taille, la couleur,...) L'approche objet est une idée qui a désormais fait ses preuves. Simula a été le

premier langage de programmation à implémenter le concept de classes en 1967! En 1976, Smaltalk implémente les concepts d'"encapsulation", d'"agrégation", et d'"héritage" (les principaux concepts de l'approche objet). D'autre part, de nombreux langages orientés objets ont été mis au point dans un but universitaire (Eiffel, Objective C, Loops...). La difficulté de cette modélisation consiste à créer une représentation abstraite, sous forme d'objets, d'entités ayant une existence matérielle (chien, voiture, ampoule, ...) ou bien virtuelle (sécurité sociale, temps, ...). Un objet est caractérisé par plusieurs notions: - Les attributs: Il s'agit des données caractérisant l'objet. Ce sont des variables stockant des informations d'état de l'objet. - Les méthodes (appelées parfois fonctions membres): Les méthodes d'un objet caractérisent son comportement, càd l'ensemble des actions (appelées opérations) que l'objet est à même de réaliser. Ces opérations permettent de faire réagir l'objet aux sollicitations extérieurs (ou d'agir sur les autres objets). De plus, les opérations sont étroitement liées aux attributs, car leurs actions peuvent dépendre des valeurs des attributs, ou bien les modifier. - L'identité: L'objet possède une identité, qui permet de le distinguer des autres objets, indépendamment de son état. On construit généralement cette identité grâce à un identifiant découlant naturellement du problème (par exemple un produit pourra être repéré par un code, une voiture par un numéro de série,...) En analogie avec un langage procédural, on pourrait considérer un objet comme étant une structure (un ensemble d'attributs) avec en plus des fonctions. Selon le même principe, on peut créer des applications composées de composants logiciels: les "objets". Ces éléments sont constitués de 3 parties: des "attributs": des données caractérisant l'objet, variables caractérisant l'objet des "méthodes": ensemble des actions que l'objet est à même de réaliser une "identité": un objet possède des attributs qui lui permettent d'être distingué des autres objets 1.4 - Classe et objet On appelle classe la structure d'un objet, càd la déclaration de l'ensemble des entités qui composeront un objet. Un objet est donc "issu" d'une classe, c'est le produit qui sort d'un moule. En réalité on dit qu'un objet est une "instanciation" d'une classe, c'est la raison pour laquelle on pourra parler indifféremment d'objet ou d'instance ou occurrence. Une classe est composée de deux parties: Les attributs (parfois appelés membres): il s'agit des données représentant l'état des objets. Le méthodes : il s'agit des opérations applicables aux objets Si on définit la classe voiture, les objets Peugeot 406, Renault 18 seront des instances de cette classe; Il pourra éventuellement exister plusieurs objets Peugeot 406 différenciés par leur numéro de série. Mieux: deux instanciations de classes pourront avoir tous leurs attributs égaux sans pour autant être un seul et même objet. C'est le cas dans le monde réel, deux T-shirt pevent être strictement identique et pourtant ils sont distincts. D'ailleurs en les mélangeant, il serait impossible de les

distinguer... Les objets sont physiquement créés en mémoire sur base d'une définition, la Classe. Ce mécanisme est nommé "instanciation" Les Objets/Instances : - occupent chacun un espace mémoire - connaissent leur classe - possèdent des valeurs pour chaque attributs Une Classe: est la définition des objets occupe un espace unique en mémoire 1.5 - UML UML (Unified Modeling Language, que l'on peut traduire par "langage de modélisation unifié) est une notation permettant de modéliser un problème de façon standard. Ce langage est né de la fusion de plusieurs méthodes existant auparavant, et est devenu désormais la référence en terme de modélisation objet. La notion objet La programmation orienté objet consiste à modéliser informatiquement un ensemble d'éléments d'une partie du monde réel (que l'on appelle domaine) en un ensemble d'entités informatiques. Ces entités informatiques sont appelées objets. Il s'agit de données informatiques regroupant les principales caractéristiques des éléments du monde réel (taille, couleur,..). La difficulté de cette modélisation consiste à créer une représentation abstraite, sous forme d'objets, d'entités ayant une existence matérielle (chien, voiture,...) ou bien virtuelle (sécurité social, temps,..) Les méthodes objets La modélisation objet consiste à créer une représentation informatique des éléments du monde réel auxquels on s'intéresse, sans se préoccuper de l'implémentation, ce qui signifie indépendamment d'un langage de programmation. Il s'agit donc de déterminer les objets présents et d'isoler leurs données et les fonctions qui les utilisent. Pour cela des méthodes ont été mises au point. Entre 1970 et 1990, de nombreux analistes ont mis au point des approches orientés objets, si bien qu'en 1994 il existait plus de 50 méthodes objet. Toutefois seule 3 méthodes ont véritablement émergées: la méthode OMT de Rumbaugh, la méthode BOOCH'93 de Booch, et la méthode OOSE de Jacobson (Objet Oriented Software Engineering). A partir de 1994, ils ont unis leurs efforts pour mettre au point UML (Unified Modeling Language), incorporant les avantages de chacune des méthodes précédentes. En résumé UML est : une notation universelle pouvant servir de support pour tout langage orienté objet un moyen de définir la structure d'un programme une représentation visuelle permettant la communication entre les acteurs d'un même projet une notation graphique simple, compréhensible même par des non informaticiens constitués de "9 diagrammes" un standard de l'industrie du logiciel reconnu par l'OMG (Object Management Group)

CHAPITRE 2 - INTRODUCTION JAVA 2.1 - Historique Java est un langage objet ressemblant au langage C++. Il a été mis au point en 1991 par la firme Sun Microsystem. Le but de Java à l'époque était de constituer un langage de programmation pouvant être intégré des appareils électroménagers, afin de pouvoir les contrôler, de les rendre intéractifs, et surtout de permettre une communication entre les appareils. Ce programme développement se situait dans un projet appelé Green, visant à créer une télécommande universelle (Star 7) comprenant un OS capable de gérer l'ensemble des appareils électroménagers de la maison. Etant donné que le langage C++ comportait trop de difficulté, James Gosling, un des acteurs du projet (considéré comme le père du Java) décida de créer un langage orienté objet reprenant des caractéristiques principales du C++, en éléminant ses points difficiles, et en le rendant moins encombrant et plus portable (il devait pouvoir intégré n'importe quel appareil..) Ainsi ce langage fut baptisé dans un premier temps Oak (Oak signifiant chêne). Toutefois, puisque ce nom était déjà utilisé, il fut rebaptisé Java en l'honneur de la boisson préférée des développeurs, càd le café, dans la production provient de l'île de Java. A la même époque, le Web faisait son apparition, or Java possèdait toutes les caractéristiques faisant de lui un langage approprié pour le Web: Le réseau des réseaux rassemblant sur une même structure des machines différentes, il fallait un langage capable de fonctionner sur chacune d'entre-elles: Java était conçu pour être portable. Le web était limité en bande passante: Java était conçu pour être petit. 2.2 - Comparaison Java/C++ Java est très proche du langage C++ étant donné qu'il a quasiment la même syntaxe. Toutefois Java est plus simple que le langage C++ bien qu'il s'en inspire, car les caractéristiques critiques du langage C++ (celles qui sont à l'origine des principales erreurs) ont été supprimées. Cela comprend: Les pointeurs La surcharge d'opérateurs L'héritage multiple La libération de mémoire est transparente pour l'utilisateur (il n'est plus nécessaire de créer des destructeurs) Une meilleur gestion des erreurs Les chaines et les tableaux sont désormais des objets faisant partie intégrante du langage Toutefois Java est beaucoup moins rapide que C++ il perd en rapidité ce qu'il gagne en portabilité.. Java est plus simple que C++, car les principales difficultés ont été éliminées: Les pointeurs, La surcharge d'opérateur, L'héritage multiple, Pas de gestion de mémoire. Néanmoins Java est un petit peu plus lent car interprété... 2.3 - Fonctionnement de JAVA Un programme Java doit être : compilé: le résultat est un nouveau fichier au format "ByteCode"

interprété: grace à une JVM (Java Virtual Machine) Remarques : Le fichier source d'un programme écrit en Java est un fichier simple texte dont l'extension est par convention ".java" Ce fichier source doit etre un fichier texte non formatté, càd un fichier texte dans sa plus simple expression, sans mise en forme particulière ou caractères spéciaux, càd qu'il contient uniquement les caractères ASCII ou EBCDIC de base. Lorsque le programme est prêt à être essayé, il s'agit de "compiler" (le traduire en langage machine) à l'aide d'un compilateur). Toutefois, contrairement aux langages compilés traditionnels, pour lesquels le compilateur créer un fichier binaire directement exécutable par un processeur données), le langage Java est compilé en un langage intermédiaire (appelé bytecode) dans un fichier portant le même nom que le fichier source à l'exception de son extension ".class" Cette caractéristique est majeure, car c'est elle qui fait qu'un programme écrit en Java est portable, càd qu'il ne dépend pas d'une plate-forme donnée. En réalité le code intermédiaire n'est exécutable sur aucune plate-forme sans la présence d'une machine virtuelle, un interpréteur (la machine virtuelle est d'ailleurs parfois appelée interpréteur Java) tournant sur une plate-forme donnée, et capable d'interpréter le code intermédiaire. 2.4 - JVM Pour peu qu'une plate-forme (Win, Unix, Linux,..) possède une JVM fonctionnant sur son système, celle-ci est capable d'éxécuter n'importe quelle application Java! 2.5 - JRE/JDK Le JRE (Java Runtime Environment) est: un fichier permettant d'interpréter des applications Java. plusieurs centaines de classes (API) Le JDK (Java Development Kit) est un complément vous permettant de les créer, déboguer, et documenter) On les trouve sur le site web de Sun microsystem en différentes déclinaisons et versions: - J2SE: les outils et APIs essentielles pour créer une application - J2EE: les bases pour un développement d'applications multi-tiers - J2ME: plus particulièrement destiné aux téléphones portables, Palm, etc... Remarques: Pour installer le JDK (ou SDK = Software Developement Kit), il vous faut récupérer la version adéquate Installer le avec la diocumentation si nécessaire ou pas, Configurer le $PATH ou Control-panel -> System -> Advanced -> Environment-Variables. 2.6 - Le célèbre HelloWorld Java est un langage case-sensitive, il vous faut donc être attentif. Vous pouvez aéré votre code comme vous le souhaitez, n'oubliez pas le ";" Le compilateur JAVAC est très strict, il existe un controle de typage fort, et dans certains cas, il imposera une gestion des erreurs dans votre code. Le programme HelloWorld: public class Hello {

public static void main(String args[]) { System.out.println(" Hello World "); } } Compilé -> javac Hello.java (création alors de Hello.class) Interprétez -> java Hello Notes: Un objet est une instanciation d'une classe

CHAPITRE 3 - CONCEPT OBJETS 3.1 - Instanciation C'est le fait de créer un objet à partir d'une classe - Déclaration : La déclaration permet d'indiquer à la JVM quelle classe devra être chargée en mémoire, afin de créer ultérieurement un nouvel objet. La déclaration est donc très importante car, sans elle, il n'est pas possible de référencer un objet. Le mécanisme dans la JVM de chargement est lié à une classe: le "ClassLoader" La déclaration indique à Java que la variable toi contiendra utlérieurement une adresse mémoire pointant sur un objet de type Personne. - Création : Lorsqu'une nouvelle instance de classe (objet) est crée, l'espace mémoire est alloué pour contenir toutes les variables déclarées dans la classe. S'il n'y a pas suffisamment d'espace disponible pour l'allocation mémoire de l'objet, alors la création de l'instance s'arrête brusquement avec une erreur "OutOfMemoryError". Si la création réussie, chaque variable est créée et est initialisée avec une valeur par défaut. - Affectation: C'est le fait de placer l'adresse mémoire de l'instance crée dans la variable receptrice. Au moment de l'affectation, Java vérifie que la variable est bien du type nécessaire: la JVM autorise donc, ou pas l'affectation. La JVM vérifie si la définition de la classe référencée par la variable correspond bien à l'ensemeble des méthodes et attributs contenues par l'objet, et que la class déclarée se trouve dans la même hiérarchie que l'objet. 3.2 - Encapsulation Un objet peut contenir des attributs qu'il est possible de consulter/modifier. On conseillera donc plutot l'utilisation de fonctions, et pour empecher l'utilisation directe des attributs, on utilisera les critères de visibilité. +public et -private private : seule la classe à accès à la ressource public : toutes les classes ont accès à la ressource En général les attributs sont "private" (sauf les constantes) et les méthodes sont public Note: A 99% private pour les attributs. 3.3 - Aggrégation Un objet peut avoir des attributs: des primitives ou d'autres objets. L'aggrégation, c'est le fait qu'un objet en contienne d'autre(s): l'objet contenant peut

utiliser les attributs et les méthodes publiques de l'objet contenu. Par exemple un Gobelet peut contenir 2 attributs de type Dé. class Gobelet{ private De de1=new De(); private De de2=new De(); public int getValeur() { return de1.getValeur() + de2.getValeur(); } } Dans un diagramme de classe, on représente une association entre 2 classes par une ligne. Les 3 associations sont : - L'association simple: les 2 objets collaborent ensemble, sans pour autant que la relation soit permanente. L'association simple est bi-directionnelle. - L'association d'aggrégation: la relation n'est pas nécessairement permanente, mais est uni-directionnelle. - L'association de composition: la relation est permanente, bi-directionnelle. Notes: Un objet contient d'autres objet. 3.4 - Composition La composition est une aggrégation très forte: l'objet contenant doit posséder l'objet contenu, et l'objet contenu doit être contenu dans l'objet contenant. Par un exemple un Corps Humain doit contenir un Cerveau. class CorpsHumain{ private Jambe jambes; private Cerveau cerveau = new Cerveau(); class Cerveau{ private Neurone neurone; public void reflechir() {jambes.bouger();} } public void marcher() {cerveau.reflechir();} } La durée de vie des 2 objets est lié. Si l'objet CorpsHumain est détruit, le Cerveau le sera de même automatiquement. Le Cerveau n'est pas viable tout seul. En plus du principe d'aggrégation, l'objet contenu (Le Cerveau) a accès aux ressources de l'objet contenant. Notes : Class imbriqué; le contenu a accès à tout private et public de celui qui le contient le contenant Le contenant n'a accès qu'au public du contenu. 3.5 - Héritage La classe dérivée reçoit tous les attributs et méthodes de la classe de base, avec leur règle de visibilité; ainsi si un attribut ancêtre est private, il ne sera toutefois pas accessible directement pour le descendant (private=seule la classe à accès à la ressource), il lui faudra utiliser la méthode d'accéssibilité (nous verrons un autre critère de visibilité "protected", qui permet d'éviter ce problème.)

La Généralisation est le fait de retrouver les ancêtres à partir des descendants La Spécialisation est le fait de retrouver les descendants à partir des ancêtres. L'héritage permet de créer une nouvelle classe à partir d'une existante. La nouvelle classe contient tous les attributs et méthodes de la classe de base, et peut rajouter des nouveaux attributs, rajouter/modifier des méthodes. Par exemple, un employé est une personne class Personne { private String nom; public String getNom() { return nom; } } class Employe extends Personne{ private int salaire; public void travailler() { System.out.println(getNom()+salaire); //ok System.out.println(nom+salaire); //Erreur } } Notes : Comme vu au Chapitre 2 il n'y a pas d'héritage multiple en Java contrairement au C++. 3.6 - Classe Abstraite/Concrète Une classe abstraite est une classe qui ne sera JAMAIS instanciée, elle sert uniquement de base à la définition d'autres classes qui seront abstraites ou concrètes. class abstract Personne En UML, l'identification est en italique ou on écrit Abstract. 3.7 - Polymorphisme Deux voitures: une Ferrari, une 2CV. Les deux voitures ont une pédale d'accélérateur. On utilise cette interface pour accélérer. Nous n'avons pas besoin de savoir comment l'accélération se produit, ce qui se passe derrière cette action... on accèle, c'est tout. Néanmoins, les 2 voitures ont un fonctionnement tout à fait différent: le fait d'accélérer sur une 2CV est un acte purement mécanique, alors que dans le cas d'une Ferrari, une partie électronique se trouve dans l'exécution du processus. Le polymorphisme signifie: - Que le même message peut être interprété de différentes façons, selon l'objet récepteur. - Que des méthodes portant le même nom peuvent être définies dans différentes classes. Polymorphisme = interface identique, implémentation différente.

CHAPITRE 4 - DEFINITION DE CLASSE, ATTRIBUTS, METHODE 4.1 - Convention de nommage UML/Java

Pour éviter les confusions, on respectera la convention de nommage. Entièrement majuscule : Constante Premier mot commence par une majuscule : Classe Chaque mot après l'initial comme par une majuscule (PersonneAdult) : Classe, Attribut, Méthode Finit par des paranthèses: Méthode En minuscule: Classe, Attribut, Méthode Caractères autorisés: A-Z, a-z, 0-9(mais pas en première position), "$" et "_" Pas de mots réservés: if, then, 1er 4.2 - Syntaxe de définition de classe Tout code java doit se trouver dans une classe. Hormis les définitions de classe, de méthode, et de boucle, toute instruction se finit par ";". Le corps d'une classe est délimité par un bloc (les accolades {} ) Le fichier Java (.java): - doit porter le nom (majuscule/minuscule) de l'unique classe (publique) qu'il contient. - peut contenir d'autres classes non-publiques. Remarques: - Ce sont les accolades qui délimitent la portée de la classe. - Il est possible de créer des classes publiques, et non publiques: la différence est importante, nous l'a verrons dans l'unité liée aux packages. - Si on crée une classe dans un fichier, ce fichier doit porter exactement le même nom que la classe: le cas échéant, le compilateur refusera de compiler le fichier, en apportant biensur un justificatif de son refus. - Si on crée plusieurs classes dans un même fichier, c'est lʼunique classe définie avec le mot réservé "public" qui donnera le nom du fichier. 4.3 - Déclaration, initialisation d'attributs, de variables locales, de constantes Le bloc délimité par les accolades définit la portée des variables. Remarques: - Ce sont les accolades qui délimitent la portée de la classe. - Un attribut sera "accessible" durant toute la durée de vie de l'objet dans lequel il se trouve. - Un attribut PEUT être initialisé avant d'être utilisé. - On indiquera un critère de visibilité pour les attributs: on selectionnera en général "private" - Une variable locale n'a d'existence que durant, l'exécution de la méthode/bloc dans laquelle elle se trouve. - Une variable locale ne peut recevoir de critères de visibilité (private,public,...): elle est de toute façon accessible uniquement dans le bloc dans laquelle elle est définie. - Une variable locale DOIT être initialisée avant d'être utilisée, un attribut reçoit une initialisation par défaut. 4.4 - Type de bases Chaque variable DOIT être d'un type donné. Un type de donnée détermine l'intervalle de valeur susceptible d'être contenue. Dans les entiers, le type "int" est le type par défaut, pour les décimaux c'est le type

"double". ATTENTION!! Les types de base sont en minuscule. A ne pas confondre avec les "Wrappers" (classe ayant le même nom que les types de base): Ex: byte vs Byte Entier: byte: 8 bits signés short: 16 bits signés int: 32 bits signés long: 64 bits signés Decimal: float: 32 bits signés double: 64 bits signés Autre: char: 16 bits UNICODE2 boolean: 1 bit, 2 valeurs possibles true or false Le type numérique entier par défaut est "int". Cela signifie qu'à chaque fois qu'on se sert d'un littéral numérique entier pour initialiser une variable, Java réserve un "int" en mémoire, dans lequel il place l'information, puis se sert de cette zone pour affecter la variable destination: il faut bien sur qu'il n'y ait pas de risque de perte d'information: le cas échéant il y a erreur de compilation. Dans le cas d'un long en destination, cela ne fonctionne que si le littéral ne dépasse pas la valeur maximale d'un "int". Pour éviter ce problème, et réserver directement une zone mémoire de 64 bits, on utilisera la lettre L ou l. Si l'information numérique entière dépasse la limite du type de réception, il y a erreur de compilation, car certitude de perte d'informations. On décharge le compilateur de ce controle en indiquant, le type de reception entre paranthèse, à gauche du littéral qui est à affecter: l'affectation s'effectuera sans remarque du compilateur, MAIS évidemment, il y aura perte d'information... celà devient la responsabilité du programmeur!! (Notes : c'est du CAST) - Type char Java est un langage portable d'une plate-forme à une autre, mais aussi d'un langage à un autre. Le format ASCII (max 256 caractères) ne permet pas de gérer las autres alphabets disponibles à travers le monde (Japonais, Chinois, Russe...): à titre d'information, les Chinois utilisent 3000 symboles courants! Java utilise le format UNICODE2, pouvant gérer jusqu'à 65535 caractères. Ce n'est pas parce que vous allez utiliser un code Japonais que ce symbole s'affichera automatiquement dans votre application: pour cela, il vous faudra importer un JAR file (fichier Java ARchive), contenant les fonts, et effectuer des manipulations supplémentaires. Les char sont au format UNICODE2, pas ASCII. UNICODE2 : 16 bit ; ASCII : 8 bit. ATTENTION!! char autorise 1 caractère pour une chaine de caractères, on utilisera la classe String, "". 4.5 - Impressions sur console System.out.println("Bonjour\nVous") System.out.print("Bonjour\nToi") 4.6 - Conversion/initialisation des variables numériques - Les constantes

Pour définir une constante, il vous suffit de rajouter "final" à la déclaration de l'attribut. On n'oubliera pas d'utiliser la convention de nommage! public final int MAX = 10; int variable = MAX; // ok MAX = 5; //erreur - Initialisation des attributs Les attributs reçoivent une initialiation par défaut Types numériques : 0 char: "\u0000" boolean: false Objet: null Les variables locales nécessitent une initialisation explicite avant usage. 4.7 - Méthodes, héritage, redéfinition, surcharge - Les méthodes: Il est possible d'avoir plusieurs méthodes dans une même classe qui aient le même nom; il faut néanmoins que le nombre et/ou le type de paramètres soient différents. Le mot return permet de renvoyer une valeur à l'instruction ayant appelé la méthode; ce mot doit obligatoirement être la dernière instruction appelée. Le type void est un type "rien du tout"; il est obligatoire pour indiquer à Java que la méthode ne renvoit rien... Les paramètres sont des variables locales: elles ne peuvent être utilisée en dehors des méthodes. Une méthode Java a un nom, une valeur de retour, d'éventuels paramètres. - Héritage de méthode: Les méthodes peuvent être redéfinies dans les descendants si on les crée avec la même signature que dans l'ancêtre. Une méthode peut remplacer ou étendre les fonctionnalités de son ancêtre. Pour étendre les fonctionnalités, on utilisera le mot réservé "super". suivi de la méthode que l'on souhaite exécuter avant/après le code de la méthode descendante. Lors de l'héritage, les descendants héritent des méthodes de leur ancêtre: ces méthodes peuvent être redéfinies ou étendues. - Non redéfinition de méthodes: le mot réservé "final" indique au compilateur que cette méthode ne pourra être étendue/redéfinie dans une classe descendante. Pour empêcher la redéfinition de méthode dans les descendants, on utilisera le mot réservé "final":

CHAPITRE 5 - STRUCTURE DE BASES 5.1 - Opérateurs d'assignements op1 += op2 op1 = op1 + op2 Addition op1 -= op2 op1 = op1 - op2 Soustraction op1 *= op2 op1 = op1 * op2Multiplication op1 /= op2 op1 = op1 / op2 Division op1 %= op2 op1 = op1 % op2 Modulo op1 &= op2 op1 = op1 & op2 AND binaire

op1 |= op2 op1 = op1 | op2 OR binaire op1 ^= op2 op1 = op1 ^ op2 XOR binaire op1 <<= op2 op1 = op1 << op2 Décalage signé vers la gauche op1 >>= op2 op1 = op1 >> op2 Décalage signé vers la droite op1 >>>= op2 op1 = op1 >>> op2 Décalage non signé vers la gauche Incrémentation/Décrémentation en préfixe/suffixe: int i = 3, j=4; ++i; i++; // égal à i = i + 1, soit 4 --i; i--; // égal à i = i -1, soit 3 j=i++; // (i=4,j=3: on copie le contenu de i dans j, puis on incrémente i j=++i; //(i=5,j=5: on incrémente i, puis on copie le contenu de i dans j. Exemple : i = 3 ; j=4 ; int k = --j * i ++ <-----> i = 4 , j=3 , k=9 5.2 - Opérateurs conditionnels > op1 > op2 >= op1 >= op2 < op1 < op2 <= op1 <= op2 == op1 == op2 != op1 != op2 && op1 && op2 éventuel. || op1 || op2 éventuel. ! !op1 & op1 & op2 2. | op1 | op2 2. ^ op1 ^ op2 true, celà retourn false. (XOR)

op1 est strictement supérieur à op2 op1 est supérieur ou égal à op2 op1 est strictement inférieur à op2 op1 est inférieur ou égal à op2 op1 est égal à op2 op1 est différent de op2 op1 et op2 sont égal à true. Evaluation de op2 op1 et op2 sont égal à true. Evaluation de op2 op1 est false op1 et op2 sont égal à true. Toujours evaluation des op1 et op2 sont égal à true. Toujours evaluation des op1 et op2 sont égal à true. Si les deux sont égals à

5.3 - Structures alternatives - if...else... ; l'élément conditionnel doit ramener true ou false boolean b=false; if (b=true) System.out.println("bonjour"); else System.out.println("au revoir"); - L'instruction switch int i=3; switch (i) // Uniquement int, char, byte, short { case 1: System.out.println("un"); break; case 2: case 3: System.out.println("deux ou trois");

break; case MAX: System.out.println("maximum"); default: System.out.println("les autres cas"); } 5.4 - Boucles - while et do...while La principale différence est que dans un do...while il passe les instructions une fois au moins avant la condition. - For for (int i=0 ; i<10 ; i++) // (index ; tant que la condition retourne true; incrémentation) - continue et break 5.5 - Commentaires Il y a 3 types de commentaires: simple ligne, bloc, Javadoc Simple : // Simple ligne Bloc : /* */ Javadoc: destiné à générer automatiquement une documentation sur votre code sous DOS : javadoc.exe Test.java Commentaire javadoc: avant une méthode c'est un commentaire de méthode, avant un attribut c'est un commentaire d'attribut, avant une classe c'est un commentaire de classe.

CHAPITRE 6 - CYCLE DE VIE D'UN OBJET 6.1 - Instanciation L'instanciation est le fait de créer un objet (new) qui sera utilisé via une référence. Le "Verifier" est une tâche chargé, au sein de la JVM, de vérifier que la classe qui va être chargé contient un byte code valide. Le but principal de ce vérificateur est de s'assurer, avant l'exécution, que le code satisfait un certain nombre de conditions, pour des raisons de sécurité. Une des spécificités particulièrement innovante de Java est l'utilisation d'un "Class Loader": un mécanisme particulier qui s'occupe de charger dans la machine virtuelle les différentes classes au fur et à mesure des besoins. En effet, Java est un langage paresseux. Contrairement au C++ par exemple, Java ne charge en mémoire que les classes utiles à un moment donné. Lorsqu'une classe est nécessaire, elle est demandée à un class loader. Celui-ci doit charger et installer la classe en mémoire. Le "Security Manager", lors de l'exécution, veille sur la sécurité du système et limite la liberté d'une application Java. Cette technologie fait en sorte qu'une barrière de sécurité est placée autour de l'application Java, barrière formant une frontière entre l'application et les données privées. En Anglais on parle de "security sandbox". Ainsi un Java Applet peut par exemple uniquement installer une communication de réseau vers le serveur duquel il provient et il ne peut pas être lu en même temps sur le disque dur local, ceci pour éviter qu'on envoit des données personnelles sur le serveur.

6.2 - Constructeur class De { private int valeurFaciale; public int getValeurFaciale() { return valeurFaciale; } public void initValeurFaciale() { valeurFaciale=5; } } .... De d = new De(); // d.initValeurFaciale(); int r = d.getValeurFaciale(); // r=0 Un constructeur est une méthode qui s'exécute automatiquement obligatoirement et uniquement lorsqu'on instancie un objet. Un constructeur: - a le même nom que la classe - n'a pas de valeur de retour (même pas void!) class De { private int valeurFaciale; public De() { this.initValeurFaciale(); } public int getValeurFaciale() { return valeurFaciale; } public void initValeurFaciale() { valeurFaciale=5; } } De d = new De(); // invocation du constructeur int r = d.getValeurFaciale(); // r=5 Une classe a toujours au moins un constructeur. Si on n'en définit pas, le compilateur en rajoute un pour nous, dans le byte code: il ne fera "rien", mais existera; on l'appelle le constructeur par défaut. Une classe peut contenir plusieurs constructeurs. class De { private int valeurFaciale; public De() { this.initValeurFaciale(); } public De(int valeurFaciale) { this.ValeurFaciale=ValeurFaciale; } public int getValeurFaciale()

{ return valeurFaciale; } public void initValeurFaciale() { valeurFaciale=5; } } De d= new De(); De d1= new De(3); int r=d.getValeurFaciale(); // r=5 int r1=d1.getValeurFaciale(); // r1=3 De d2= new De(7); int r2=d2.getValeurFaciale(); // r2=7 De d3= new De("7"); int r3=d3.getValeurFaciale(); // Erreur de compilation, pas de String attendue en param. Un constructeur peut en appeler un autre. class De { private int valeurFaciale; public De() { this.(4); } public De(int valeurFaciale) { this.ValeurFaciale=ValeurFaciale; } } 6.3 - Garbage Collector Le Garbage Collector est une tâche chargée de "supprimer" de la mémoire les objets non-référençables. Le compteur interne sert au Garbage Collector (début de mémoire pour les objets 0 ou 1 ou 2 dépend du nombre d'objet qui pointent).

CHAPITRE 7 - LES CLASSES CHAINES DE CARACTERES 7.1 - String La classe String est la seule classe ne nécessitant pas de new pour l'instanciation. Un objet String ne peut pas être modifié. Un autre objet est instancié. 7.2 - StringBuffer La classe StringBuffer permet la modification.

CHAPITRE 8 - METHODES ET ATTRIBUTS STATIQUES 8.1 - Attributs statiques Un attribut statique est un attribut de classe et non d'objet. (si static c'est alors

souligné dans le diagramme UML). Chaque instance connaissant sa classe, l'attribut est partageable. Il est possible de les manipuler sans instanciation. 8.2 - Constantes Les constantes sont généralement définies statiques: ne changeant pas, elles ne nécessitent pas d'être multiples en mémoire. class Test { public static final int MAX=5; public final static double MIN=3.45; } 8.3 - Les méthodes statiques Tout comme les attributs statiques, les méthodes peuvent être de classe. Elles peuvent être utilisées sans instancier un objet. 8.4 - La méthode main La méthode main est le point d'entrée de l'application Avec "java Test", on indique à la JVM par ou commencer l'application. La JVM va charger la classe en mémoire, puis éxecuter la méthode main. public static void main(String args[])

CHAPITRE 9 - PREMIER LABO : JEU DE HASARD CHAPITRE 10 - LES TABLEAUX 10.1 - Spécification Les tableaux sont des objets, ils doivent donc être instanciés avec "new" La taille d'un tableau est fixée à sa création Les tableaux contiennent soit des primitives (int,char, boolean, etc...), soit des objets: le mélange n'est pas possible 10.2 - Déclaration Déclaration d'un tableau de int private int [] monTableau; private int monTableau2 []; Déclaration d'un tableau d'objets private Personne [] monTableauDObjet; private Personne monTableauDObjet2 []; 10.3 - Création Utiliser "new" et spécifier la taille avec les "[]". monTableau = new int[4]; // 4 est la taille du tableau monTableauDObjet = new Personne[5]; // 5 est la taille du tableau

10.4 - Initialisation/Affectation On référence les éléments dun tableau avec un indice commençant à 0 jusqu'à (taille - 1). monTableau[0] = 34; monTableau[1] = 27; int val = monTableau[0]; monTableauDObjet[3] = new Personne("Jean"); monTableauDObjet[5] = new Personne("Arthur"); <== ERREUR On peut cumuler création et initialisation monTableau = new int [] {2,78,34}; monTableau2 = {2,78,34}; Il n'est pas nécessaire de préciser "new". monTableauDObjet = new Personne[] {new Personne("Alfred"), new Personne("Arthur")}; monTableauDObjet2 = {new Personne("Alfred"), new Personne("Arthur")}; 10.5 - Longueur des tableaux "lenght" est un attribut public, uniquement en lecture, indiquant le nombre de "cases" du tableau. public String[] getNom( Personne[] personnes ) { String[] noms = new String [personnes.lenght]; for (int i = 0; i < personnes.lenght ; i++) { noms[i] = personnes[i].getNom(); } return noms; } 10.6 - Utilisation Initialisation: for (int i = 0; i < joueurs.lenght ; i++) joueurs[i] = new Joueur("Joueur"+ (i+1)); Appel des méthodes: for (int i = 0; i < args.length; i++) joueurs[i].aTonTour(); La méthode "main" reprend un tableau String comme paramètre qui récupère les valeurs reçues lors du démarrage. public class Test { public static void main(String args()) { for (int i=0; i < args.lenght ; i++) System.out.println("param : " + (i+1) + args[i]); } } java Test "hello vous" trois 2 param : 1 hello vous param : 2 trois param : 3 2

CHAPITRE 11 - DEUXIEME LABO : JEU DE HASARD ET TABLEAUX CHAPITRE 12 – LES PACKAGES 12.1 – Utilité La variable d environnement CLASSPATH permet a la JVM de retrouver les classes utilisees dans lʼapplication: des que la classe est trouvee, la recherche s interrompt. Que se passe t il si 2 classes ont le meme nom, qu elles se trouvent dans des repertoires differents, et qu on souhaite les utiliser dans la meme application? Que se passent ils si vous avez plusieurs centaines de classes? Java fournit le mecanisme de "package" pour organiser et gerer les classes et les interfaces (que nous verrons plus tard!) Definition: Un package est un ensemble de classes et d interfaces permettant d organiser les classes sous forme d unites plus vastes, et d eviter les problemes de conflits de noms. 12.2 – Les packages de Sun Sun fournit un ensemble de classes (plusieurs milliers) que vous pouvez utiliser dans vos applications. Ces classes sont organises dans des packages: java.lang java.io java.util java.net java.sql java.awt java.awt.event etc.... 12.3 - "Packager" une classe On peut creer ses propres packages, et mettre des classes dedans. package lu.cepl.jeuDeHasard; public class Depart { public static void main(String args[]) { System.out.println("Bonjour"); } } Il ne peut y avoir qu une seule instruction package par fichier. Cela doit etre la premiere instruction du fichier. Pour compiler, il faudra utiliser la commande d:\ 1041> javac –d. Depart.java le resultat est d:\1041\lu\cepl\jeuDeHasard\Depart.class CLASSPATH, CLASSPATH est une variable d environnement contenant un ensemble de "chemins" permettant à Java (compilateur, JVM) de retrouver les classes dont il a besoin. C\> set classpath=.;d\1041;e:\test C:\cepl> java Depart Lors de sa recherche de classe, il ira donc initialement dans le répertoire

C:\ cepl, puis le cas échéant dans d:\1041 et finalement (toujours le cas échéant) dans E:\test S'il ne trouve pas, il y aura erreur de compilation/interprétation. 12.4 - Importation de packages Si une classe se trouve dans un package, son nom change: il devient égal au nom du package suivi du nom de la classe! D:\>1041> java Depart <= Erreur la classe n'est pas connu D:\>1041> java lu.cepl.jeuDeHasard.Depart <= OK Dans le code aussi on utilisera le nom complet de la classe. class Objet { private lu.cepl.jeuDeHasard.De de1,de2; private java.util.Date maDate; public Gobelet() { de1 = new lu.cepl.jeuDeHasard.De(); de2 = new lu.cepl.jeuDeHasard.De(); maDate = new java.util.Date(); } } On peut utiliser le mot réservé "import" pour simplifier le code. Plusieurs imports sont possibles. package monPackage; import lu.cepl.jeuDeHasard.De; import java.util.Date; Si plusieurs classes se trouvent dans le même package, on peut utiliser *. package monPackage; import java.util.*; Si plusieurs classes (se trouvant dans des packages différents) ont le même nom, il y aura des risques de conflit. import java.util.*; import java.sql.*; class Gobelet { private Date maDate; // java.util.Date ou java.sql.Date : erreur compilation private java.sql.Date maDate2; // ok } Certains packages sont automatiquement accessibles. java.lang le package courant (toutes les classes dans ce répertoire.) 12.5 - Comprendre le processus de localisation des classes... - Les fichiers Java Archive (JAR) Pour éviter de déployer, plusieurs centaines de classes, il est possible de stocker les classes dans un fichier JAR.

> Avec Winzip (en changeant l'extension .zip en .jar) > avec jar.exe du JDK En modifiant CLASSPATH, les classes seront ainsi accessibles. C:\> set classpath=.;d:\1041;a:\test\cepl.jar - La visibilité de package > On peut déclarer une classe avec le mot réservé "public", ou pas > Avec public, la classe sera accessible en dehors du package. > Il y a un cas équivalent pour les méthodes/attributs (à voir plus tard!)

CHAPITRE 13 - L'HERITAGE 13.1 - Rappel L'héritage permet de créer une nouvelle classe à partir d'une existante. La nouvelle classe contient tous les attributs et méthodes de la classe de base, et peut rajouter des nouveaux attributs, rajouter/modifier des méthodes. 13.2 - Le polymorphisme Grace au polymorphisme, on peut référencer "Génériquement" un objet. 13.3 - Redefinir une méthode class Personne{... public String parler() { return "personne"; } } class Client extends Personne {... public String parler() { return "client"; } } class Employe extends Personne {... public String parler() { return "employe"; } } Client.cli = new Client(); System.out.println(cli.parler()); Personne pers = cli; System.out.println(pers.parler()); -> Casting explicite de classe Personne personne = new Personne(); Client client = personne; !!!! Erreur de compilation Client client = (Client) personne; client.parler(); client.acheter(); Avec le casting, on ne transforme pas l'objet ! On empêche simplement le compilateur d'effectuer ses controles. 13.4 - Etendre une methode class Personne {... public String parler(){ return "personne"; } }

class Employe extends Personne {... public String parler() { return super.parler() + " - employe"; } } Employe emp = new Employe(); System.out.println(emp.parler()); Personne p = emp; System.out.println(p.parler()); 13.5 - Empecher la redefinition class Personne {... public final String parler() {...} // pas de redéfinition de la méthode } final class Employe extends Personne {... // pas d'héritage possible public void acheter() {...} } class Test extends Employe {...} // Erreur compilation 13.6 - Les constructeurs Les contructeurs ne s'héritent pas! Le constructeur par défaut fait appel à celui de la classe ancêtre. Si on redéfinit un constructeur, on fera appel explicitement à celui de l'ancetre. class Personne { public Personne() { System.out.println("personne"); } } class Client extends Personne { public Client() { this("toto");} // Chainage public Client(String text) { super(); System.out.println(text + "client"); } class ClientEtendu extends Client { public ClientEtendu() { super("titi");} System.out.println("Etendu"); } ClientEtendu ce= new ClientEtendu(); Quel sera le résultat ? personne titi client Etendu

13.7 - Les methodes polymorphes Il est obligatoire de definir les methodes polymorphes dans l ancetre, meme si on les redefinit toujours dans les descendants. Sans definir la methode dans l ancetre, impossible de l utiliser dans le cadre du polymorphisme!

13.8 - Les classes/methodes abstraites Grace aux classes/methodes abstraites, on peut obliger les descendants a redefinir les methodes, tout en ayant la methode definie dans l ancetre. abstract class Personne { public abstract String parler(); } class Employe extends Personne { public String parler() {...} } class Client extends Personne { public String parler() {...} } Personne[] p; Employe emp = new Employe(); Client cli = new Client(); p = {emp,cli}; p[0].parler(); p[1].parler(); Complement: Protected Il y a 4 criteres lies a l encapsulation

CHAPITRE 14 - LES INTERFACES 14.1 - L'heritage multiple En java, il n est pas possible d avoir plusieurs ancetres. 14.2 - Definition Une interface est un ensemble de methodes abstraites et de constantes. Une classe peut implementer une ou plusieurs interfaces. Elle doit fournir une implementation pour chaque interfaces. Les methodes doivent etre publiques interface Printable { void print(); } class Employe extends Personne implements Printable { .... public void print() { System.out.println(this.getNom()); } } 14.3 - Polymorphisme Les interfaces peuvent servir de type, et donc etre utilisee dans le cadre du polymorphisme. Printable p1 = new Employe(); Printable p2 = new De(); Test test = new test();

test.calcul(p1); test.calcul(p2); class Test { public void calcul(Printable imprime) { imprime.print(); } } 14.4 - Les Constantes Les interfaces peuvent contenir des attributs : ceux-ci sont OBLIGATOIREMENT des constantes publiques (il n'est pas nĂŠcessaire de prĂŠciser final et public) interface Printable { int MAX = 4; public void print(); } class De implements Printable { public void print () { System.out.println(MAX); } } 14.5 - instanceof Le mot reserve "instanceof" vous permet de savoir si un ojet est d un type donne, ou si sa classe implemente telle interface. Employe emp = new Employe(); // tout retourne true if (emp instanceof Employe) ..... if (emp instanceof Personne) .... if (emp instanceof Printable) .....

CHAPITRE 15 - LA CLASSE OBJET 15.1 - Definition Objet est une classe Objet est la super-classe de toutes les classes Chaque classe herite directement ou indirectement de la classe Objet public class Objet { public boolean equals(Object obj) {....} public String toString() {...} protected void finalize() {...} ///etc... } Ces methodes doivent/peuvent etre redefinies par toutes les classes que vous creez (deja realise pour les classes Sun).

15.2 - La methode "equals" Cette méthode permet de comparer 2 objets. String s = "hello"; String t = new String("hello"); if (s==t) {....} // test des adresses mémoires if (s.equals(t)) {....} // test du contenu référencé Si cette méthode retourne "true", cela signifie que les deux objets testés sont "équivalents". La méthode "equals" par défaut compare les références d'instances en utilisant l'opérateur == Personne p1 = new Personne("Jacques",43); Personne p2 = new Personne("Jacques",43); if (p1.equals(p2)) {System.out.println("vrai");} else { system.out.println("faux"); Il vous faut redéfinir la méthode afin de définir les critères de comparaison. class Personne { private String prenom; private int age; .... public boolean equals(Object obj) { if ((obj != null) && (obj instanceof Personne)) { Personne temp = (Personne) obj; return ( (this.getPrenom().equals(temp.getPrenom())) && (this.getAge() == temp.getAge())); } else return false; } } 15.3 - La methode "toString" Cette méthode fournit la représentation chaine de caractères d'un objet. Personne p = new Personne("Jean",23); Le compilateur modifiera votre code lors de la compilation! Il rajoutera pour vous cet appel de méthode. System.out.println(p); est identique à System.out.println(p.toString()); et affiche Personne@16AB3 ==> La méthode "toString" par défaut renvoie le nom de la classe suivi de l'adresse mémoire. public class Personne { .... public String toString() { return "le nom est "+ this.getPrenom() +" et son age est "+ this.getAge(); } } ..... Personne p = new Personne("Jean",23); System.out.println(p); affiche maintenant:

Le prenom est Jean et son age est 23.

CHAPITRE 16 – KIOSQUE 1: PACKAGE & HERITAGE CHAPITRE 17 – KIOSQUE : AGGREGATION CHAPITRE 18 – LES WRAPPERS 18.1 – Definition Les wrappers sont des classes permettant de: . contenir des types de base sous forme d objet . convertir des types de base vers des String, et vice-versa. Les wrappers se trouvent dans le package "java.lang", ils portent le meme nom que les types de base. byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 18.2 – Instanciation Lors de l instanciation d un Wrapper, on peut l initialiser avec des types de bases ou des String. Float value1,value2,value3; value1=new Float(3.56f); value2=new Float(3.56); value3=new Float("3.56"); Integer intValue1, intValue2; intValue1=new Integer(3); intValue2=new Integer("43"); 18.3 – Convertir les types de Base Les wrappers ont des methodes permettant de retourner un type de base. Ces methodes ont la forme: typedebaseValue() Float value1 = new Float(3.56f); Integer intValue1 = new Integer(3); int valInt = value1.intValue(); byte valByte = value1.byteValue(); 18.4 – Methodes statiques Plutot que de passer à chaque fois par un objet pour transformer un String vers un type de base, il est possible d'utiliser une méthode statique. int valInt = Integer.parseInt("123453");

byte valByte = Byte.parseByte("12"); Chaque Wrapper a, au moins, 2 constantes. byte maxByteValue = Byte.MAX_VALUE; byte minByteValue = Byte.MIN_VALUE; CHAPITRE 19 – LES COLLECTIONS 19.1 - Définition Les Collections sont des objets permettant de contenir d'autres objets. Les Collections ne peuvent stocker que des objets. Les Collections sont de taille variable. Les Collections contiennent des méthodes d'insertion, de recherche, d'extraction d'objets. Les Collections se trouvent dans le package java.util. Set : données uniques List : données récupérables avec index Map : Un objet donnée associé avec une clé objet cle unique, donnée pas nécessairement. 19.2 - Utilisation d'un Set import java.util.*; class Test {... HashSet set = new HashSet (); Joueur joueur1 = new Joueur("Jean"); Joueur joueur2 = new Joueur("Arthur"); set.add(joueur1); set.add(joueur2); ... } 19.3 - Utilisation d'une List import java.util.*; class Test {... ArrayList list = new ArrayList(); Joueur1 = new Joueur("Jean"); Joueur2 = new Joueur("Arthur"); list.add(joueur1); list.add(joueur2); for (int=0; i<list.size(); i++) { Joueur joueurTemp = (Joueur) list.get(i); System.out.println(joueurTemp); } ... } size() retourne le nombre d'éléments stockés. get(i) fournit un Objet lié à l'indice précisé Attention: 0 <= i <= size()-1

19.4 - Utilisation d'une Map import java.util.*; class Test {... HashMap map = new HashMap(); Joueur1 = new Joueur("Jean"); Joueur2 = new Joueur("Arthur"); map.put("Jean",joueur1); map.put("Arthur",joueur2); Joueur joueurTemp = (Joueur) map.get("Arthur"); System.out.println(joueurTemp); .... } get(clé) fournit un Objet lié à l'indice précisé. 19.5 - Iterator Les Map et les Set ne peuvent être parcouru avec un index numérique. On utilise plutot les Iterator (fonctionne pour List, ou Set) import java.util.*; class Test {... ArrayList list = new ArrayList(); Joueur1 = new Joueur("Jean"); Joueur2 = new Joueur("Arthur"); list.add(joueur1); list.add(joueur2); for (Iterator iterat = list.iterator(); iterat.hasNext();) { Joueur joueurTemp = (joueur) iterat.next(); System.out.println(joueurTemp); } ... } iterator() fournit la référence de l'itérateur hasNext() retourne true tant qu'on est pas à la fin de l'itération. next() renvoie l'objet courant 19.6 - Cas spécial Les Map ne peuvent être parcouru directement avec un iterator. On récupère la List ou le Set du Map auparavant. import java.util.*; class Test {... HashMap map = new HashMap(); ... List valeurs = (List) map.values(); set cles = map.keySet(); for (Iterator iterat=cles.iterator(); iterat.hasNext();) { String cle = (String) iterat.next(); System.out.println("cle="+cle+",valeur="+map.get(cle)); } ....

}

CHAPITRE 20 – KIOSQUE : LES COLLECTIONS