Vous êtes sur la page 1sur 78

Apprendre Java en 154 minutes

Tutorial Java 1.6 - HESB-TI

St ephanie Calderara Jos e R. Beuret Quentin Cosendey Mai 2008

Table des mati` eres


1 Objet, classe et modicateur 1.1 Le premier pas . . . . . . . . . . . . . . . . 1.2 Le concept de lobjet . . . . . . . . . . . . . 1.3 Le concept de la classe . . . . . . . . . . . . 1.4 La classe et lobjet . . . . . . . . . . . . . . 1.4.1 Lattribut ou variable . . . . . . . . 1.4.2 La m ethode . . . . . . . . . . . . . . 1.4.3 Le constructeur . . . . . . . . . . . . 1.5 Le point-virgule . . . . . . . . . . . . . . . . 1.6 Le point . . . . . . . . . . . . . . . . . . . . 1.7 Lorganisation des classes . . . . . . . . . . 1.7.1 Mot cl e package . . . . . . . . . . . 1.7.2 Mot cl e import . . . . . . . . . . . . 1.8 Les modicateurs . . . . . . . . . . . . . . . 1.8.1 Modicateurs de port ee . . . . . . . 1.8.2 Modicateur static . . . . . . . . . . 1.8.3 Modicateur nal . . . . . . . . . . 1.9 Le concept de lencapsulement . . . . . . . 1.10 Le concept de la r ef erence . . . . . . . . . . 1.10.1 D eclaration . . . . . . . . . . . . . . 1.10.2 Instanciation . . . . . . . . . . . . . 1.10.3 Initialisation . . . . . . . . . . . . . 1.10.4 Aectation . . . . . . . . . . . . . . 1.11 La r ef erence null . . . . . . . . . . . . . . . 1.12 La r ef erence this . . . . . . . . . . . . . . . 1.13 Combinaison de modicateur . . . . . . . . 1.13.1 La constante . . . . . . . . . . . . . 1.14 La m ethode main . . . . . . . . . . . . . . . 1.15 Acher du texte dans la console du syst` eme 3 3 3 4 4 5 5 6 7 7 7 7 8 9 9 11 12 12 13 13 14 14 15 15 16 18 18 20 20

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . op erationnel

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

2 Type primitif et classe String 21 2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.2 Les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . 21

2.3 2.4

2.5 2.6

2.2.1 Les nombres entiers . . . . . . . . . . 2.2.2 Les nombres ` a d ecimales . . . . . . . . 2.2.3 Le type logique ou bool een . . . . . . 2.2.4 Les caract` eres . . . . . . . . . . . . . . 2.2.5 Conversion implicite . . . . . . . . . . Op erateurs num eriques . . . . . . . . . . . . . Valeur contre r ef erence . . . . . . . . . . . . . 2.4.1 Emp echer la modication de la valeur 2.4.2 Avantage des r ef erences . . . . . . . . Classes Wrapper . . . . . . . . . . . . . . . . La classe String . . . . . . . . . . . . . . . . . 2.6.1 M ethode trim . . . . . . . . . . . . . . 2.6.2 M ethode equal . . . . . . . . . . . . . 2.6.3 M ethode equalIgnoreCase . . . . . . . 2.6.4 M ethode length . . . . . . . . . . . . . 2.6.5 M ethode charAt . . . . . . . . . . . . 2.6.6 M ethode substring . . . . . . . . . . . 2.6.7 M ethode concat . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . .

21 22 22 22 22 23 24 24 25 26 27 27 28 28 29 29 29 29 31 31 32 33 33 35 37 38 38 39 41 41 42 42 43 43 43 44 44 45

3 Conditions, boucles et tableaux 3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 If - un mot simple qui cache une r ealit e complexe . . . . . . . 3.3 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.1 la boucle while - quand on ne sait pas quand sarr eter 3.3.2 la boucle for - quand on sait ` a lavance combien de fois 3.4 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.1 D eclarer un tableau . . . . . . . . . . . . . . . . . . . 3.4.2 Acc eder aux valeurs dun tableau . . . . . . . . . . . . 3.4.3 Parcourir un tableau . . . . . . . . . . . . . . . . . . . 3.5 ArrayList, ou les tableaux dynamiques . . . . . . . . . . . . . 3.5.1 Cr eer un tableau dynamique . . . . . . . . . . . . . . 3.5.2 Ajouter des el ements . . . . . . . . . . . . . . . . . . . 3.5.3 Obtenir la taille du tableau . . . . . . . . . . . . . . . 3.5.4 R ecup erer un el ement . . . . . . . . . . . . . . . . . . 3.5.5 Modier un el ement . . . . . . . . . . . . . . . . . . . 3.5.6 Enlever des el ements . . . . . . . . . . . . . . . . . . . 3.5.7 Ins erer un el ement ` a une position arbitraire . . . . . . 3.5.8 Le retour de la boucle for am elior ee . . . . . . . . . . 3.5.9 Les types primitifs et petites curiosit es . . . . . . . . .

4 H eritage 47 4.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.2 Le modicateur protected . . . . . . . . . . . . . . . . . . . . 47 4.3 H eriter dune classe . . . . . . . . . . . . . . . . . . . . . . . . 47 ii

4.4 4.5 4.6

4.7 4.8

4.9

Le modicateur nal . . . . . . . . . . . . Overridden m ethode . . . . . . . . . . . . Classe abstraite et modicateur abstract . 4.6.1 A quoi ca sert ? . . . . . . . . . . . 4.6.2 Ce qui nest pas permis . . . . . . 4.6.3 Ce qui est permis . . . . . . . . . . Polymorphisme . . . . . . . . . . . . . . . Le multi-h eritages . . . . . . . . . . . . . 4.8.1 Cr eer une interface . . . . . . . . . 4.8.2 Lh eritage dans une interface . . . 4.8.3 Lien existant entre une interface et 4.8.4 H ebergement par des r ef erences . . Le casting dun type . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . une classe . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

. . . . . . . . . . . . .

48 49 50 52 52 52 53 54 54 54 55 56 58 59 59 59 60 60 61 63 63 63 64 64 65 68 70 71

5 Introduction aux exceptions 5.1 Motivation . . . . . . . . . . . 5.2 Lancer une exception . . . . . . 5.3 Attraper une exception . . . . . 5.4 Relancer une exception . . . . . 5.5 Les exceptions - cause derreurs

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . de conception

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

6 Flux de chier 6.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . 6.2 La jungle des ux en Java . . . . . . . . . . . . . . . . 6.3 La gestion et cr eation de ux - La nouvelle philosophie 6.3.1 La classe File . . . . . . . . . . . . . . . . . . . 6.3.2 La classe PrintWriter . . . . . . . . . . . . . . 6.3.3 La classe Scanner . . . . . . . . . . . . . . . . . 6.3.4 La sp ecialisation dun ux . . . . . . . . . . . . 6.3.5 La s erialisation dune donn ee . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

iii

Introduction
Tour dhorizon
La programmation Java est un langage qui a et e d evelopp e par lentreprise Sun Micorsystem dans les ann ees 80. Plusieurs versions apparaitront dans les ann ees suivantes. Chacune de ces versions apportera ` a Java de nouvelles classes et de ce fait, le rendra lun des langages les plus modernes. Vous verrez par la suite quavec Java, vous pourrez programmer nimporte quelle application. Java peut aussi etre utilis e pour programmer des applets pour Internet, mais nous nen parlerons pas dans ce manuel.

Apprendre Java en une apr` es-midi


Le but de ce manuel consiste ` a vous enseigner la programmation Java en une apr` es-midi. Ce document sadresse donc ` a tous ceux qui d esirent avoir une premi` ere approche en programmation. Vous verrez quapr` es avoir lu ce manuel, vous serez capable de programmer de petites choses d ej` a tr` es int eressantes. vous serez egalement en mesure de mieux comprendre les autres cours en Java. Il faut bien comprendre quil est impossible de tout savoir en si peu de temps. Il vous faudra essayer d` es que vous le pourrez, de programmer. De pr ef erence commencez par de petits projets sans grande importance, car il vous faut de lexp erience et comme vous le savez, lexperience se gagne en essayant. Ne vous d ecouragez surtout pas.

Comment s equiper
Il est aussi int eressant de mentionner que Java est un langage portable, cest-` a-dire que vous pouvez programmer sur un syst` eme Linux, Windows ou encore Mac OS. Lorsque vous programmez en Java, votre code compil e deviendra du byte code. Ce langage nest compris que par un environement Java (JRE). Mais cette partie est contenu dans la plupart des IDE Java. Il vous faut donc un IDE. Il en existe plusieurs mais les plus connus sont de loin NetBeans et Eclipse. Vous etes tout-` a-fait libre de choisir ce1

lui qui vous convient le mieux. Nous vous conseillons tout de m eme dutiliser NetBeans. En eet, les cr eateurs de NetBeans sont egalement ceux qui ont cr ee Java. De plus Sun Microsystems fourni un eort consid erable dans le d eveloppement des outils utilisant les technologies Java. Il vous faut egalement JDK 6. Cest un kit de d eveloppement propos e par Sun Microsystems. Dans ce pack, vous trouverez entre autres Java Runtime Environment (JRE). Tous les logiciels qui vous sont n ecessaires sont accessibles gratuitement par t el echargement ` a cette adresse http://java.sun.com/javase/downloads/index.jsp

Comment bien comprendre ce manuel


Nous vous conseillons vivement de lire les chapitres de ce manuel dans lordre donn e. Bien entendu, si vous avez d ej` a de bonnes connaissances en Java, vous pouvez sauter les chapitres d ej` a acquis. Si vous etes un d ebutant, prenez le temps de bien lire les chapitres dans lordre. Nh esitez pas ` a revenir sur ce que vous navez pas compris. Ce manuel sert dintroduction au monde de Java, vous ne pouvez pas forc ement comprendre tout dun coup. An de mieux sy retrouver, les mots-cl es (mots r eserv e par le langage Java) seront mis en italique. Les extraits de lAPI de Java seront dans une bo te jaune. Quant aux exemples de codes, vous les retrouverez dans des bo tes bleues. A la n de ce manuel, vous trouverez toutes les r ef erences utilis ees ainsi que des adresses de bons tutoriels pour approfondir vos connaissances en Java.

Chapitre 1

Objet, classe et modicateur


1.1 Le premier pas

Un proverbe chinois raconte quun voyage de 5000 lieux commence toujours par un pas. Aussi nous allons introduire les notions essentielles pour une bonne compr ehension de Java en termes simples et didacticiels. N eanmoins avant de commencer ` a apprendre les diverses notions, nous allons analyser le programme suivant en observant les di erents mots utilis es. Leur signications seront introduites progressivement tout au long de ce chapitre.
public c l a s s HelloWorld { public s t a t i c void main ( S t r i n g [ ] a r g s ) { System . out . p r i n t l n ( This i s a f r i e n d l y HelloWorld ! ) ; } }

Ce premier programme nous produira la sortie suivante :


This i s a f r i e n d l y HelloWorld !

Nous allons ` a pr esent apprendre les di erents concepts de la programmation objet.

1.2

Le concept de lobjet

Lobjet en Java est une donn ee structur ee, cest ` a dire quelle peut ellem eme contenir des donn ees plus petite. Un langage orient e objet ou ` a objet

consiste en la possibilit e de d ecrire tout objet de la vie courante en formalisme informatique. Ainsi il est possible de construire une structure ou une donn ee qui repr esentera lobjet de la vie courante associ e. La plus grande dicult e dun langage ` a objet consiste ` a r e echir en terme dobjet , cest-` a-dire que tout se relie ` a un moins un objet. De bons exercices pour sentrainer ` a cet philosophie consistent ` a choisir un objet dans votre entourage, puis de le d ecrire au niveau de sa structure ou son contenu, mais egalement au niveau de ses actions ou ev enements possibles. Par exemple, il sagit de d ecrire une porte, une fen etre, un chat ou encore un chien, en se posant les questions : Comment est-il ? et Que fait-il ? . Si vous avez fait lexercice avec une autre personne, et que celle-ci a d ecrit lobjet dune autre mani` ere, cest quelle a construit un autre formalisme pour lobjet en question. Il se peut m eme que ni lun, ni lautre ait tord. De plus, lorsquil sagit de formaliser un objet de la vie r eelle, il faut veiller que ce quon formalise, correspond eectivement ` a lensemble des objets du m eme genre que celui choisit. Si ce nest pas le cas, nous avons cr eer un formalisme trop sp ecique. A loppos e, il est aussi parfois utile d oublier certaines contraintes de la vie r eelle pour avoir un mod` ele utilisable, sans quoi le mod` ele serait trop dicile ` a programmer, voire m eme impossible. Personne souhaiterait cr eer un objet repr esentant un chat qui contiendrait toutes ses cellules, lesquels auraient des mitochondries ou autres el ements biologiques. An de cr eer un tel objet, nous pourrions nous contenter des informations concernant son age, la couleur de sa fourrure ou encore la couleur de ses yeux.

1.3

Le concept de la classe

Une classe est une sorte de descriptif qui concerne directement ou indirectement un type dobjet. Cest une sorte de regroupement de toutes les fonctionnalit es disponibles pour un type dobjet. Il est souvent utilis e, dans la litt erature, lexpression la classe de . En eet pour chaque type dobjet, il y a une seule classe. Et par classe, il ny a quun seul type dobjet qui y est d ecrit, cela nemp eche pas quil peut y avoir des interactions avec dautres types dobjet. Par exemple, un chat et une souris auront une interaction, n eanmoins dans la classe Chat, seul le type Chat y sera d ecrit et dans la classe Souris, seul le type Souris y sera d ecrit.

1.4

La classe et lobjet

A pr esent que nous sommes introduits aux concepts dobjet et de classe, nous pouvons le d ecrire selon le langage Java. En Java, le nom de la classe est aussi le m eme nom du type dobjet qui y est d ecrit. De plus, la classe doit etre plac ee dans un chier comportant le nom et ayant comme extension de 4

chier .java . En dautres termes si lon construit un type dobjet nomm e Chat, nous allons le faire dans la classe Chat qui se trouve dans le chier Chat.java sur votre ordinateur.
public c l a s s Chat { // . . . }

La description de la classe Chat se fait ` a laide de divers moyens comme par exemple lattribut ou la m ethode.

1.4.1

Lattribut ou variable

Lattribut, appel e egalement variable, consiste en une donn ee n ecessaire pour une description, elle nous permet de m emoriser une information, qui pourra etre reprise par la suite. En dautres termes, elle permet de contenir une information que nous avons jug ee n ecessaire dans la mod elisation. Dans notre exemple pour d ecrire un chat, nous souhaitons garder des informations telles que son age, la couleur de sa fourrure ou encore la couleur de ses yeux, comme nous le montre lexemple suivant :
public c l a s s Chat { public int age ; public C o l o r yeux ; public C o l o r f o u r r u r e ; }

Nous pouvons observer que int (type nombre) et Color (type Couleur) sont eux-m emes des types de donn ees.

1.4.2

La m ethode

La m ethode consiste en une action ou une r eaction ` a un ev enement, elle utilise ce quon appelle des param` etres, et renvoie un r esultat. Les param` etres sont des indications pour d enir le comportement de la m ethode. Le r esultat renvoy e sappellent egalement la valeur de retour. Chose particuli` ere, il y a toujours un r esultat renvoy e, mais ce dernier peut etre rien avec le type void. En eet void est un type qui ne fait rien du tout. Dans notre exemple, nous allons introduire une m ethode o` u le chat peut manger une souris, ainsi quune autre m ethode mentionnant sil a assez mang e. Nous ne d ecrirons pas le contenu de ces deux m ethodes.

public c l a s s Chat { public int age ; public C o l o r yeux ; public C o l o r f o u r r u r e ; public void mange ( S o u r i s s ) { // . . . } public boolean assezMange ( ) { // . . . } }

A noter que le type boolean repr esente une r eponse oui ou non, ou plut ot vrai ou faux avec les valeurs true ou false.

1.4.3

Le constructeur

Nous avons jusqu` a pr esent d ecrit ce quest un chat, en dautres termes ce quon juge int eressant de m emoriser lorsquon parle de chat. Nous avons egalement d ecrit ce quun chat peut faire. Il nous manque encore une notion essentielle dans la description dun chat, qui est la mani` ere dont le chat est m emoris e tout au d ebut, en dautres termes cest lacte de naissance de lobjet dans la m emoire de lordinateur. Imaginons deux chats Cannelle et Wi. Cannelle a une ann ee, poss` ede les yeux bruns, ainsi quune couleur de fourrure ch atain. Tandis que Wi a trois ans, poss` ede les yeux bleus, ainsi quune couleur de fourrure noir. Partant du point de vue que nous allons utiliser notre description du chat, nous aimerions construire nos deux chats. Nous allons donc devoir d evelopper un outil permettant de m emoriser l etat initial de notre objet. Ce m ecanisme sappelle le constructeur. Contrairement aux m ethodes, il ne renvoie rien, m eme pas void. La raison etant quil renvoie ou enregistre dans la m emoire les di erentes valeurs avec celles que nous lui donnons par d efaut. Nous allons donc elaborer un constructeur pour le type Chat dans notre exemple. Nous devons aussi remarquer que le nom utilis e pour le constructeur doit etre identique au nom de la classe.
public c l a s s Chat { public int age ; public C o l o r yeux ; public C o l o r f o u r r u r e ; public Chat ( int un age , C o l o r des yeux ,

Color u n e f o u r r u r e ) { age = un age ; yeux = d e s y e u x ; fourrure = une fourrure ; } public void mange ( S o u r i s s ) { // . . . } public boolean assezMange ( ) { // . . . } }

1.5

Le point-virgule

Vous lavez sans doute d ej` a remarqu e; ` a la n de chaque ligne il y a un point-virgule ( ;). Le point-virgule indique une n dinstruction. Cela permet a lordinateur de reconna ` tre une n dinstruction est de la traiter de mani` ere ind ependante avec la suivante.

1.6

Le point

Le point est lop erateur permettant dacc eder ` a un el ement ` a lint erieur dun autre, par exemple un attribut ou une m ethode dun objet.

1.7

Lorganisation des classes

Nous sommes en train de construire progressivement une classe Chat, nous savons egalement que le chier Chat.java existera. En Java, il existe le concept de paquet, on parle aussi de librairie ou de biblioth` eque. Cest un ensemble de classe que lon rassemble sous un m eme nom appel e package. Dans notre exemple, nous avons la classe Chat, mais nous pouvons egalement imaginer avoir les classes Chien et Souris. Nous pourrions donc cr eer un package appel e animaux.

1.7.1

Mot cl e package

An de faire appartenir une classe ` a un package, il faut placer en premi` ere ligne, en d ebut de chier, package suivit du nom du package et placer le chier dans le r epertoire correspondant au nom du package.

Ainsi si nous souhaitons faire ajouter la classe Chat au paquet animaux, nous devrons enregistrer le document Chat.java dans un r epertoire animaux.
package animaux ; public c l a s s Chat { // . . . }

Si au contraire nous souhaitons ajouter la classe Chat au paquet animaux.domestique, nous devrons enregistrer le document Chat.java dans un sous r epertoire danimaux et le nommer domestique.
package animaux . domestique ; public c l a s s Chat { // . . . }

Il existe un package particulier qui est le package courant, le package provenant du r epertoire courant ou actuel. Dans ce cas particulier, il nest pas n ecessaire de mentionner le nom du package. Implicitement, les autres classes du m eme r epertoire seront consid er ees comme du m eme package.

1.7.2

Mot cl e import

Il est parfois n ecessaire de reprendre ce qui a d ej` a et e programm e dans un autre package, il nous faut donc pouvoir y acc eder. Nous disposons pour cela du mot cl e import. Dans notre exemple, nous utilisons la classe Color qui se trouve dans le package java.awt, notre exemple deviendrait donc
package animaux . domestique ; import j a v a . awt . * ; public c l a s s Chat { // . . . }

Le symbole .* signie que nous souhaitons acc eder ` a toutes les classes gurant dans le paquet java.awt. Il est aussi important de remarquer quon nimporte pas les classes gurant dans les sous r epertoires. Par exemple, en 8

important les classes de java.awt, on nimporte pas les classes gurant dans java.awt.event. Il se peut aussi quon souhaite uniquement acc eder ` a la classe Color, dans ce cas il est possible dimporter que la classe voulue en la mentionnant directement, comme nous le montre lexemple.
package animaux . domestique ; import j a v a . awt . C o l o r ; public c l a s s Chat { // . . . }

1.8

Les modicateurs

Jusqu` a pr esent, dans les codes pr ec edents, apparaissent les mots public et static, ils font partis de ce que lon nomme les modicateurs. En dautres termes, ils indiquent un contexte dutilisation. Tout au long de ce document, vous serez introduit progressivement ` a la plupart de ces modicateurs.

1.8.1

Modicateurs de port ee

Les modicateurs de port ee servent ` a d enir les endroits depuis lesquels un attribut ou une m ethode est accessible. Pour cela chaque modicateur poss` ede une d enition bien pr ecise. Par el ement, il ne peut y avoir quun seul modicateur de port ee. Il existe quatre modicateurs, nous nen pr esenterons que trois, le quatri` eme sera introduit lors dun autre concept en programmation objet. Modicateur public Le modicateur public signie que l el ement est accessible depuis nimporte o` u. Modicateur private Le modicateur private signie que l el ement est accessible uniquement depuis lint erieur de sa classe. Modicateur package Le modicateur package signie que l el ement est accessible uniquement depuis le m eme package de sa classe. Contrairement aux autres modicateurs de port ee, lorsquon souhaite utiliser ce modicateur, il ny a pas de mot cl e 9

qui y est associ e. En dautres termes ne pas ajouter un modicateur revient a d ` eclarer l element avec le modicateur package. Imaginons dans la classe Chat de notre exemple une m ethode estSurveille() qui ne renvoie rien et accessible uniquement ` a lensemble des classes du m eme package.
package animaux ; public c l a s s Chat { public int age ; public C o l o r yeux ; public C o l o r f o u r r u r e ; public Chat ( int un age , C o l o r des yeux , Color u n e f o u r r u r e ) { age = un age ; yeux = d e s y e u x ; fourrure = une fourrure ; } public void mange ( S o u r i s s ) { // . . . } public boolean assezMange ( ) { // . . . } void e s t S u r v e i l l e ( ) { // Le c h a t ne p e u t p l u s f a i r e n i m p o r t e q u o i . } }

Cette m ethode pourra etre utilis ee par exemple dans la classe Chien ou toutes autres classes dans le package animaux.
package animaux ; public c l a s s Chien { public Chien ( ) { } public void s u r v e i l l e U n C h a t ( Chat c ) { c . e s t S u r v e i l l e ( ) ; // a c c` e s permis }

10

1.8.2

Modicateur static

Le modicateur static consiste ` a signaler que l el ement ne d epend que de la classe et non dun objet en particulier. Les acc` es se font donc par le nom de la classe elle-m eme. Nous appelons aussi les attributs statiques les attributs de classe. Les m ethodes statiques sont, elles, appel ees les m ethodes de classe. Il existe aussi un abus de notation consistant ` a utiliser un objet pour y faire acc` es, nous vous le d econseillons fortement dune part car il sagit dune mauvaise interpr etation du concept en soi, dautre part avec cet abus vous aurez probablement des dicult es par la suite ` a di erencier ce qui concerne lobjet en soi, de ce qui concerne uniquement la classe. Pour revenir ` a notre exemple, nous pouvons imaginer une m ethode de classe getPlanete() qui renverrait la plan` ete sur laquelle vie les chats. En eet, nous supposons que tous les chat vivent sur la m eme plan` ete. De plus nous observons que la m ethode ne d epend pas des objets qui seront cr e es a partir de cette classe. N ` eanmoins cest une information qui concerne les chats.
package animaux ; public c l a s s Chat { public int age ; public C o l o r yeux ; public C o l o r f o u r r u r e ; public Chat ( int un age , C o l o r des yeux , Color u n e f o u r r u r e ) { age = un age ; yeux = d e s y e u x ; fourrure = une fourrure ; } public void mange ( S o u r i s s ) { // . . . } public boolean assezMange ( ) { // . . . } public s t a t i c P l a n e t e g e t P l a n e t e ( ) { // r e t o u r n e l a p l a n ` e t e Terre }

11

void e s t S u r v e i l l e ( ) { // Le c h a t ne p e u t p l u s f a i r e n i m p o r t e q u o i . } }

1.8.3

Modicateur nal

Le modicateur nal est un modicateur qui interdit ` a une variable de prendre une nouvelle valeur. En dautres termes, une fois quune valeur est plac ee dans la variable, la variable ne peut plus la changer.

1.9

Le concept de lencapsulement

Jusqu` a pr esent nous avons syst ematiquement utilis e le modicateur public, ainsi tout le monde peut modier les valeurs de nos attributs. Bien que simple, cela convient que tr` es peu ` a une programmation rigoureuse et s ecuris ee. Le concept dencapsulement consiste ` a rendre priv e les attributs, mais de pouvoir les modier, si lon souhaite, par des m ethodes. Pour cela on peut, sans obligation et selon notre volont e, elaborer deux m ethodes, lune pour lire, lautre pour modier. On les reconnait souvent facilement car elles commencent par convention par get ou set. Notre exemple deviendrait donc, en rajoutant la notion de poids :
package animaux ; public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; private int p o i d s ; public Chat ( int un age , C o l o r des yeux , Color u n e f o u r r u r e ) { age = un age ; yeux = d e s y e u x ; fourrure = une fourrure ; } // a c c eder ` a une donn ee p r i v ee public int g e t P o i d s ( ) { return p o i d s ; }

12

// m o d i f i e r une donn ee p r i v ee public void s e t P o i d s ( int n o u v e a u p o i d s ) { poids = nouveau poids ; } public void mange ( S o u r i s s ) { // . . . } public boolean assezMange ( ) { // . . . } public s t a t i c P l a n e t e g e t P l a n e t e ( ) { // r e t o u r n e l a p l a n ` e t e Terre } void e s t S u r v e i l l e ( ) { // Le c h a t ne p e u t p l u s f a i r e n i m p o r t e q u o i . } }

Dans la litt erature, on parle aussi dattributs mutable si ils sont modiables et unmutable sils ne sont pas modiables.

1.10

Le concept de la r ef erence

Une r ef erence ne contient pas la donn ee directement, mais uniquement lendroit dans la m emoire o` u se trouve la donn ee. N eanmoins toutes les mani` eres dacc eder ` a lobjet ont et e rendues intuitives.

1.10.1

D eclaration

Quest-ce que signie r eellement d eclarer une variable ? Cest tout simplement le fait de la cr eer. Essayez toujours de choisir des noms de variables le plus explicite possible. Cela simplie consid erablement la relecture du code. Il faut tout de m eme respecter les quelques r` egles suivantes en mati` ere de nomination de variable : Le nom doit toujours commencer par une lettre, un blanc soulign e ( ) ou encore un dollar ($). En aucun cas une variable ne peut commencer par un chire. Ceci sapplique uniquement pour le premier caract` ere. Vous pouvez choisir nimporte quel nom sauf les mots r eserv es d ej` a pris par le langage. Dans lexemple ci-dessous, nous avons cr e e une variable de type Chat avec pour nom monChat . Notons que pour le moment, la variable monChat ne contient pas de valeur. 13

Chat monChat ;

1.10.2

Instanciation

Linstanciation consiste en la cr eation dun objet. Dans la litt erature, on parle de cr eer une instance pour cr eer un objet. On utilise pour cela le mot cl e new qui sutilise suivit dun constructeur. Par exemple, si nous souhaitons cr eer un chat ag e dune ann ee, ayant les yeux bleues et la fourrure brune, nous ecririons :
new Chat ( 1 , C o l o r . BLUE, C o l o r .BLACK) ;

Nous pouvons cr eer ce quon appelle un objet sans r ef erence. Cest ce que nous avons fait avant. Nous pouvons aussi imaginer cr eer un objet directement dans un des param` etres dune m ethode. Pour reprendre lexemple du chien et du chat :
Chien monChien = new Chien ( ) ; monChien . s u r v e i l l e U n C h a t ( new Chat ( 1 , C o l o r . BLUE, C o l o r .BLACK) ) ;

1.10.3

Initialisation

Linitialisation consiste en lapplication de la premi` ere valeur dans la variable. Ayant des r ef erences, ce sera donc ladresse qui sera consid er ee dans linitialisation. Dans lexemple pr ec edent nous avons fait une initialisation de la variable monChien. Voici le code, si lon devait faire egalement une initialisation de la variable monChat.
Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BLACK) ; Chien monChien = new Chien ( ) ; monChien . s u r v e i l l e U n C h a t ( monChat ) ;

Il est aussi important de remarquer que le type dobjet construit doit etre identique au type dobjet de la r ef erence. Nous verrons plus tard que ce principe sera dune certaine mani` ere un peu plus souple.

14

1.10.4

Aectation

Laectation consiste en lapplication dune nouvelle valeur qui remplacera la pr ec edente. Dans notre exemple, nous construisons deux chats bien distincts qui seront chacun ` a leur tour mis dans la variable monChat.
Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BLACK) ; monChat = new Chat ( 0 , C o l o r .BROWN, C o l o r .WHITE) ;

Il est important de ne pas rajouter Chat en d ebut de la seconde ligne dans lexemple pr ec edent, car sinon le compilateur interpr etera quil y a deux variables de m eme nom, ce qui ne conviendra pas, do` u une erreur. Tout comme pour linitialisation le type dobjet construit doit etre identique au type dobjet de la r ef erence.

1.11

La r ef erence null

Nous savons que dans les exemples pr ec edents, nous construisons un Chat et le pla cons dans la r ef erence monChat. N eanmoins, que ce passe t-il si lon tente de cr eer une r ef erence sans y aecter une valeur, puis que lon y acc` ede ? Nous avons en Java la r ef erence null, cest-` a-dire la r ef erence qui ne pointe sur rien. Comme elle ne pointe sur rien, il est impossible dy appliquer une m ethode ou un attribut. Cette r ef erence est utile si lon souhaite eacer une valeur dune r ef erence. Lexemple suivant produira une erreur, car la m ethode surveilleUnChat(Chat c) appelle c.estSurveille(), mais comme la variable monChat est null, alors c est null, do` u lerreur.
Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BLACK) ; monChat = null ; Chien monChien = new Chien ( ) ; monChien . s u r v e i l l e U n C h a t ( monChat ) ; // p r o d u i r a une e r r e u r

La m eme situation se passerait si, on ninitialise pas monChat


Chat monChat ; // v a r i a b l e pas i n i t i a l i s e // equivalent ` a Chat monChat = n u l l ; Chien monChien = new Chien ( ) ; monChien . s u r v e i l l e U n C h a t ( monChat ) ; // p r o d u i r a une e r r e u r

15

1.12

La r ef erence this

Nous avons vu que notre constructeur utilise des noms de variable di erents, mais nous aimerions n eanmoins pouvoir r eutiliser les m emes dans le constructeur et dans les variables dinstance, comme nous le rappelle lexemple suivant.
public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; public Chat ( int un age , C o l o r des yeux , Color u n e f o u r r u r e ) { age = un age ; yeux = d e s y e u x ; fourrure = une fourrure ; } // e t c . . . }

Si nous le faisons directement nous aurons un probl` eme, car les variables existantes d ej` a localement, seront privil egi ees ` a celle de linstance.
public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; public Chat ( int age , C o l o r yeux , Color f o u r r u r e ) { // l e s v a r i a b l e s d i n s t a n c e s ne s o n t pas m is e s ` a jour age = age ; yeux = yeux ; fourrure = fourrure ; } // e t c . . . }

Java dispose pour cela dune r ef erence particuli` ere qui nous indique ladresse de lobjet courant. Cette r ef erence sappelle this et elle pointe sur lobjet qui 16

est en train d etre utilis e.


public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; public Chat ( int age , C o l o r yeux , Color f o u r r u r e ) { // l e s v a r i a b l e s d i n s t a n c e s s o n t m i se s ` a jour t h i s . age = age ; t h i s . yeux = yeux ; this . fou rr ure = fou rr ure ; } // e t c . . . }

De plus, vu que this pointe sur lobjet courant, il nest pas permis dutiliser this dans une m ethode statique, vu que cette m ethode ne d epend pas dune instance. En dautres termes, dans une m ethode statique il ny a pas dobjet courant. Il est important de ne pas confondre cela avec cr eer ou utiliser des objets dans une m ethode statique. Voici encore un exemple, de ce qui est permis
public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; public Chat ( int age , C o l o r yeux , Color f o u r r u r e ) { // l e s v a r i a b l e s d i n s t a n c e s s o n t m i se s ` a jour t h i s . age = age ; t h i s . yeux = yeux ; this . fou rr ure = fou rr ure ; } public s t a t i c int ageMoyen ( Chat c1 , Chat c2 ) { return ( c1 . age+c2 . age ) / 2 ; } }

17

et de ce qui ne lest pas.


public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; public Chat ( int age , C o l o r yeux , Color f o u r r u r e ) { // l e s v a r i a b l e s d i n s t a n c e s s o n t m i se s ` a jour t h i s . age = age ; t h i s . yeux = yeux ; this . fou rr ure = fou rr ure ; } public s t a t i c int ageMoyen ( Chat c ) { return ( t h i s . age+c . age ) / 2 ; // t h i s r e p r esente quoi ? // c e t t e m e thode e s t s t a t i q u e } }

1.13

Combinaison de modicateur

Les modicateurs peuvent se combiner normalement, il existe certaines exceptions dues au concept qui ne sont pas compatibles. La combinaison des modicateurs est importante car elle d etermine le contexte dutilisation : accessible depuis o` u ? de classe ou dinstance ? modiable ? Ce qui signie respectivement ` a choix public ou private, puis static ou non, et enn en dernier nal ou non.

1.13.1

La constante

La constante est un cas particulier dutilisation de modicateur. Par le principe dune constante, elle nest pas di erente dune instance ` a une autre, donc elle est static. De plus une fois d enie, elle ne doit plus etre modiable, donc elle doit etre nal. La derni` ere question que nous devons nous poser consiste ` a choisir entre une constante accessible uniquement ` a lint erieur de la classe, au m eme package ou au contraire accessible de partout. Le choix nous est propre en fonction de ce que nous souhaitons faire. Une utilisation particuli` ere de la constante consiste ` a pr ed enir des choix, puis de les utiliser dans le contexte voulu. Imaginons dans notre exemple que nous souhaitons introduire le mental du chat, nous allons pour cela introduire les constantes TROP HEUREUX, HEUREUX, PARTIELLEMENT HEUREUX, et MALHEUREUX. Les constantes s ecrivant 18

de pr ef erence que en majuscule pour mieux les reconna tre.


public c l a s s Chat { private int age ; private C o l o r yeux ; private C o l o r f o u r r u r e ; private int mental ; public public public public static static static static final final final final int int int int TROP HEUREUX=0; HEUREUX=1; PARTIELLEMENT HEUREUX=2; MALHEUREUX=3;

public Chat ( int age , C o l o r yeux , Color f o u r r u r e ) { t h i s ( age , yeux , f o u r r u r e , HEUREUX) ; // t h i s u t i l i s e de c e t t e mani` e re a p p e l l e // un c o n s t r u c t e u r de l a m eme c l a s s e } public Chat ( int age , C o l o r yeux , C o l o r f o u r r u r e , int mental ) { // l e s v a r i a b l e s d i n s t a n c e s s o n t m i se s ` a jour t h i s . age = age ; t h i s . yeux = yeux ; this . fou rr ure = fou rr ure ; t h i s . mental = mental ; } // . . . public int getMental ( ) { return mental ; } public void s e t M e n t a l ( int mental ) { t h i s . mental = mental ; } } Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BROWN, Chat .HEUREUX) ; monChat . s e t M e n t a l ( Chat .TROP HEUREUX) ;

Cette utilisation excessive de constantes est utilis ee pour faciliter la lecture de code, cela permet egalement de savoir ce qua pr evu exactement le 19

programmeur de la classe.

1.14

La m ethode main

Pour pouvoir ex ecuter un programme, il faut pouvoir d esigner un point dentr ee. En dautres termes, il faut pouvoir signaler la premi` ere instruction a faire. En Java, comme il ny a que des classes, la m ` ethode main doit donc etre dans une classe. Nayant rien de particulier avec une instance, elle doit donc etre static. De plus, devant etre accessible depuis lext erieur de la classe, elle doit etre public. Largument args est en faite un tableau contenant tous les param` etres que Java transmet ` a lapplication. Nous pouvons ` a pr esent comprendre parfaitement ce que fait lexemple suivant.
public c l a s s HelloWorld { public s t a t i c void main ( S t r i n g [ ] a r g s ) { // Le contenu du programme } }

1.15

Acher du texte dans la console du syst` eme op erationnel

Le syst` eme op erationnel ou syst` eme dexploitation tel que Mac OS X, Linux ou Unix fournissent plusieurs points dentr ees et sorties. Le point de sortie standard pour pouvoir acher du texte est en fait lobjet out se trouvant dans la classe System. Nous pouvons y acc eder directement. De plus, la m ethode pour acher du texte est la m ethode println. Nous pouvons, ` a pr esent comprendre pleinement notre premier programme, pr esent e en d ebut de chapitre.
public c l a s s HelloWorld { public s t a t i c void main ( S t r i n g [ ] a r g s ) { System . out . p r i n t l n ( This i s a f r i e n d l y HelloWorld ! ) ; } }

Ce premier programme nous produira la sortie suivante :


This i s a f r i e n d l y HelloWorld !

20

Chapitre 2

Type primitif et classe String


2.1 Motivation

Jusqu` a pr esent nous navons vu que le comportement des objets. Il y a cependant des donn ees qui ne sont pas des objets, elles sappellent les types primitifs. Ce nom provient du fait que historiquement ce sont des types de nombre pouvant etre trait es en tant que tel dans le processeur de lordinateur. Java propose huit types primitifs. Nous allons voir dans ce chapitre en quoi les types primitifs sont di erents des objets. Nous allons egalement aborder la classe String en profondeur et lutiliser an de mieux montrer la di erence quil y a entre un type primitif et un objet.

2.2

Les types primitifs

Normalement les tailles de type primitif sont propres ` a chaque syst` eme op erationnel, toutefois, Java devant standardiser son comportement sur chaque syst` eme, ` a choisi daecter des tailles xes ` a chacun de ces types.

2.2.1

Les nombres entiers

Les types des nombres entiers sont au nombre de quatre et ayant chacun une capacit e di erente. Un bit repr esente deux valeurs 0 et 1. Ainsi avec n bits, nous pouvons repr esenter 2n valeurs. Type Dimension Repr esentation byte 8 bits -128 ` a 127 short 16 bits -32768 ` a 32767 int 32 bits -2147483648 ` a 2147483647 long 64 bits immense Le type int est egalement appel e integer.

21

2.2.2

Les nombres ` a d ecimales

Les types de nombre ` a d ecimales sont au nombre de deux et ayant chacun une capacit e di erente. Tous les nombres ` a d ecimales ne peuvent pas etre enregistr es tel quel, ils sont arrondis pour etre dans le format des nombres a virgule dans linformatique. Les nombres ` ` a virgule sont g en eralement d ecompos es en trois parties : lune pour le signe, une autre pour un nombre entier et une troisi` eme pour un exposant. Nous avons donc un nombre d de la forme : d = s n 10e o` u s repr esente le signe 1 ou +1, n est le nombre entier, et e est une puissance (positive ou n egative). An de pouvoir remarquer quil y a une perte, prenez votre calculatrice est faite 2 2 2, il est fort probable que vous nobteniez pas 0, mais un nombre extr emement petit. En eet 2 est arrondie selon le syst` eme cidessus, est donc sa mise au carr e ne correspond plus ` a 2. An daugmenter la pr ecision, on utilise g en eralement le type double, et tr` es peu le type oat. Type Dimension oat 32 bits double 64 bits

2.2.3

Le type logique ou bool een

Le type logique, ou plus commun ement appel e boolean, est un type qui ne poss` ede que deux valeurs qui sont vrai ou faux. Les valeurs sont true pour vrai et false pour faux.

2.2.4

Les caract` eres

Les caract` eres sont en faite des nombres. Pour chacun des nombres on d ecide conceptuellement ` a quel symbole il correspond. Cest pourquoi il existe plusieurs encodages tels que latin-1 ou utf-8. Car chaque encodage attribut son propre symbole ` a un nombre. Type Dimension char 16 bits

2.2.5

Conversion implicite

Dans les types primitifs il y a des r` egles de conversion implicite. Nous allons uniquement traiter deux de ces conversions.

22

int vers long Lorsque nous ecrivons le code suivant, nous pourrions avoir la fausse impression que nous cr eons un nombre de type long pour le placer dans la variable de type long, il nen nest rien. En eet, le nombre cr e e est un int, la variable etant de type long, le nombre sera converti en type long.
long l = 1 2 ;

An d eviter ce probl` eme, il faut rajouter un suxe L pour indiquer que cest bien un nombre de type long.
long l = 12L ;

char vers int Nous avons vu quun caract` ere nest quen fait un nombre, cest pourquoi il est permis denregistrer une lettre dans un int.

long l = A ; // e n r e g i s t r e l e nombre c o r r e s p o n d a n t ` a A

2.3

Op erateurs num eriques

Il existe di erents op erateurs num eriques, qui repr esentent les op erations arithm etiques standards. Nous connaissons d ej` a les op erateurs + et * qui reprennent laddition et la multiplication math ematique. Il existe aussi lop erateur incr ement ++ qui peut ` a la fois se mettre avant ou apr` es la variable. Observons pour cela le code source suivant.
int i =3; i ++; // i d e v i e n t 4 ++i ; // i d e v i e n t 5

N eanmoins leur signication ne sont pas les m emes, comme nous le montre lexemple suivant. Car lop erateur se pla cant avant ` a une priorit e elev e.
int i = 3 ; i = i++ * 3 // i * 3 + 1 int j = 3 ; j = ++j * 3 ; // ( j +1) * 3

23

2.4

Valeur contre r ef erence

Une variable m emorise une r ef erence lorsquil sagit dun objet, et m emorise une valeur lorsquil sagit dun type primitif, la di erence est de taille. En eet, lorsquon passe une valeur ` a une m ethode en param` etre, la valeur est copi ee. Alors que lorsquil sagit dune r ef erence, cest la r ef erence qui est copi ee. Ainsi lacc` es ` a lobjet est rest e intacte, et donc lobjet pourra etre modi e depuis lint erieur de la m ethode, ce que lutilisateur navait pas forc ement pr evu. An de mieux illustrer ce principe, nous allons observer deux programmes qui font la m eme chose, une fois avec un int, une autre fois avec un chat.
public c l a s s D e s t r o y e r { public s t a t i c void d e s t r o y e r ( Chat c ) { c = new Chat ( 2 0 6 3 , C o l o r .YELLOW, C o l o r .GREEN, Chat .TROP HEUREUX) ; } public s t a t i c void d e s t r o y e r ( int i ) { i = 0; } public s t a t i c void main ( S t r i n g [ ] a r g s ) { Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BRWON, Chat .HEUREUX) ; int i = 0 0 7 ; d e s t r o y e r ( monChat ) ; destroyer ( i ) ; System . out . p r i n t l n ( monChat . getMental ( ) ) ; System . out . p r i n t l n ( i ) ; } } 0 7

o` u 0 est la valeur de la constante Chat.TROP HEUREUX. On observe bien que lobjet contenu dans monChat est modi e, et que linteger nest pas modi e.

2.4.1

Emp echer la modication de la valeur

Nous avons vu que si une variable d etient le modicateur nal, cela emp eche la valeur d etre modi ee. Ainsi si le modicateur est pr esent dans 24

une variable dune m ethode, cela signie que la modication de la variable est interdite.
public c l a s s D e s t r o y e r { public s t a t i c void d e s t r o y e r ( f i n a l Chat c ) { // c = new Chat ( // 2063 , Color .YELLOW, Color .GREEN, Chat .TROP HEUREUX) ; // l a l i g n e p r e c edente s e r a i t i n t e r d i t e } public s t a t i c void d e s t r o y e r ( int i ) { i = 0; } public s t a t i c void main ( S t r i n g [ ] a r g s ) { Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BRWON, Chat .HEUREUX) ; int i = 0 0 7 ; d e s t r o y e r ( monChat ) ; destroyer ( i ) ; System . out . p r i n t l n ( monChat . getMental ( ) ) ; System . out . p r i n t l n ( i ) ; } } 1 7

o` u 1 est la valeur de la constante Chat.HEUREUX.

2.4.2

Avantage des r ef erences

Parfois, il est bien de pouvoir modier le contenu dun objet directement, cela evite de devoir retourner une valeur qui correspond ` a la valeur modi ee, puis de r ecup erer cette valeur et de la placer dans la bonne r ef erence.
public c l a s s D e s t r o y e r { public s t a t i c void d e s t r o y e r ( Chat c ) { Chien p l u t o = new Chien ( ) ; pluto . surveilleUnChat ( c ) ; c . s e t M e n t a l ( Chat .TROP HEUREUX) ; // l e c h a t e s t s u r v e i l l e par p l u t o // i l n y a donc p l u s aucun r i s q u e // pour l e c h a t

25

} public s t a t i c void d e s t r o y e r ( int i ) { i = 0; } public s t a t i c void main ( S t r i n g [ ] a r g s ) { Chat monChat = new Chat ( 1 , C o l o r . BLUE, C o l o r .BRWON, Chat .HEUREUX) ; int i = 0 0 7 ; d e s t r o y e r ( monChat ) ; destroyer ( i ) ; System . out . p r i n t l n ( monChat . getMental ( ) ) ; System . out . p r i n t l n ( i ) ; } } 0 7

o` u 0 est la valeur de la constante Chat.TROP HEUREUX.

2.5

Classes Wrapper

Les types primitifs ne sont pas des objets, ainsi il nous est impossible de b en ecier des avantages de lobjet. Cest pourquoi il existe des classes wrapper, qui enveloppent le type primitif. Type primitif associ e Type byte Byte Short short int Integer long Long boolean Boolean char Char oat Float double Double Toutes les classes wrapper poss` edent un constructeur ayant comme unique argument le type primitif associ e. Il est ainsi possible dutiliser toute la puissance des concepts objets.

26

I n t e g e r i = new I n t e g e r ( 2 5 ) ; Char c = new Char ( E ) ;

2.6

La classe String

Une string est une chaine de caract` ere, par exemple :


S t r i n g c h a i n e = Bonjour ;

On peut egalement l ecrire dune autre mani` ere :


S t r i n g c h a i n e = new S t r i n g ( Bonjour ) ;

Une string vide (sans caract` ere) peut etre cr e e ainsi :


S t r i n g s t r 1 = ; // ou b i e n S t r i n g s t r 2 = new S t r i n g ( ) ;

Les strings sont tr` es utile pour acher du texte, cest pourquoi si un objet doit etre ach e, on fait appelle ` a la fonction toString() qui existe dans toutes les classes. Cette m ethode renvoie alors une String. Un autre el ement important est que Java nous fourni beaucoup de m ethode dans la classe String. Il est donc possible de faire beaucoup de manipulation sur les strings. Cest en particulier utile pour du traitement de texte. Nous allons explorer ` a pr esent la classe String.

2.6.1

M ethode trim

La m ethode trim supprime les espaces en d ebut et en fait de string. Cest par exemple utile si une autre personne ` a rajout e par erreur des espaces, et que votre programme n etait pas con cu pour. La m ethode renvoie une nouvelle String sans les espaces.
S t r i n g trim ( )

27

public c l a s s S t r i n g T e s t a t o r { public s t a t i c void main ( S t r i n g [ ] a r g ) { S t r i n g s t r = Un e s p a c e devant e t e n t r e l e s mots . ; System . out . p r i n t l n ( s t r ) ; System . out . p r i n t l n ( s t r . t r i m ( ) ) ; } } Un e s p a c e devant e t e n t r e l e s mots . Un e s p a c e devant e t e n t r e l e s mots .

2.6.2

M ethode equal

La m ethode equal permet de comparer deux string pour savoir si elles sont identiques.
boolean e q u a l ( Object s t r i n g ) public c l a s s S t r i n g T e s t a t o r { public s t a t i c void main ( S t r i n g [ ] a r g ) { S t r i n g s t r 1 = Un e s p a c e devant e t e n t r e l e s mots . ; S t r i n g s t r 2 = Un e s p a c e devant e t e n t r e l e s mots . ; System . out . p r i n t l n ( s t r 1 . e q u a l ( s t r 2 ) ) ; } } true

2.6.3

M ethode equalIgnoreCase

La m ethode equalIgnoreCase permet de comparer deux string sans tenir compte des majuscules et minuscules.
boolean e q u a l I g n o r e C a s e ( S t r i n g s t r i n g ) public c l a s s S t r i n g T e s t a t o r { public s t a t i c void main ( S t r i n g [ ] a r g ) { S t r i n g s t r 1 = Un eSpace dEvant e t eNtre l e s mots . ; S t r i n g s t r 2 = uN esPace devAnt ET e n t r e l E s mots . ; System . out . p r i n t l n ( s t r 1 . e q u a l ( s t r 2 ) ) ; } } true

28

2.6.4

M ethode length

La m ethode length renvoie la longueur de la String.


int l e n g t h ( )

2.6.5

M ethode charAt

La m ethode charAt renvoie le caract` ere de la position choisie, les positions commencent ` a 0 jusqu` a length()-1.
char charAt ( int p o s i t i o n )

2.6.6

M ethode substring

La m ethode substring extrait une String de la String originale.


S t r i n g s u b s t r i n g ( int b e g i n p o s i t i o n , int e n d p o s i t i o n )

2.6.7

M ethode concat

La m ethode concat permet dajouter une String ` a la n de la String courante, puis renvoie ce r esultat.
String concat ( String s t r i n g ) public c l a s s S t r i n g T e s t a t o r { public s t a t i c void main ( S t r i n g [ ] a r g ) { S t r i n g s t r 1 = Un ; S t r i n g s t r 2 = s t r 1 . c o n c a t ( must ! ) ; System . out . p r i n t l n ( s t r 2 ) ; } } Un must !

Op erateur de concat enation En Java, il est aussi possible dutiliser lop erateur de concat enation +. Voici comment lexemple pr ec edent est modi e.

29

public c l a s s S t r i n g T e s t a t o r { public s t a t i c void main ( S t r i n g [ ] a r g ) { S t r i n g s t r 1 = Un ; S t r i n g s t r 2 = s t r 1 + must ! ; System . out . p r i n t l n ( s t r 2 ) ; } } Un must !

30

Chapitre 3

Conditions, boucles et tableaux


3.1 Introduction

Au chapitre 2, nous avons d ecouvert lutilit e des variables et les di erents types existants. Nous savons donc maintenant calculer avec des nombres entiers ou r eels, et nous connaissons quelques op erations el ementaires sur les cha nes de caract` eres gr ace ` a la classe String. Mais nous avons encore un vide a combler : comment faire lorsque nous devons traiter une s ` erie de donn ees identiques, de surcro t lorsquon ne sait pas ` a lavance leur nombre ? Nous pouvons certes cr eer des variables avec des noms du type donnee1, donnee2, donnee3, ... mais ce nest pas la bonne solution. Cela sav` ere rapidement inutilement complexe et peu pratique ` a utiliser en plus d etre assez peu exible. Cest alors que les tableaux simples viennent ` a la rescousse. Dans la troisi` eme partie de ce chapitre, nous allons d ecouvrir que gr ace ` a eux, il est tr` es ais e de g erer une suite de donn ees identiques. Puis nous allons ensuite voir quelles en sont les limites et explorer les tableaux dynamiques, qui eux vont plus loin en permettant avec une simplicit e extr eme de g erer des s eries de donn ees dont la quantit e varie au cours du temps. Mais avant de sattaquer ` a ces fameux tableaux, nous devons dabord apprendre ce quest une condition et une boucle, et comment sen servir pour rendre nos programmes un peu moins monotones. Nous en aurons besoin dans la quatri` eme et derni` ere partie, qui mettra en pratique tout ce que nous avons appris en m elangeant tous les ingr edients.

31

3.2

If - un mot simple qui cache une r ealit e complexe

En Java, comme dans de nombreux autres langages de programmation, une condition se mat erialise par une instruction if ainsi quune partie else (signication : sinon) optionnelle :
i f ( condition ) { // i n s t r u c t i o n s } else { // I n s t r u c t i o n s }

Les instructions qui se trouvent entre les deux premi` eres accolades ne seront r eellement ex ecut ees que si et seulement si la condition qui est entre les parenth` eses du if est vraie. Le deuxi` eme bloc (la deuxi` eme paire) sera ex ecut e au contraire si la condition consign ee par le if est fausse. Ce bloc est facultatif. Pour indiquer la condition, nous avons ` a notre disposition plusieurs op erateurs math ematiques de comparaison (liste ci-dessous). Nous pouvons bien s ur comparer des nombres entre eux et dautres objets, mais la r eelle utilit e est de comparer la valeur dune variable et un nombre ou la valeur de deux variables entre elles. Voici ci-dessous quelques exemples dinstructions de comparaison qui trouveraient leur place entre les parenth` eses dun if :
3 > 5 // 3 e s t p l u s grand que 5 . Faux dans t o u s l e s c a s . nombre <= 7 // l a v a l e u r de l a v a r i a b l e nombre e s t p l u s // p e t i t e ou egale ` a 7 nombre1 == nombre2 // l a v a l e u r de l a v a r i a b l e nombre1 e s t // egale ` a l a v a l e u r de nombre2 . nombre != 8 . 5 // La v a l e u r de nombre e s t d i f f e r e n t e de 8 . 5 true // t r u e e s t v r a i , f a l s e e s t faux , d a i l l e u r s on // p o u r r a i t a u s s i u t i l i s e r une v a r i a b l e de t y p e b o o l e a n

Il existe 6 op erateurs de base : == pour v erier l egalit e exacte (` a ne pas confondre avec le simple = qui permet dattribuer une valeur ` a une variable) 32

!= pour v erier une in egalit e >, <, >=, <= pour v erier respectivement si le premier terme est sup erieur ou inf erieur au deuxi` eme, strictement ou non. Gr ace ` a cela, nous pouvons comparer les types primitifs (les nombres) entre eux. Les variables de type boolean, qui contiennent d ej` a true ou false, peuvent etre test ees directement (Ex : if(mon boolean)) Pour comparer des objets, m eme des cha nes (String), nous ne pouvons par contre pas utiliser ces op erateurs. Il faut avoir recours ` a des m ethodes sp ecialis ees. La plus connue est equals mais il existe aussi compareTo (que nous avons vu dans le chapitre sur les cha nes). Par exemple :
String test = hello ; i f ( test . equals ( Hello )) { // i n s t r u c t i o n s }

Ici, les deux cha nes hello et Hello seront compar ees. Si elles sont equivalentes, le bloc if sera ex ecut e. Ce qui nest ici pas le cas, car la correspondance minuscules/majuscules est prise en compte. Nous en connaissons maintenant assez pour attaquer la partie suivante : les boucles

3.3

Les boucles

Dans la vie de tous les jours, il est parfois n ecessaire de r ep eter une m eme s erie dop erations plusieurs fois de suite sous certaines conditions : on se l` eve tous les matins de la semaine pour aller au travail sauf si on a les vacances par exemple, ou bien on mange trois fois dans la journ ee. On appelle une s erie dinstructions ex ecut ees plusieurs fois cons ecutives une boucle. En programmation, on fait la distinction entre deux sortes principales de boucles : celles qui sont r ep et ees un certain nombre de fois connu davance, et celles qui sont r ep et ees jusqu` a ce quune certaine condition soit ou ne soit plus remplie. Nous allons commencer par cette derni` ere, qui est plus facile.

3.3.1

la boucle while - quand on ne sait pas quand sarr eter

Comme vous laurez compris, le mot-cl e important ici est while (traduction : pendant que ou tant que ). Voici succinctement comment il sutilise :
while ( c o n d i t i o n ) {

33

// i n s t r u c t i o n s }

Les instructions qui se trouvent entre les accolades seront r ep et ees jusqu` a ce que la condition sp eci ee ` a la suite du mot-cl e while ne soit plus remplie, ou autrement dit tant que la condition est v eri ee. La syntaxe de la condition attendue est la m eme que celle utilis ee dans les blocs if/else. Voici un exemple qui demande ` a lutilisateur de taper le mot exit au clavier tant que cela na pas et e fait.
S t r i n g s a i s i e = ; Scanner i n = new Scanner ( System . i n ) ; while ( ! s a i s i e . e q u a l s ( e x i t ) ) { System . out . p r i n t l n ( Tapez e x i t pour q u i t t e r l e programme ) ; s a i s i e = i n . next ( ) ; s a i s i e = s a i s i e . trim ( ) ; }

Le point dexclamation devant la condition saisie.equals(...) permet dinverser le r esultat de la m ethode equals, ce qui revient ` a demander la non equivalence de la valeur de la variable avec exit. Le bloc entre accolades, soit le message dinvite et lattente dune saisie par lutilisateur, sera ex ecut e tant que la condition inscrite dans le while, cest-` a-dire notre non equivalence, est v eri ee. Ce qui est eectivement le cas jusqu` a ce que lutilisateur tape exactement exit . La classe Scanner utilis ee ici est assez importante et ore de nombreuses fa cons dobtenir des donn ees entr ees au clavier de mani` ere simple. Sa m ethode next permet en particulier de r ecup erer un mot sans espace, ce qui est parfaitement adapt e pour ce que nous faisons dans notre cas. Il serait tout aussi facile de demander un nombre... nous aurons loccasion de r eutiliser cette classe plusieurs fois dici la n de ce chapitre. Si vous etes int eress e` a la conna tre plus, r ef erez-vous ` a la documentation ocielle de Java sur le web. Voici maintenant un deuxi` eme exemple, celui quil ne faut surtout pas suivre, vous comprendrez pourquoi quand vous aurez essay e si vous ne tiltez pas imm ediatement :
while ( true ) { // i n s t r u c t i o n s }

34

On appelle ceci une boucle innie, ou, autrement dit, une boucle qui se r ep` ete jusqu` a ce que plantage magistral de votre pauvre ordinateur surcharg e sen suive. Le bloc est r ep et e tant que la condition est v eri ee. Or, lerreur ici est que le mot-cl e true est, par d enition, toujours vrai. Par cons equent, le programme restera ind eniment dans le bloc sans jamais en sortir. Ce type de bug est courant en cours de d eveloppement, et, heureusement pour nous, les ordinateurs modernes nous orent tous les moyens darr eter le monstre de mani` ere totalement able sans avoir ` a tirer la prise... Et voici un dernier exemple. Quen pensez-vous ?
while ( f a l s e ) { // I n s t r u c t i o n s }

Si vous avez pr edit sans tester que les instructions de cette boucle ne serait jamais ex ecut ees, vous avez parfaitement raison. Lexplication est la m eme que pr ec edemment : false etant par d enition toujours faux, la condition nest jamais v eri ee et les instructions ne sont par cons equent jamais parcourues. Ce qui nous am` ene ` a une constatation importante : la condition est evalu ee avant de parcourir les instructions associ ees. Ainsi, une boucle while peut tr` es bien ne jamais etre ex ecut ee, comme celle ci-dessus. Il existe une variante de while : la boucle do...while, dont voici la syntaxe :
do { // i n s t r u c t i o n } while ( c o n d i t i o n ) ;

Notez le point-virgule nal. Avec cette variante, la condition est toujours evalu ee apr` es les instructions. Ce qui assure quelles sont ex ecut ees au moins une fois. Le reste du processus est le m eme. Lutilisation de lune plut ot que lautre est souvent une histoire de go ut, car ces deux constructions sont pratiquement toujours interchangeables.

3.3.2

la boucle for - quand on sait ` a lavance combien de fois

Dans notre exemple pr ec edent avec lutilisateur qui etait cens e taper exit , nous ne connaissions pas davance combien dessais seraient n ecessaires avant quil ne comprenne. Avec les boucles for que nous allons voir maintenant, il en va autrement : nous connaissons en principe toujours davance le nombre de fois quune boucle for va sex ecuter. Voici rapidement la syntaxe de cette instruction :

35

f o r ( i n i t i a l i s a t i o n ; c o n d i t i o n ; i n c r ement ) { // i n s t r u c t i o n s }

Comme vous le voyez, elle est un peu plus dicile que la boucle while. On distingue trois parties entre les parenth` eses du for : Linitialisation : dans cette premi` ere partie, on cr ee g en eralement une variable de type enti` ere et on lui aecte une valeur de d epart. On appelle cette variable un compteur, et la pratique courante est de lappeler avec une seule lettre de lalphabet, souvent i, j, k ou n. On nest bien s ur pas oblig e de cr eer une nouvelle variable ` a ce moment-l` a, ni quelle soit enti` ere dailleurs et r eutiliser une autre d ej` a existante. Lavantage de la cr eer a ` cet endroit est quon limite son champ daction : la variable ainsi d eclar ee nexiste que dans le cadre de la boucle for. Une fois quelle est termin ee, la variable nexiste plus. Ce qui permet d eviter quelques erreurs diciles ` a d eboguer, et ce qui permet aussi de ne pas avoir de collisions de noms de variables lorsque plusieurs boucles se suivent ou simbriquent, ce qui est tr` es r eguli` erement le cas. La condition : De m eme que pour la boucle while, la boucle for est r ep et ee tant que la condition sp eci ee est v eri ee. Lincr ementation : Dans cette partie, on incr emente g en eralement le compteur d eclar e en premi` ere partie. Incr ementer signie litt eralement augmenter dune unit e, mais on est libre, si on le souhaite, de modier les variables que lon d esire. Nous ne devons pas obligatoirement incr ementer dune unit e` a la fois et pas obligatoirement non plus uniquement la variable compteur. On appelle parfois cette partie le pas, car elle repr esente souvent de combien la variable compteur varie ` a chaque etape successive de la boucle. Des etapes, parlons-en, car cest un peu particulier : lorsque lordinateur rencontre une boucle for, il comence par ex ecuter la partie initialisation, qui ne le sera quune seule et unique fois en d ebut de boucle. Ensuite, il evalue une premi` ere fois la condition. Si elle nest pas v eri ee, il ne va pas plus loin et quitte directement le bloc sans se poser dautres questions. Si elle lest, il parcourt les instructions dans lordre avant de passer ` a la partie incr ementation. Puis, il r e evalue la condition et eectue un nouveau tour de boucle si elle est toujours v eri ee, ou la quitte sinon. Comme cest peut- etre un peu compliqu e, voici un exemple simple qui se contente dacher successivement les nombres de 1 ` a 100 :
f o r ( int i = 1 ; i <= 1 0 0 ; i ++) { System . out . p r i n t l n ( i ) ;

36

Reprenons ce que nous avons dit plus haut : nous commen cons par la partie initialisation, qui commande de cr eer une variable int i contenant la valeur 1. Ensuite nous passons ` a la condition et nous remarquons que i est bien inf erieur ou egal ` a 100, donc on continue. Nous achons la valeur courante de la variable i, pour le moment 1. Nous passons ` a la partie incr ementation. Linstruction i++ est labr eviation de i+=1 qui lui-m eme est labr eviation de i=i+1. Nous aectons donc ` a i la valeur quil poss` ede plus une unit e, soit i=1+1=2 dans notre exemple. La variable i vaut maintenant 2 qui est toujours inf erieur ou egal ` a 100, nous achons une fois de plus la valeur de i avant de lincr ementer ` a nouveau. Et ainsi de suite jusqu` a ce que i=100+1=101 ce qui fera echouer la condition et qui commandera la sortie de boucle. Voici un deuxi` eme exemple plus int eressant : il sagira ici de calculer la factorielle dun nombre entier. Pour rappel, formellement, la factorielle dun nombre entier n se d enit comme etant le produit 1 * 2 * 3 * ... * (n -1) * n. Par exemple la factorielle de 5 est 120 car 1*2*3*4*5=120.
public int f a c t o r i e l l e ( int n ) { int r e s u l t a t = 1 ; f o r ( int i = n ; i > 0 ; i ) { r e s u l t a t *= i ; } return r e s u l t a t ; }

Cette m ethode re coit en param` etre le nombre n dont nous souhaitons calculer la factorielle. On initialise le compteur i de la boucle for ` a n. Cette fois-ci, linstruction dincr ementation est i, ce qui equivaut ` a i-=1 ou i=i -1, qui correspond ` a diminuer i dune unit e` a chaque tour de boucle. Nous faisons tourner la boucle jusqu` a ce que i arrive ` a la valeur 0. La variable r esultat contiendra au nal la valeur n * (n -1) * (n -2) * ... * 3 * 2 * 1, ce qui est pr ecis ement la d enition de la fonction factorielle. Et voil` a ! Nous pouvons enn attaquer nos fameux tableaux.

3.4

Les tableaux

Lorsque nous souhaitons manipuler une s erie de donn ees identiques, il faut utiliser un tableau. Un tableau nest rien dautre quune variable unique dans laquelle sont en fait stock es une s erie de donn ees du m eme type. Un tableau simple est d eni par son type et sa taille. Son type est le m eme 37

pour tous les el ements du tableau, il nest donc pas possible denregistrer conjointement des int et des double dans le m eme tableau. Sa taille est le nombre d el ements quil peut stocker. Une fois d enie, cette taille ne peut etre modi ee, ce qui peut etre un inconv enient assez lourd si le nombre d el ements ` a traiter varie au cours du programme. Cest pour cela quil existe les tableaux dynamiques, que nous verrons dans la section suivante de ce chapitre. Mais pour le moment, occupons-nous des tableaux simples.

3.4.1

D eclarer un tableau

D eclarer une variable tableau se fait tr` es simplement, presque comme une variable ordinaire :
int [ ] t a b l e a u ; t a b l e a u = new int [ 1 0 0 ] ;

La variable ci-dessus est un tableau de 100 valeurs int. On reconna t quil sagit dun tableau gr ace ` a la paire de crochets qui suit le mot-cl e int d enissant le type. Mais la premi` ere ligne ne sut pas pour cr eer le tableau proprement dit, pour le moment il contient, comme pour un objet non initialis e, la valeur null. Sur la deuxi` eme ligne, on rappelle quil sagit bien dun tableau de int, on pr ecise en plus le nombre d el ements quil contiendra entre crochets, ici 100. On a le choix entre indiquer un nombre xe ou alors la valeur dune variable de type int (uniquement une variable de type int). Nous aurions pu faire le tout en une seule ligne. Apr` es ces instructions, notre tableau est disponible et nous pouvons commencer ` a lutiliser. Il existe une deuxi` eme fa con de d eclarer un tableau en lui fournissant doce les valeurs par d efaut quil contiendra :
int [ ] t a b l e a u = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 1 0 } ;

Ce code cr eera un tableau de type int contenant 10 valeurs. Il est inutile de pr eciser la taille, le compilateur sen chargera en comptant directement le nombre d el ements dans les accolades. Apr` es cette instruction, nous disposons donc dun tableau de 10 el ements contenant les nombres de 1 ` a 10 dans lordre.

3.4.2

Acc eder aux valeurs dun tableau

Cest bien beau davoir d eclar e un tableau, mais cest un peu emb etant de ne pas pouvoir sen servir. An dacc eder ` a un el ement pr ecis du tableau, nous devons faire suivre le nom de la variable de lindice de l el ement auquel 38

nous souhaitons acc eder. Cet indice s ecrit entre crochets juste apr` es le nom de la variable et indique lemplacement, le num ero dordre de l el ement ` a atteindre. Ensuite, on peut manipuler notre variable comme dhabitude. Le premier el ement du tableau ne porte pas lindice 1 mais lindice 0 et le dernier lindice taille -1 au lieu de taille. Il est possible de conna tre la taille du tableau en utilisant la propri et e length, que tout tableau d eclar e poss` ede automatiquement. Exemple rapide :
int [ ] t a b l e a u = new t a b l e a u [ 5 ] ; // On d e c l a r e un nouveau // t a b l e a u de t y p e i n t c o n t e n a n t 5 e l ements tableau [ 0 ] = 123; // On a f f e c t e l a v a l e u r 123 au p r e m i e r e l ement tableau [ 4 ] = 456; // On a f f e c t e l a v a l e u r 456 au c i n q u i` eme e l ement t a b l e a u [ t a b l e a u . l e n g t h 1] = t a b l e a u [ 0 ] + t a b l e a u [ 4 ] ; // On a d d i t i o n n e l a v a l e u r du p r e m i e r e t du c i n q u i` eme // e l e m e n t e t on l a s t o c k e dans l e d e r n i e r e l e ment , q u i // e s t en f a i t l e c i n q u i` e m e ( l a v a l e u r 456 e s t donc perdue , // mais on e s t pas c e n s e l e s a v o i r , ce ne s e r a i t pas l e c a s // s i l e t a b l e a u a v a i t 6 e l e m e n t s ou p l u s ) . int n = 2 ; t a b l e a u [ n ] = 4 * n +7; // On p e u t b i e n s u r u t i l i s e r une // v a r i a b l e de t y p e i n t en t a n t qu i n d i c e . I c i , ce s e r a // donc l e t r o i s i ` eme e l e m e n t q u i s e r a m o d i f i e p u i s q u e n=2. System . out . p r i n t l n ( t a b l e a u [ 1 ] ) ; // On a f f i c h e l a v a l e u r du // deuxi` e me e l e m e n t . . . aucune v a l e u r e x p l i c i t e ne l u i a et e // a f f e c t e e , sa v a l e u r par d efaut est 0.

3.4.3

Parcourir un tableau

Nous connaissons maintenant la base de la manipulation des tableaux. Il est temps dapprendre ` a les parcourir de mani` ere ecace en utilisant les boucles que nous avons vu dans la section pr ec edente de ce chapitre. Pour parcourir un tableau, on choisit en g en eral une boucle for, et on utilise la variable compteur de la boucle comme indice de tableau. Le compteur, comme lindice de tableau, doivent varier entre 0 et tableau.length -1 et nous devons tout parcourir sans rien oublier. En principe, la boucle for d emarre donc avec un compteur ` a 0, se termine avec une valeur de tableau.length -1 et est incr ement ee de 1 ` a chaque tour. Nous connaissons donc parfaitement le nombre de tours ` a eectuer dans la boucle, do` u le choix dune boucle for 39

plut ot quune boucle while (nous aurions pu aussi le faire avec une boucle while mais cela est moins pratique). Voici un premier exemple qui ache successivement les valeurs de notre tableau de tout ` a lheure :
f o r ( int i = 0 ; i < t a b l e a u . l e n g t h ; i ++) { int elementCourant = t a b l e a u [ i ] ; System . out . p r i n t l n ( elementCourant ) ; }

Notre boucle for continue tant que i est inf erieur ` a tableau.length, donc jusqu` a la valeur limite tableau.length -1 (qui pour rappel contient le dernier el ement du tableau). A chaque nouveau tour, nous achons la valeur qui se trouve ` a lindice i du tableau. Comme i d emarre ` a 0 puis est incr ement e de 1 ` a chaque fois, nous achons successivement tableau[0], tableau[1], tableau[2], etc. jusqu` a tableau[tableau.length -1]. La boucle for am elior ee La construction pr ec edente de la boucle for etant abondamment utilis ee et relativement r ebarbative, Java nous propose un raccourci int eressant : la boucle for am elior ee (en anglais : enhanced for loop) egalement appel ee foreach, dont voici la syntaxe :
f o r ( int elementCourant : t a b l e a u ) { System . out . p r i n t l n ( elementCourant ) ; }

En r ealit e, il ny a aucune di erence entre ce code et le pr ec edent. En interne, Java utilise toujours un indice i variant de 0 ` a length -1. Lavantage de la construction am elior ee est que vous navez pas ` a vous soucier de g erer une variable comme i, mais pr esente deux inconv enients majeurs : vous navez pas acc` es ` a la valeur de lindice courant dune part, et dautre part vous etes oblig e de parcourir le tableau enti` erement et dans lordre, ce qui nest pas forc ement ce que vous voulez et qui serait parfaitement possible avec la construction pr ec edente (il sut de changer la valeur de d epart, la borne exprim ee dans la condition ou lincr ement). En pratique cependant, nous avons g en eralement besoin ni de lun ni de lautre, ce qui fait que ce raccourci est souvent bien utile.

40

3.5

ArrayList, ou les tableaux dynamiques

Dans la section pr ec edente, nous avons d ecouvert les tableaux et leur utilisation. Nous avons notamment vu quune fois le tableau cr e e et sa taille d enie, il nest plus possible de la changer. Que faire alors si nous ne savons pas exactement ` a lavance combien il y aura d el ements dans notre tableau ? Il faudrait cr eer un second tableau plus grand, recopier les el ements du petit tableau dans le grand un par un, ajouter les nouveaux el ements ` a la n du grand tableau, et enn eacer d enitivement le petit tableau pour nutiliser plus que le grand par la suite. Et il faut refaire toutes ces manipulations a chaque fois que nous faisons d ` epasser la taille que nous pensions etre la bonne. Bien s ur, cest parfaitement envisageable, mais cest inutilement lourd et peu pratique. La plupart du temps, lorsque nous manipulons des donn ees complexes, il est relativement rare que nous connaissons la quantit e ` a traiter. Bien souvent, nous ne le savons pas avant davoir r ecup er e toutes les donn ees en question, et nous ne devons pourtant ne rien oublier. Une fois de plus, Java nous ore une classe qui fera tout cela pour nous et bien plus : voici ArrayList. Les r` egles de bonnes pratiques veulent quon pr ef` ere les tableaux dynamiques aux tableaux classiques quon a vu jusquici, qui seraient, dans lid eal, r eserv es ` a des cas o` u nous connaissons le nombre d el ements ` a traiter et o` u nous savons quil ne changera plus ensuite, ou alors pour dautres contraintes sp eciques comme une rapidit e dex ecution accrue par exemple. Nous allons donc dans cette partie de chapitre d ecouvrir les principales m ethodes de cette classe. Nous ne verrons que les plus simples. Si vous voulez en savoir plus, vous pouvez vous r ef erer ` a la documentation ocielle sur le web.

3.5.1

Cr eer un tableau dynamique

Avant de pouvoir utiliser un tableau dynamique ArrayList, il faut cr eer un nouvel objet de cette classe. Un tableau dynamique ArrayList nest en fait rien dautre quun objet encapsulant un tableau classique. Cette encapsulation permet de le rendre intelligent et dynamique dans sa taille, sans que lutilisateur nal (nous !) ne se soucie du fonctionnement interne (copie de tableau, ajustement de la taille, etc.) Cr eons donc un tableau dynamique qui sera destin e` a contenir des String par exemple :
A r r a y L i s t <S t r i n g > t a b l e a u = new A r r a y L i s t <S t r i n g > ( ) ;

Comme nous pouvons le voir, il faut indiquer de quel type seront les donn ees g er ees par le tableau dynamique entre deux chevrons, ici nous avons dit que nous utiliserions un tableau de String, cest ce qui est sp eci e. Les traitements sadapteront en fonction du type choisi, et nous pouvons choisir 41

le type dobjet que nous voulons ` a lexception des types primitifs (comme int, oat, double, etc.). Dans la litt erature, on dit que le type String est un param` etre de type. Une classe acceptant un ou plusieurs param` etres de type est appel ee classe g en erique. Elle utilise la capacit e de g en ericit e de Java, ce qui ne sera pas trait e dans ce cours car bien trop complexe. Retenons que nous devons indiquer quel sera le type des donn ees utilis ees dans le tableau, nous en resterons l` a. Maintenant, nous avons notre tableau dynamique, mais il est encore vide... il est temps de le remplir.

3.5.2

Ajouter des el ements : add

Commen cons par le commencement : la m ethode add permet dajouter de nouveaux el ements en n de tableau :
public void add (E e l e m e n t )

Elle prend un seul param` etre, qui est, comme nous pouvons nous en douter, lobjet que nous voulons ajouter. Le type E est une notation g en eralis ee, et est ` a remplacer par le type eectivement d eclar e` a la cr eation de lobjet ArrayList. Nous avons pr ec edemment cr e e un tableau de String, le type E correspond donc ici au type String. Ajoutons quelques el ements ` a notre tableau de tout ` a lheure :
t a b l e a u . add ( One ) ; t a b l e a u . add ( Two ) ; t a b l e a u . add ( Three ) ; t a b l e a u . add ( Four ) ; t a b l e a u . add ( F ive ) ;

3.5.3

Obtenir la taille du tableau : size


public int s i z e ( )

La m ethode size sutilise le plus simplement du monde : elle retourne un int qui contient la taille du tableau, ce qui equivaut exactement ` a la propri et e length que nous avions vue pour les tableaux classiques. Notez quelle change en fonction des el ements que nous ajoutons ou enlevons. Cest le but des tableau dynamiques !

42

3.5.4

R ecup erer un el ement : get

Que contient le ni` eme el ement du tableau ? La m ethode get nous donne la r eponse :
public E g e t ( int i n d e x )

Ici encore appara t le param` etre g en erique E, quil faut toujours remplacer par String dans notre cas. R ecup erons puis achons donc le troisi` eme el ement :
String troisiemeElement = tableau . get ( 2 ) ; System . out . p r i n t l n ( t r o i s i e m e E l e m e n t ) ;

Si nous avez bien suivi, cela devrait acher Three. Rappelons-nous que le premier el ement porte le num ero 0, cela na pas chang e depuis ce que nous avons appris sur les tableaux classiques.

3.5.5

Modier un el ement : set


public E s e t ( int index , E e l e m e n t )

La m ethode set accepte deux param` etres : dune part la position de l el ement ` a modier, et le nouvel el ement ` a placer dans le tableau dautre part. Cette m ethode retourne l el ement qui se trouvait ` a cet emplacement avant la modication, ce qui peut parfois etre utile. Modions le dernier el ement du tableau :
t a b l e a u . s e t ( t a b l e a u . s i z e ( ) 1, Seven ) ;

3.5.6

Enlever des el ements : remove


Il existe deux fa cons di erentes dutiliser cette m etode remove :


public E remove ( int i n d e x ) public boolean remove ( Object e l e m e n t )

43

La premi` ere permet denlever l el ement ` a la position index et retourne ce qui vient d etre supprim e. La deuxi` eme permet denlever l el ement d esign e par lui-m eme, et retourne true si un tel el ement existe dans lArrayList. Fait int eressant, le trou qui fait suite ` a la suppression dun el ement est automatiquement combl e, car les el ements qui le suivent se d ecalent dun cran. Supprimons donc deux el ements de notre tableau pour lexemple :
t a b l e a u . remove ( Four ) ; t a b l e a u . remove ( 1 ) ;

3.5.7

Ins erer un el ement ` a une position arbitraire : une deuxi` eme version de add

La m ethode add vue pr ec edemment pour ajouter un el ement en n de tableau poss` ede une alternative :
public void add ( int index , E e l e m e n t )

Cette version de la m ethode add ajoute l el ement sp eci e ` a la position voulue. tout est pr evu pour que nous nayons vraiment rien ` a faire de plus : les el ements qui suivent la position dinsertion sont, comme pour la suppression, automatiquement d ecal es dun cran. Il nest de toute fa con pas possible que des el ements partagent la m eme position, alors nous sommes oblig es de les d eplacer. Ajoutons un el ement suppl ementaire pour essayer :
t a b l e a u . add ( 2 , F iv e ) ;

3.5.8

Le retour de la boucle for am elior ee

Nous savons maintenant consulter, modier, ajouter et enlever des el ements comme bon nous semble. Il nous manque encore une op eration indispensable : parcourir lensemble du tableau, pour lacher par exemple. Cest ici que la boucle for fait son retour en force. Nous avons deux alternatives : soit la boucle for normale, soit la version am elior ee que nous avons vue rapidement ` a la n de la deuxi` eme partie. Cest ici que cette derni` ere d emontre tout son int er et. Jugeons plut ot la di erence :
f o r ( int i = 0 ; i < t a b l e a u . s i z e ( ) ; i ++) { S t r i n g element = tableau . get ( i ) ;

44

System . out . p r i n t l n ( e l e m e n t ) ; }

Versus :
for ( S t r i n g element : tableau ) { System . out . p r i n t l n ( e l e m e n t ) ; }

Outre le fait d etre beaucoup plus lisible, la construction am elior ee ore un autre avantage : si un jour les concepteurs de Java d ecident de renommer la m ethode size en length, ou si, plus probable, nous d ecidons de remplacer votre ArrayList par un tableau classique ou utiliser une autre classe proposant encore plus de fonctionnalit es, nous ne serons pas oblig e de modier le code. Petit test pour voir si nous avons tout compris : essayons de dire ce qui sera ach e par les lignes ci-dessus. La solution gure ` a la n de ce chapitre.

3.5.9

Les types primitifs et petites curiosit es

Nous avons dit au d ebut de cette section sur les ArrayList que le param` etre de type ne pouvait pas etre un type primitif comme int, oat, double, etc. En fait ce nest pas tout ` a fait exact, il est toujours possible de proter des avantages de lobjet par les classes Wrapper. D eclarons pour lexemple un ArrayList de Integer :
A r r a y L i s t < I n t g e r > nombres = new A r r a y L i s t < I n t e g e r > ( ) ;

... que nous pouvons ensuite utiliser par exemple comme ceci :
nombres . add ( new nombres . add ( new nombres . add ( new nombres . add ( new nombres . add ( new Integer ( 17)); Integer (2)); Integer (9)); Integer (128)); Integer (441));

puis supprimons linteger ayant la valeur 128.


nombres . remove ( new I n t e g e r ( 1 2 8 ) ) ;

45

An de bien comprendre quelle est la m ethode utilis e, nous allons reprendre les deux alternatives propos ees de remove appliquer ` a la classe Integer.
public E remove ( int i n d e x ) public boolean remove (E e l e m e n t )

Ce qui dans notre cas concernant la classe Integer devient :


public I n t e g e r remove ( int i n d e x ) public boolean remove ( I n t e g e r e l e m e n t )

Voici encore la r eponse de notre petit test :


One Three Fi ve Seven

46

Chapitre 4

H eritage
4.1 Motivation

Lh eritage dans notre culture consiste ` a transmettre ` a une autre personne lensemble ou une partie de ce que nous poss edons. Une autre approche de lh eritage consiste en notre h eritage g en etique, cest-` a-dire que nous transmettons ce que nous sommes. La notion dh eritage en informatique reprend les deux notions pr ec edentes. Une classe h eritant dune autre re coit non seulement lensemble des m ethodes, mais egalement lacc` es aux attributs.

4.2

Le modicateur protected

Nous connaissons d ej` a les mots-cl es public et private. Lobjectif en mettant public, est de rendre la m ethode ou la donn ee accessible en dehors de la classe, et private etant de ne pas rendre la m ethode ou la donn ees accessible en dehors de la classe. Un el ement d eclar e en private ne peut pas etre h erit e par une autre classe pour des questions de s ecurit e. Sinon, il surait de toujours cr eer une classe h eritant de celle quon veut pirater. Dautre part, nous ne rendons pas les donn ees publiques. Il nous faut donc trouver un compromis pour les donn ees que nous souhaitons transmettre. Java introduit pour cela un autre modicateur nomm e protected. Ce mot-cl e, nous permet de rendre une donn ee accessible par une sous-classe, mais pas aux autres.

4.3

H eriter dune classe

La terminologie pour h eriter dune classe A vers une classe B est la suivante :
public c l a s s B extends A { // . . . }

47

Le mot extends est le mot-cl e permettant lh eritage. Nous devons aussi savoir que toute classe h erite par d efaut de la classe Object. Reprenons lexemple pr ec edent :
public c l a s s A { // . . . } public c l a s s B extends A { // . . . }

est equivalent ` a
public c l a s s A extends Object { // . . . } public c l a s s B extends A { // . . . }

Dans la litt erature, on parle souvent de superclasse, sousclasse, classe parent ou encore de classe enfant. Dans notre exemple A est la superclasse de B, ou B est la sous-classe de A. Ou analogiquement, A est la classe parent de B, ou B est la classe enfant de A. Une autre notation consiste ` a dire que B h erite ou d erive de A.

4.4

Le modicateur nal

Il est aussi important de savoir que nous pouvons emp echer lh eritage en d eclarant la classe nale avec le mot-cl e nal. Cest par exemple le cas de la classe Math en Java.
public f i n a l c l a s s Math extends Object { // . . . }

48

4.5

Overridden m ethode

Nous avons jusqu` a pr esent observ e de mani` ere g en erale le processus dh eritage. Il nous manque encore la mani` ere dont une m ethode est r e ecrite, on parle aussi doverridden, ou encore de m ethode overidd ee . Imaginons lexemple suivant :
public c l a s s BonbonCitron { private A r r a y L i s t c o m p o s i t i o n ; public BonbonCitron ( ) { c o m p o s i t i o n = new A r r a y L i s t ( ) ; c o m p o s i t i o n . add ( C i t r o n ) ; c o m p o s i t i o n . add ( S u c r e ) ; } public A r r a y L i s t g e t C o m p o s i t i o n ( ) { return c o m p o s i t i o n ; } public double g e t C a l o r i e ( ) { return 0 . 2 3 ; } } public c l a s s BonbonCitronLight extends BonbonCitron { public BonbonCitronLight ( ) { } public double g e t C a l o r i e ( ) { // r e t o u r n e 70% de l a v a l e u r du bonbon pas l i g h t . // Le p r o b l` e m e e s t que s i on a p p e l l e g e t C a l o r i e // on va a p p e l e r c e t t e m e thode e t c e l a // f e r a une b o u c l e i n f i n i e . } }

Le probl` eme, que nous avons, est que nous souhaitons acc eder ` a une m ethode dont la signature co ncide exactement avec la m ethode que nous sommes en train d editer. Nous devons pour cela apprendre un nouveau motcl e nomm e super, pour acc eder ` a un el ement de la super-classe. Notre code devient donc :
public c l a s s BonbonCitron { private A r r a y L i s t c o m p o s i t i o n ;

49

public BonbonCitron ( ) { c o m p o s i t i o n = new A r r a y L i s t ( ) ; c o m p o s i t i o n . add ( C i t r o n ) ; c o m p o s i t i o n . add ( S u c r e ) ; } public A r r a y L i s t g e t C o m p o s i t i o n ( ) { return c o m p o s i t i o n ; } public double g e t C a l o r i e ( ) { return 0 . 2 3 ; } } public c l a s s BonbonCitronLight extends BonbonCitron { public BonbonCitronLight ( ) { } // nous d e c i d o n s de c h a n g e r l e comportement de // g e t C a l o r i e ( ) pour B o n b o n C i t r o n L i g h t public double g e t C a l o r i e ( ) { // r e t o u r n e 70% de l a v a l e u r du bonbon non l i g h t . return 0 . 7 * super . g e t C a l o r i e ( ) ; } }

Nous devons encore remarquer que, comme le mot-cl e this, le mot-cl e super peut etre utilis e de mani` ere similaire dans le constructeur. Le constructeur de la superclasse est appel e avec super(), cest une convention. Tout comme this, nous pouvons aussi rajouter des arguments. Si rien nest explicit e, Java appelle le constructeur par d efaut de la superclasse.

4.6

Classe abstraite et modicateur abstract

Il arrive parfois que nous ne savons pas d enir convenablement une classe car elle est trop abstraite. En Java, nous disposons du modicateur abstract pour d eclarer une classe abstraite. Une m ethode peut etre abstract, cest-` a-dire que nous souhaitons que la m ethode existe plus tard mais que pour linstant, le comportement de cette m ethode nest pas d eni. Une donn ee par contre ne peut pas etre d eclar ee en abstract par convention. Il est important de remarquer que d` es quune m ethode de la classe est abstraite, alors la classe elle-m eme est d eclar ee abstraite. Mais la r eciproque 50

nest pas vrai, en eet nous pouvons d enir une classe abstraite sans quil y ait de m ethode abstraite. Dans ce cas, on arme que la classe construite nest pas susamment concr` ete, malgr e le fait quelle le pourrait normalement. Nous allons ` a pr esent introduire une superclasse abstraite dans notre exemple.
public abstract c l a s s Bonbon { private A r r a y L i s t c o m p o s i t i o n ; public Bonbon ( ) { c o m p o s i t i o n = new A r r a y L i s t ( ) ; } public A r r a y L i s t g e t C o m p o s i t i o n ( ) { return c o m p o s i t i o n ; } // A c t u e l l e m e n t nous ne pouvons pas d i r e combien // de c a l o r i e comporte l e bonbon ne // c o n n a i s s a n t pas sa c o m p o s i t i o n . public abstract g e t C a l o r i e ( ) ; }

Ayant cette superclasse, nous allons modier nos deux classes vu auparavant.
public c l a s s BonbonCitron extends Bonbon { public BonbonCitron ( ) { // l e c o n s t r u c t e u r par d e f a u t de l a s u p e r c l a s s e e s t // a p p e l e ce q u i r e v i e n t ` a mettre : // s u p e r ( ) ; c o m p o s i t i o n . add ( C i t r o n ) ; c o m p o s i t i o n . add ( S u c r e ) ; } // nous rendons c o n c r` e t e l a m e thode public double g e t C a l o r i e ( ) { return 0 . 2 3 ; } } public c l a s s BonbonCitronLight extends BonbonCitron { public BonbonCitronLight ( ) { } public double g e t C a l o r i e ( ) {

51

return 0 . 7 * super . g e t C a l o r i e ( ) ; } }

4.6.1

A quoi ca sert ?

Nous pouvons nous demander ` a quoi cela sert de d enir une classe qui ne nous sert ` a rien explicitement. La raison est bien dans le mot explicitement . Si un coll` egues trouve limpl ementation int eressante (dans notre cas ce sera lexemple des bonbons), il sera aussi peut etre int eress e ` a construire dautres types dobjets di erents mais similaires, qui reprennent en faite les m emes concepts. Une classe abstraite est une mani` ere de garantir que telle ou telle m ethode existera, et donc ` a posteriori il y aura les m emes concepts.

4.6.2

Ce qui nest pas permis

Tout dabord ce que nous nosons pas faire, nous pr esentons une liste non exhaustive : Instancier un objet de classe abstraite Le code suivant produira une erreur ` a la compilation, car il est interdit de cr eer un objet abstrait. Car par le mot abstract, nous informons au compilateur que la classe nest pas compl` etement utilisable ainsi.
Bonbon b = new Bonbon ( ) ;

H eberger un objet dune superclasse Le code suivant produira une erreur, nous avons bien par la notion dh eritage quun bonbon light est un bonbon, n eanmoins un bonbon (en g en eral) nest pas forc ement light.
BonbonCitronLight b = new BonbonCitron ( ) ;

4.6.3

Ce qui est permis

Nous pouvons aussi faire un certain nombre de chose :

52

Acc eder ` a une m ethode de la superclasse Si la m ethode est accessible en mode public ou protected, alors la machine virtuel de Java v eriera si bc dans le code suivant poss` ede une m ethode getComposition(), n etant pas le cas, elle v erie dans la superclasse, puis dans la superclasse de la superclasse et ainsi de suite.
BombomCitron bc = new BonbonCitron ( ) ; bc . g e t C o m p o s i t i o n ( ) ;

H eberger un objet dune sous-classe Comme vu pr ec edemment, un bonbon light est un bonbon, cest pourquoi le code suivant est correct.
BombomCitron bc = new BonbonCitronLight ( ) ; bc . g e t C o m p o s i t i o n ( ) ;

4.7

Polymorphisme

Le principe du polymorphisme signie quun el ement peut avoir plusieurs visages , pour cela observons le code suivant :
public s t a t i c double c h a n c e D e F a i r e U n e C a r r i e ( Bonbon b ) { double p = b . g e t C a l o r i e ( ) / 1 0 0 0 0 0 . 0 ; i f (p > 1.0) p = 1; return p ; }

Nous pouvons nous poser la question suivante : Qui est concr` etement la m ethode getCalorie() ? Malheureusement, personne ne pourra nous r epondre, voici la raison par un simple exemple.
System . out . p r i n t l n ( c h a n c e D e F a i r e U n e C a r r i e ( new BonbonCitron ( ) ) ) ; System . out . p r i n t l n ( c h a n c e D e F a i r e U n e C a r r i e ( new BonbonCitronLight ( ) ) ) ; 0.0000023 0.00000161

53

Nous observons que dans le premier cas, cest la m ethode getCalorie() de la classe BonbonCitron qui est choisie. Puis dans le deuxi` eme cas, cest la m ethode getCalorie() de la classe BombomCitronLight(). Le polymorphisme nest en faite quun m ecanisme informatique pour acc eder ` a la m ethode de lobjet lui-m eme, et non pas ` a la m ethode de la r ef erence. Par contre la m ethode doit exister dans la classe de la r ef erence.

4.8

Le multi-h eritages

Deux visions sarontent aujourdhui concernant le multi-h eritages. Dans la premi` ere vision, il est possible dh eriter de plusieurs classes en m emes temps, ce qui peut parfois occasionner certains probl` emes avec un anc etre en commun dans les superclasses. La seconde vision est un processus analogue sans trop de contrainte et ne poss` edant pas cette probl ematique des anc etres en communs. Le langage Java est bas e sur la deuxi` eme vision de lh eritage. Nous avons ` a disposition pour cela les interfaces, ce sont des presque classes . Elles nont pas de constructeur et elles peuvent faire du multih eritages selon la premi` ere vision.

4.8.1

Cr eer une interface

Nous pouvons cr eer une interface en utilisant le mot-cl e interface au lieu de classe. Nous pouvons aussi y d eclarer des m ethodes ou des constantes. Nous pouvons egalement voir une interface comme une sorte de classe abstraite. D enissons pour notre exemple deux interfaces :
public i n t e r f a c e CadeauDeNoel { public double g e t P r i x ( ) ; public S t r i n g getDonnateur ( ) ; } public i n t e r f a c e CadeauDeHallowin { public double g e t P r i x ( ) ; public int g e t N o t e D e P r e s t a t i o n P o u r A c u i s i t i o n ( ) ; }

4.8.2

Lh eritage dans une interface

Nous souhaitons egalement introduire une super interface Cadeau comme suit :

54

public i n t e r f a c e Cadeau { public double g e t P r i x ( ) ; }

et reformuler nos deux interfaces comme suit :


public i n t e r f a c e CadeauDeNoel extends Cadeau { public S t r i n g getDonnateur ( ) ; } public i n t e r f a c e CadeauDeHallowin extends Cadeau { public int g e t N o t e D e P r e s t a t i o n P o u r A c u i s i t i o n ( ) ; }

On souhaite egalement faire une interface repr esentant le plaisir en g en erale :


public i n t e r f a c e P l a i s i r { public double getBonheur ( ) ; }

Nous aimerions aussi faire h eriter nos deux interfaces de Plaisir, car cela nous pla t conceptuellement :
public i n t e r f a c e CadeauDeNoel extends Cadeau , P l a i s i r { public S t r i n g getDonnateur ( ) ; } public i n t e r f a c e CadeauDeHallowin extends Cadeau , P l a i s i r { public int g e t N o t e D e P r e s t a t i o n P o u r A c u i s i t i o n ( ) ; }

Finalement, nous pouvons ais ement construire du multi-h eritages avec les interfaces sans se poser des probl` emes dimpl ementation, car il ny a que des d enitions de m ethodes ou de constantes. On ne mentionne jamais comment se comporte une m ethode, on ne signale nalement que son existance.

4.8.3

Lien existant entre une interface et une classe

Pour une classe, nous savons que nous pouvons h eriter dune seule classe. Nous avons egalement vu quune classe abstraite ou une interface oblige lexistence de m ethode par la suite. 55

En Java le multi-h eritages se note sous la forme :


public c l a s s A extends B implements C, D, E { // . . . }

o` u A est une classe, B est la superclasse, et C, D, E sont des interfaces ` a h eriter. Nous observons aussi que pour h eriter dune interface, nous utilisons aussi le mot-cl e implements qui signie impl emente ou utilise . Ainsi les promesses de m ethodes doivent etre respect ees dans la classe, sans quoi elles doivent etre mise abstraites.

4.8.4

H ebergement par des r ef erences

Il est possible de cr eer des r ef erences ` a partir dinterface ou de classe abstraite, par exemple nous pouvons ecrire le code suivant :
public c l a s s BonbonCitron extends Bonbon implements CadeauDeNoel , CadeauDeHallowin { private S t r i n g from ; public BonbonCitron ( ) { c o m p o s i t i o n . add ( C i t r o n ) ; c o m p o s i t i o n . add ( S u c r e ) ; } public BonbonCitron ( S t r i n g from ) { this ( ) ; t h i s . from=from ; } public double getBonheur ( ) { return 1 0 0 . 2 5 ; } public double g e t P r i x ( ) { return 0 . 0 5 ; } public double g e t C a l o r i e ( ) { return 0 . 2 3 ; } public S t r i n g getDonnateur ( ) { return from ;

56

} public int g e t N o t e D e P r e s t a t i o n P o u r A c u i s i t i o n ( ) { return 5 ; // t o u j o u r s b i e n s i on donne un bonbon } } public c l a s s BonbonCitronLight extends BonbonCitron implements CadeauDeNoel , CadeauDeHallowin { // i n t e r f a c e s d ej` a pr e s e n t e s dans BonbonCitron // mais i l n y a aucun r i s q u e de c o n f u s i o n public BonbonCitronLight ( ) { } public BonbonCitronLight ( S t r i n g from ) { super ( from ) ; } public double g e t C a l o r i e ( ) { return 0 . 7 * super . g e t C a l o r i e ( ) ; } public double getBonheur ( ) { // on e s t d ej` a un peu moins h e u r e u x // s i on r e c o i t un bonbon l i g h t return super . getBonheur ( ) * 0 . 8 ; } } public c l a s s T e s t a t o r { public s t a t i c void main ( S t r i n g [ ] a r g ) { Bonbon b = new BonbonCitron ( ) ; b . getComposition ( ) ; CadeauDeNoel cdn = new BonbonCitron ( ) ; cdn . g e t P r i x ( ) ; CadeauDeHallowin cdh = new BonbonCitronLight ( ) ; cdh . g e t N o t e D e P r e s t a t i o n P o u r A c u i s i t i o n ( ) Cadeau c = new BonbonCitron ( ) ; c . getPrix ( ) ; P l a i s i r p = new BonbonCitronLight ( ) ; p . getBonheur ( ) ; } }

57

4.9

Le casting dun type

Nous avons vu quun objet est toujours un objet de la superclasse, mais linverse nest pas forc ement vrai. En r ealit e ce nest pas forc ement vrai , car on ne peut pas pr edire si le type correspond. N eanmoins, si nous sommes certain que le type correspond, il existe un moyen de forcer la conversion comme nous le montre lexemple suivant :
Bonbon b = new BonbonCitron ( ) ; BonbonCitron bc = ( BonbonCitron ) b ; P l a i s i r p = ( P l a i s i r )b ;

Linconv enient de cette m ethode est que si le type ne correspond pas, le programme ne sachant pas comment r eagir devra sarr eter. Java nous propose une solution moins radicale, en faisant un test de compatibilit e en premier lieu. Nous avons pour cela le mot-cl e instanceof, qui signie litt eralement de m eme type que . Lexemple suivant nous montre comment utiliser cet op erateur.
Bonbon b = new BonbonCitron ( ) ; i f ( b instanceof BonbonCitron ) { BonbonCitron bc = ( BonbonCitron ) b ; } i f ( b instanceof P l a i s i r ) { P l a i s i r p = ( P l a i s i r )b ; }

Nous connaissons ` a pr esent tous les concepts de lh eritage en Java, mais seul une longue pratique est ecace pour r eellement ma triser les concepts.

58

Chapitre 5

Introduction aux exceptions


5.1 Motivation

Nous savons tous que nous nosons pas diviser par 0, car math ematiquement cest une op eration interdite. Dans nimporte quel langage de programmation une erreur sera lev ee, et le cours normal du programme sera interrompu. Aussi si nous devons fournir une m ethode division(double i, double j) pour diviser un nombre par un autre, nous sommes bien emb et e si le deuxi` eme est z ero. Il nous faudrait donc un moyen davertir lutilisateur quun probl` eme est apparu sans pour autant arr eter le programme. Nous appellerons ce processus lexception. En Java, nous avons ` a disposition la classe Exception qui est la superclasse de toutes les types dexceptions. En soi, une exception ne contient presque rien, si ce nest un message pour indiquer plus pr ecis ement la cause de cette exception.

5.2

Lancer une exception

Une exception se lance juste avant que lerreur napparaisse. En g en eral, nous devons faire un petit test si un cas non d esirable risque de se produire, comme nous le montre lexemple suivant :
public s t a t i c double d i v i s e u r ( double a , double b ) throws A r i t h m e t i c E x c e p t i o n { i f ( b==0) throw new A r i t h m e t i c E x c e p t i o n ( ) ; return a / b ; }

Nous y remarquerons deux mots-cl es throw et throws, le premier pour eectivement lancer une exception, le second pour avertir les utilisateurs 59

quune exception de type ArithmeticException peut etre lanc ee. Nous verrons au prochain point comment attraper une tel exception.

5.3

Attraper une exception

Nous attrapons une exception lorsque chaque etape dun bout de programme est surveill e, cest pourquoi nous avons trois blocs ` a disposition : try - catch - nally. Le bloc try : tente de faire ce qui est demand e, si une exception est lanc ee, le cours normal sinterrompt et le bloc catch est appel e. Le bloc catch : intercepte une exception, il est alors temps de continuer avec un code alternatif. Il peut y avoir plusieurs blocs catch les uns ` a la suite pour traiter di erentes sources de probl` eme. Le bloc nally : sex ecute dans tout les sc enarios possibles, il est n ecessaire de nir avec le code dans ce bloc. Ce bloc est facultatif. Voici un mini-exemple pour sch ematiser :
try { // Plan A } catch ( A r i t h m e t i c E x c e p t i o n e ) { // Le p l a n A a e chou e , e t l a c a u s e e s t donn e e par System . out . p r i n t l n ( e . getMessage ( ) ) ; // On p e u t a u s s i t e n t e r de f a i r e un p l a n B, au l i e u de // simplement a f f i c h e r l a r a i s o n de l e c h e c du p l a n A } catch ( E x c e p t i o n e ) { // Hmmm, un a u t r e p r o b l` e m e e s t apparu . S i l e p r o b l` eme // f u t du t y p e A r i t h m e t i c E x c e p t i o n , i l a u r a i t et e attrap e // a v a n t . } finally { // Dans l e s deux cas , nous avons f a i t du mieux que l on // p o u v a i t e t l on s o u h a i t e c o n c l u r e a v e c l e contenu // dans ce b l o c . }

5.4

Relancer une exception

Imaginons la situation suivante, nous avons impl ement e une m ethode solveLinearEquation(double a, double b) qui repr esente l equation ax = b , nous savons aussi que la solution est de la forme x = a b . Nous aimerions donc logiquement utiliser notre m ethode diviseur(double a, double b). Nous 60

savons egalement que si b est z ero, une exception est lanc ee, nous aimerions donc lattraper, puis lancer une autre exception expliquant ` a lutilisateur que cette equation ne peut pas etre r esolue. Nous allons pour cela cr eer une classe EquationNotSolvableException qui h erite dException et lancer un objet de ce type dans notre m ethode.
public c l a s s E q u a t i o n N o t S o l v a b l e E x c e p t i o n extends E x c e p t i o n { } public c l a s s MyMathClass { public s t a t i c double d i v i s e u r ( double a , double b ) throws A r i t h m e t i c E x c e p t i o n { i f ( b==0) throw new A r i t h m e t i c E x c e p t i o n ( ) ; } public s t a t i c double s o l v e L i n e a r E q u a t i o n ( double a , double b ) throws E q u a t i o n N o t S o l v a b l e E x c e p t i o n { double x = 0 . 0 ; try { x = diviseur (a , b ); } catch ( A r i t h m e t i c E x c e p t i o n e ) { throw new E q u a t i o n N o t S o l v a b l e E x c e p t i o n ( ) ; } return x ; } }

5.5

Les exceptions - cause derreurs de conception

Observons le code suivant et imaginons ce quil fait :


public s t a t i c double s o l v e P o s i t i v e L i n e a r E q u a t i o n ( double a , double b ) throws E q u a t i o n N o t S o l v a b l e E x c e p t i o n { try { double x = s o l v e L i n e a r E q u a t i o n ( double a , double b ) ;

61

if (x < 0.0) { throw new E q u a t i o n N o t S o l v a b l e E x c e p t i o n ( ) ; // c e t t e e x c e p t i o n s e r a e l l e a u s s i a t t r a p e e dans l e // b l o c c a t c h c i d e s s o u s . } return x ; } catch ( E q u a t i o n N o t S o l v a b l e E x c e p t i o n e ) { throw new E q u a t i o n N o t S o l v a b l e E x c e p t i o n ( ) ; } finally { System . out . p r i n t l n ( Youhou ! ) ; System . out . p r i n t ( Je peux e c r i r e n i m p o r t e quoi , ) ; System . out . p r i n t l n ( c e t e x t e ne s e r a j a m a i s a f f i c h e !); } return 0 . 0 ; }

Nous devons malheureusement accepter le fait que dans tous les cas, le texte dans le bloc nally sera ach e. Nous avons vu tout au d ebut que le bloc nally est toujours ex ecut e. Sil y a un return avant que le bloc nally ait et e appel e, alors le code dans le bloc nally est ex ecut e et ce nest qu` a ce moment-l` a que le return est eectivement fait. Le m eme raisonnement est fait avec une exception lanc ee dans le bloc try ou catch.

62

Chapitre 6

Flux de chier
6.1 Motivation

Jusqu` a pr esent nous avons uniquement travaill e avec la m emoire mise ` disposition par lordinateur. Notre probl` a eme est que actuellement nous ne pouvons pas sauvegarder des donn ees sur le disque dur. Ce chapitre nous proposent une introduction dans les mani` eres d ecrire des chiers qui pourront etre lu par la suite. Nous appellerons ux ou ot de chier, la mani` ere dont linformation est ecrite. En informatique, nous distinguons deux grandes familles de ux de chier, les ux binaires et textuels. Cependant nous devons bien comprendre quil ny a que des 1 et des 0 qui sont ecrits sur le disque dur, cest pourquoi il est imp eratif de comprendre que seul linterpr etation de la donn ee est di erente. Par exemple, nous avons vu dans les types primitifs quun integer s etend sur 4 bytes et quun char s etand sur 1 byte. Imaginons que nous souhaitons ecrire le chire 1 dans un chier. Si nous voulons ecrire le caract` ere 1, nous allons ecrire un nombre binaire sur 1 byte qui a comme repr esentation 1, alors que si nous voulons ecrire linteger 1, nous allons ecrire le nombre binaire 1 sur 4 bytes ce qui fait 32 positions en base 2, cest-` a-dire 00000000000000000000000000000001. Vu que nous avons une interpr etation sur la mani` ere davoir sauvegard e la donn ee, il est logique davoir la m eme interpr etation pour la r ecup erer. Cest pourquoi dans la litt erature on nous explique quun ux en ecriture doit etre du m eme type en lecture.

6.2

La jungle des ux en Java

En Java, il y a pr` es de 60 types de ux, pour ecrire ou lire, pour un ux binaire ou textuel, pour un ux avec m emoire tampon interm ediaire (ce quon appelle buer dans la litt erature) ou non, et pour di erents types de 63

destinations (chier physique ou chier simul e via une m emoire sp ecialement allou ee). En bref, cest la jungle ! N eanmoins, depuis Java 1.5, la classe Scanner est apparue. Elle compl emente une autre classe d ej` a pr esente appel ee PrintWriter. Avec ces deux classes nous pouvons faire de la gestion de ux tr` es facilement. Dailleurs la mani` ere de g erer les ux a compl` etement chang ee depuis Java 1.5 avec lapparition de la classe Scanner.

6.3

La gestion et cr eation de ux - La nouvelle philosophie

Nous allons apprendre ` a manipuler les ux des classes Scanner et PrintWriter, puis comprendre le principe de la sp ecialisation des ux. En faisant la synth` ese de ces deux points, nous aurons la possibilit e de construire nimporte quel ux, selon nos besoins.

6.3.1

La classe File

Java dispose dune classe File, cela nous permet davoir un point dacc` es au disque dur. N eanmoins, le chier h eberg e dans lobjet de cette classe est logique, et donc pas forc ement physique. Il se peut quun chier nexiste pas, comme nous le montre lexemple suivant, car il est en eet peu probable que Windows int` egre un r epertoire Linux dans son r epertoire syst` eme. N eanmoins, Java ne nous emp eche pas de cr eer un objet avec comme destination de chier C :/Windows/Linux/linux.bin .
F i l e f = new F i l e ( C: \ Windows \ Linux \ l i n u x . b i n ) ;

Nous avons pour eviter ce probl` eme, une m ethode qui nous permet de v erier si le chier existe ` a lendroit sp eci e. La m ethode sappelle exists() et renvoie true si le chier existe et false sinon.
F i l e f = new F i l e ( C: \ Windows \ Linux \ l i n u x . b i n ) ; if ( ! f . exists ()) { System . out . p r i n t l n ( Le f i c h i e r n e x i s t e pas . ) ; }

An de simplier la structure en Java, un dossier est aussi un chier , cest pourquoi Java propose deux autres m ethodes isFile() et isDirectory(). Dans le cas o` u le chier respectivement le r epertoire nexisterait pas, la 64

m ethode renvoie false comme nous le montre lexemple suivant.


F i l e f = new F i l e ( C: \ Windows \ Linux \ l i n u x . b i n ) ; if ( f . isFile ()) { System . out . p r i n t l n ( C e s t un f i c h i e r . ) ; } F i l e d = new F i l e ( C: \ Windows \ Linux ) ; i f (d . isDirectory ()) { System . out . p r i n t l n ( C e s t un d o s s i e r . ) ; }

A pr esent que nous avons vu les sp ecicit es de la classe File nous pouvons apprendre ` a placer un ux de chier sur un chier.

6.3.2

La classe PrintWriter

En premier, nous devons instancier un objet. Nous appelons donc un des constructeurs que Java nous proposent, parmi eux il y a les suivants :
public public public public PrintWriter ( String fileName ) PrintWriter ( F il e f i l e ) P r i n t W r i t e r ( OutputStream out ) P r i n t W r i t e r ( Writer out )

Nous devons remarquer quappeler le premier constructeur, ne va en fait appeler que le deuxi` eme. En eet,
P r i n t W r i t e r monFlux = new P r i n t W r i t e r ( HelloWorld . t x t ) ;

est equivalent ` a
P r i n t W r i t e r monFlux = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ;

Les deux autres constructeurs seront utilis es lors de sp ecialisation, nous reviendrons un plus tard sur ce sujet. Nous allons ` a pr esent explorer les possibilit es que la classe PrintWriter nous fournie. Nous allons apprendre comment ecrire une donn ee et comment la classe la g` ere, mais egalement apprendre ` a travailler avec un minimum de ressources, car elles sont souvent limit ees par votre syst` eme op erationnel. 65

1er principe Un ux est une ressource limit ee du syst` eme. Il est donc n ecessaire de lui rendre aussi vite que possible. En dautres termes ` a partir du moment que nous nen avons plus besoin nous redonnons la ressource au syst` eme. Ainsi, un ux apr` es navoir plus aucune utilit e doit etre ferm e, pour cela nous disposons de la m ethode close().
P r i n t W r i t e r monFlux = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ; // J e c r i s p l e i n de donn e es s u r HelloWorld . t x t // Je n a i ` a pr e s e n t p l u s b e s o i n de mon f l u x monFlux . c l o s e ( ) ;

2` eme principe Un ux de type PrintWriter poss` ede une m emoire tampon, ainsi ce quon croit ecrire dans le chier ne lest pas automatiquement. En eet, les acc` es au disque sont co uteux . Il est donc pr ef erable d ecrire plusieurs donn ees a la suite en une seule fois. Cest pourquoi dans le cas o` ` u nous jugeons quil est n ecessaire ou imp eratif d ecrire les donn ees dans le chier, il nous faut vider la m emoire tampon. Cette m ethode sappelle ush(). La m ethode close() appelle aussi ush() avant de cl oturer d enitivement le ux.
P r i n t W r i t e r monFlux = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ; // J e c r i s p l e i n de donn e es s u r HelloWorld . t x t monFlux . f l u s h ( ) ; // J a i a ` pr e s e n t l a g a r a n t i e que t o u s ce q u i f u t // e c r i t l e s t e f f e c t i v e m e n t sur l e f i c h i e r . // J e c r i s e n c o r e q u e l q u e s donn e es . // Je n a i ` a pr e s e n t p l u s b e s o i n de mon f l u x , monFlux // v i d e sa m e moire tampon a v a n t de s e c l oturer . monFlux . c l o s e ( ) ;

Les m ethodes pour ecrire Pour pouvoir ecrire une donn ee nous disposons de deux m ethodes print et println, la deuxi` eme etant comme la premi` ere ajoutant en plus une ligne suppl ementaire dans le chier. Voici un eventail des m ethodes ` a disposition :

66

public public public public public public public

void void void void void void void p r i n t ( boolean b ) p r i n t ( char c ) p r i n t ( double d ) print ( float f ) p r i n t ( int i ) p r i n t ( long l ) print ( String s )

ainsi que les m ethodes ajoutant en plus un saut de ligne :


public public public public public public public void void void void void void void p r i n t l n ( boolean b ) p r i n t l n ( char c ) p r i n t l n ( double d ) println ( float f ) p r i n t l n ( int i ) p r i n t l n ( long l ) println ( String s )

Nous avons aussi ` a disposition une m ethode println() qui ne fait quun saut de ligne, elle est tr` es utile pour ajouter un saut de ligne apr` es avoir ecrit plusieurs donn ees sur une m eme ligne.
P r i n t W r i t e r monFlux = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ; monFlux . p r i n t ( 1 2 ) ; monFlux . p r i n t ( true ) ; monFlux . p r i n t ( c ) ; monFlux . p r i n t l n ( ) ; monFlux . f l u s h ( ) ; monFlux . p r i n t ( Toto ) ; monFlux . p r i n t l n ( 1 4 ) ; monFlux . c l o s e ( ) ;

Le code source suivant produira le contenu de chier suivant :


12 t r u e c Toto14

67

Nous avons acquis ` a pr esent une premi` ere approche pour l ecriture dun chier, qui consiste en les deux principes ainsi que l ecriture proprement dite. Actuellement, nous navons pas encore en notre connaissance tous les concepts pour pouvoir relire notre chier et ainsi r ecup erer nos donn ees. Ce sera notre principal objectif lors des trois points suivants.

6.3.3

La classe Scanner

Nous savons d ej` a que cette classe est dune part r ecemment apparue, mais aussi quelle nous permettra de lire des donn ees pr ealablement ecrites. En comparaison avec la classe PrintWriter, nous dirons que le premier principe est toujours valable, mais que le deuxi` eme se fait de mani` ere camouer. En eet, lobjet Scanner lit en avance une partie des donn ees, et y fait acc` es lors de nos requ etes. Dans la m eme philosophie, il ny a pas de sens ` a avoir une m ethode ush(). A nouveau, Java nous propose plusieurs constructeurs :
Scanner ( S t r i n g s o u r c e ) Scanner ( F i l e s o u r c e ) Scanner ( InputStream s o u r c e ) Scanner ( Readable s o u r c e )

Il est n ecessaire de remarquer que :


Scanner monFlux = new Scanner ( HelloWorld . t x t ) ;

nest pas du tout equivalent ` a


Scanner monFlux = new Scanner ( new F i l e ( HelloWorld . t x t ) ) ;

Nous allons encore observer un peu plus en profondeur comment, le constructeur Scanner(String str) est utilis e.
Scanner monFlux = new Scanner ( 13 c t r u e 4 5 ) ; int i = monFlux . n e x t I n t ( ) ; // i =13 char c = monFlux . nextChar ( ) ; // c = c boolean b = monFlux . ne xt Bo o l e an ( ) ; // b=t r u e long l = monFlux . nextLong ( ) ; // l =45

68

Les m ethodes pour lire Nous allons ` a pr esent voir plus en profondeur comment lon r ecup` ere les donn ees, mais il est aussi important de v erier que la donn ee que nous allons lire est eectivement du type que nous attendons.
public public public public public public public public boolean boolean boolean boolean boolean boolean boolean boolean hasNextBoolean ( ) hasNextByte ( ) hasNextDouble ( ) hasNextFloat ( ) hasNextInt ( ) hasNextLine ( ) hasNextLong ( ) hasNextShort ( )

Dans le cas o` u la r eponse a ` cette question est true, nous devons extraire la donn ee avec la m ethode correspondante :
public public public public public public public public boolean n e xt B o ol e a n ( ) byte nextByte ( ) double nextDouble ( ) float nextFloat () int n e x t I n t ( ) String nextLine () long nextLong ( ) short n e x t S h o r t ( )

Ainsi par exemple, nous pouvons lire un integer puis un boolean :


Scanner monFlux = new Scanner ( new F i l e ( HelloWorld . t x t ) ) ; int i = 0 ; boolean b = f a l s e ; i f ( monFlux . h a s N e x t I n t ( ) ) { i = monFlux . n e x t I n t ( ) ; } i f ( monFlux . hasNextBoolean ( ) ) { b = monFlux . ne x t Bo o l e an ( ) ; } monFlux . c l o s e ( ) ;

Cependant, nous souhaitions lire les deux donn ees en m eme temps, ce qui nest malheureusement pas le cas si par exemple ce nest pas un integer qui 69

est lu en premier. Nous devons etre plus vigilant, cest pour cela que d` es quune attente nest pas satisfaite, nous devons quitter le cheminement normal. Voici une premi` ere approche :
Scanner monFlux = new Scanner ( new F i l e ( HelloWorld . t x t ) ) ; int i = 0 ; boolean b = f a l s e ; i f ( monFlux . h a s N e x t I n t ( ) ) { i = monFlux . n e x t I n t ( ) ; i f ( monFlux . hasNextBoolean ( ) ) { b = monFlux . ne x t Bo o l e an ( ) ; } } monFlux . c l o s e ( ) ;

La deuxi` eme approche consiste ` a lire aveuglement les donn ees sans se pr eoccuper de la justesse du type, si une m ethode rencontre un probl` eme une exception est alors lanc ee.
try { Scanner monFlux = new Scanner ( new F i l e ( HelloWorld . t x t ) ) ; int i = monFlux . n e x t I n t ( ) ; boolean b = monFlux . ne x t Bo o l e an ( ) ; monFlux . c l o s e ( ) ; } catch ( E x c e p t i o n e ) { // Un p r o b l` e m e e s t apparu . }

6.3.4

La sp ecialisation dun ux

La sp ecialisation dun ux consiste ` a rajouter des etapes interm ediaires dans le traitement de la donn ee entre le moment de lecture/ ecriture dans le chier et le moment de mise en m emoire. Nous connaissons d ej` a deux types de traitement : binaire ou ` a caract` ere, mais il y a egalement avec ou sans m emoire tampon suppl ementaire, ainsi que sur chier ou autre (par exemple sur une m emoire emul ee). Voici un exemple de sp ecialisation farfelu mais possible :
P r i n t W r i t e r pw = new P r i n t W r i t e r ( new DataOutputStream (

70

new BufferedOutputStream ( new FileOutputStream ( new F i l e ( dummystream . t x t ) ) ) ) ) ;

Nous avons ici, des ux imbriqu es les uns dans les autres, lorsque nous appelons une m ethode, le ux appelle la/les m ethodes correspondante(s) et ainsi de suite. Ce qui permet ` a chacun des ux de faire le travail qui lui est propre puis de transmettre linformation plus loin.

6.3.5

La s erialisation dune donn ee

Nous allons ` a pr esent apprendre le principe dune donn ee s erialis ee. Auparavant, nous avions le souhait quune donn ee ecrite puisse etre ` a son tour etre lue sans perte, ni superux, ce principe sappelle la s erialisation. Nous allons apprendre donc ` a eviter les pi` eges qui nous font perdre la s erialisation ainsi quun temps pr ecieux lorsque nous ne reconnaissons pas imm ediatement la source du probl` eme. Le type de ux Nous devons absolument avoir des types de ux entrant et sortant de m eme sorte. Dans le cas contraire, il ny aucune garantie que la donn ee sera interpr et ee de la m eme fa con ` a l ecriture qu` a la lecture. Le retour de ligne non trait e Nous avons tendance ` a ecrire une donn ee avec une m ethode println(... data) pour un type voulu. Et nous souhaitons relire le type avec la m ethode next...(). Or, nous avons oubli e de r ecup erer le caract` ere de n ligne dans le chier ! Il faut pour cela encore appeler nextLine() pour lire ce dernier caract` ere.
P r i n t W r i t e r out = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ; out . p r i n t l n ( 1 6 ) ; out . p r i n t l n ( true ) ; out . p r i n t ( 1 3 2 ) ; out . p r i n t l n ( MyEndString ) ; out . c l o s e ( ) ; Scanner i n = new Scanner ( new F i l e ( HelloWorld . t x t ) ) ; int i = i n . n e x t I n t ( ) ; in . nextLine ( ) ; boolean b = i n . n e xt B o ol e a n ( ) ; in . nextLine ( ) ;

71

int j = i n . n e x t I n t ( ) ; String s t r = in . nextLine ( ) ; in . close ( ) ;

Le probl` eme avec les types num eriques Le probl` eme avec les types num eriques napparait quavec les ux ` a caract` ere, cependant vu que nous pouvons changer la sp ecialisation en une ligne, nous devons nous en occuper pour tout les ux en pr evention dune manipulation ult erieure du code.
P r i n t W r i t e r out = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ; out . p r i n t ( 3 4 ) ; out . p r i n t ( 2 1 ) ; out . c l o s e ( ) ;

produira le contenu suivant dans le chier :


3421

Notre probl` eme est que si nous lisons notre sortie de chier comme nombre, il nen verra logiquement quun seule. Cest la raison pour laquelle nous utilisons la m ethode ajoutant en plus une n de ligne. En dautres termes :
P r i n t W r i t e r out = new P r i n t W r i t e r ( new F i l e ( HelloWorld . t x t ) ) ; out . p r i n t l n ( 3 4 ) ; out . p r i n t l n ( 2 1 ) ; out . c l o s e ( ) ;

qui nous produit la sortie suivante, laquelle permet de lire les deux nombres distinctement :
34 21

72

Conclusion
Pour aller plus loin
Parce que lunivers de Java est vaste et complexe, parce quil est dicile de sy retrouver seul, et parce quon apprend par la pratique et jamais mieux quen autodidacte, voici une s erie de liens vers dautres tutoriels ou documentations qui vous permettront dapprofondir vos connaissances : http://pagesperso-orange.fr/emmanuel.remy/ (fr) Lexcellent site personnelle dun ing enieur qui pr epare des tutoriels pour Java, mais aussi pour C++. Au coeur de Java 2 - Volume 1- Notions fondamentales, Cay S. Horstmann , Gary Cornell (fr) Java - t ete la premi` ere, Bert Bates, Kathy Sierra (fr) http://java.developpez.com/livres/javaEnfants/ (fr) Java pour les enfants, les parents et les grands-parents. Un cours similaire ` a celuici qui reprend les bases et va plus loin avec la programmation dinterfaces graphiques. http://java.sun.com/docs/books/tutorial/ (en) The Java Tutorial. Le tutoriel ociel de Sun, qui couvre pratiquement tous les aspects du langage, depuis les bases de la programmation orient ee objet jusqu` a la programmation dinterfaces graphiques en passant par la gestion du multim edia et du r eseau. http://java.developpez.com/faq/java/ (fr) FAQ Java contenant des questions-r eponses divers sur les el ements du langage. http://java.sun.com/javase/6/docs/api/ (en) Lindispensable documentation ocielle de Java 6. M eme si la documentation est une vraie jungle, elle permet pratiquement toujours de trouver la classe ou la m ethode qui nous manque, et permet parfois de d ecouvrir des fonctionnalit es m econnues. Elle est donc bien plus quun simple aidem emoire qui renseigne sur les param` etres des m ethodes et lutilisation des classes.

73

Le mot de la n
Nous arrivons au terme de nos 154 minutes que nous nous etions initialement x ees. Peut- etre avez-vous mis plus, ou moins de temps. Peut- etre ce manuel a tenu ses promesses et vous avez eectivement appris les bases de Java en une seule apr` es-midi, ou bien il ne les a pas tenues et vous avez au contraire pris beaucoup plus de temps car certains points n etaient pas clairs. Dans tous les cas, nh esitez pas ` a relire les passages que vous navez pas bien compris, car il est vraiment tr` es important que vous ma trisiez les fondations, an que rien ne s ecroule lorsque vous d eciderez dajouter des etages suppl ementaires. Ce nest pas grave de ne pas tout r eussir du premier coup. Lexp erience ne sacquiert de toute fa con pas en un jour et la seule mani` ere de progresser est de pratiquer. Comme son nom lindique, ce manuel dintroduction nest h elas quune introduction et ne propose de loin pas susamment de pratique pour pouvoir pr etendre conna tre Java dans les d etails. Nous lavions dit d` es le d epart, ce n etait pas notre but, loin sen faudrait pour y parvenir. Quoi quil en soit, nous sommes cependant persuad es quune fois arriv e ici, vous ne vous arr eterez pas en si bon chemin et que vous chercherez a ` en savoir plus sur ce fabuleux langage quest Java. Ce nest plus le moment de vous d ecourager : il est maintenant temps de passer ` a la vitesse sup erieure et de commencer ` a faire des programmes v eritablement int eressants. Tel Cristophe Colomb, vous venez tout juste de d ebarquer sur un nouveau continent. Un nouveau monde plein de satisfactions et de plaisir sore d` es ` a pr esent ` a vous. Bien s ur, il y aura aussi des surprises et des epreuves ` a surmonter, mais rien nest impossible, car vous connaissez maintenant les indispensables pour bien vous orienter dans cet environnement aux dimensions presque innies. Bonne conqu ete !

74