Programmation avecle langage Java

CENTRE DE CALCUL ET DES SYSTMES D'INFORMATIONNORBERT KAJLER

JEAN-MICHEL VIOVY ET L'QUIPE DU CCSI

v 1.22 (octobre 2014)

Table des matires

Objectifs 11

Pourquoi Java ? 13

I - Introduction 15 A. Les langages de programmation............................................................15

B. Origine et historique de Java................................................................18

C. Java aujourd'hui..................................................................................18

D. Caractristiques techniques de Java......................................................19

E. Qualits et dfauts de Java...................................................................20

F. JRE, Java SE, JDK, Eclipse, ..................................................................21

G. Les diffrentes ditions du langage Java...........................................22

H. Langages et technologies connexes.......................................................22

II - Syntaxe de base 25 A. Premiers exemples..............................................................................25

B. Variables, types, porte, commentaires, .............................................26 1. Variables et types.............................................................................................26 2. Types primitifs ............................................................................................26 3. Le type boolen................................................................................................27 4. Le type caractre..............................................................................................27 5. Les types entiers..............................................................................................28 6. Les types flottants............................................................................................28 7. Constantes......................................................................................................29 8. Dclaration et porte des variables.....................................................................30 9. Conventions de nommage.................................................................................30 10. Commentaires................................................................................................31

C. Oprateurs.........................................................................................31 1. Principaux oprateurs.......................................................................................31 2. Oprateurs arithmtiques..................................................................................32 3. Oprateurs de comparaison...............................................................................33 4. Oprateurs boolens.........................................................................................33 5. Oprateurs bit--bit..........................................................................................34 6. Oprateurs d'affectation....................................................................................34 7. Oprateurs d'incrmentation et de dcrmentation...............................................35 8. Autres oprateurs.............................................................................................35 9. Priorit des oprateurs......................................................................................35

D. Blocs, instructions de contrle (tests, boucles, )...................................36 1. Instructions et blocs.........................................................................................36 2. Instructions de contrle.....................................................................................37 3. Excution conditionnelle....................................................................................37 4. Cas multiples...................................................................................................38 5. Boucles de rptitions.......................................................................................39 6. Boucles d'itration............................................................................................40

3

7. Boucles d'itration simplifies .......................................................................40 8. Interruptions des boucles, labels........................................................................41

E. Entres-sorties....................................................................................42

F. Exemple de programme, compilation, excution......................................45

III - Rfrences, tableaux, chanes de caractres, types numrs simples 47

A. Rfrences.........................................................................................47

B. Tableaux............................................................................................48

C. Chanes de caractres..........................................................................53

D. Types numrs simples......................................................................55

E. Rfrences constantes.........................................................................56

IV - Fonctions 57 A. Introduction.......................................................................................57

B. Type de retour et instruction return.......................................................58

C. Appel (ou invocation ) de fonction....................................................59

D. Fonction et porte...............................................................................59

E. Programme principal............................................................................60

F. Passage des paramtres.......................................................................60

G. Rcursivit.........................................................................................62

H. Surcharge (ou overloading )............................................................62

I. Fonctions nombre variable d'arguments...............................................62

J. Fonctions natives ...........................................................................63

V - Algorithmique, complexit, tris 65 A. Algorithme.........................................................................................65

B. Calculabilit........................................................................................66

C. Heuristique.........................................................................................67

D. Complexit, efficacit..........................................................................67

E. Algorithmique, classification des algorithmes, ......................................69

F. Problmatique du tri............................................................................69

G. Tri par slection..................................................................................70

H. Tri par insertion..................................................................................71

I. Tri bulle..............................................................................................72

J. Tri rapide............................................................................................74

K. Complexit des algorithmes de tri.........................................................77

VI - Programmation par objets 79 A. Vocabulaire (classe, instance, objet, ...).................................................79

B. Classes, instances, .............................................................................80 1. Classe.............................................................................................................80 2. Attributs..........................................................................................................81

4

3. Mthodes........................................................................................................81 4. Constructeur....................................................................................................81 5. Instanciation (mot-cl : new).............................................................................82 6. Tableau d'objets...............................................................................................83 7. L'instruction instanceof......................................................................................83 8. Destructeur.....................................................................................................84

C. This...................................................................................................84 1. this(...) dans un constructeur.............................................................................84 2. this comme rfrence........................................................................................84

D. Static................................................................................................85 1. Mot-cl static...................................................................................................85 2. Attribut statique...............................................................................................85 3. Initialiseur statique...........................................................................................86 4. Mthode statique..............................................................................................87 5. Appel de mthode statique................................................................................87 6. Static or not static ?..........................................................................................88

E. Visibilit.............................................................................................88

F. Types numrs..................................................................................89

VII - Exceptions 91 A. Principe des exceptions........................................................................91

B. Gestion des erreurs.............................................................................91

C. Traitement des exceptions....................................................................93

D. Nature des exceptions.........................................................................93

E. Catgories d'exceptions........................................................................94

F. Exceptions contrles ou non................................................................94

G. Types d'exception usuels.....................................................................95

H. Lancement d'exception........................................................................95

I. Cration de nouveaux types d'exception.................................................96

J. Clause throws......................................................................................96

K. Assertions..........................................................................................97

VIII - Entres - Sorties 99 A. Catgories de flux et classes connatre................................................99

1. Les 4 grandes catgories de flux abstraits............................................................99 2. Principaux flux concrets .............................................................................100 3. Conversions pour flux binaire...........................................................................101 4. Autres conversions de flux...............................................................................101

B. Fiches pratiques (exemples)...............................................................101 1. En pratique : criture d'un fichier texte ........................................................101 2. En pratique : lecture d'un fichier texte sans Scanner......................................103 3. En pratique : lecture d'un fichier texte avec Scanner......................................103 4. En pratique : criture d'un fichier binaire ......................................................105 5. En pratique : lecture d'un fichier binaire .......................................................106

C. Autres classes connatre..................................................................107 1. Entres-sorties en mode random .................................................................107 2. Manipulation de fichiers et rpertoires...............................................................108

5

IX - Listes, piles, files, arbres 109 A. Problmatique commune....................................................................109

B. Listes...............................................................................................110 1. Introduction...................................................................................................110 2. Fonctions de manipulation...............................................................................111 3. Implantation..................................................................................................112 4. Applications...................................................................................................113

C. Piles................................................................................................113 1. Introduction...................................................................................................113 2. Fonctions de manipulation...............................................................................114 3. Piles : implantation.........................................................................................114 4. Application.....................................................................................................115

D. Files................................................................................................116 1. Introduction...................................................................................................116 2. Fonctions de manipulation...............................................................................116 3. Implantation..................................................................................................117 4. Applications...................................................................................................117

E. Arbres..............................................................................................117 1. Introduction...................................................................................................117 2. Rcursivit....................................................................................................117 3. Vocabulaire....................................................................................................118 4. Arbres binaires...............................................................................................118 5. Numrotation des nuds.................................................................................118 6. Parcours........................................................................................................119 7. Exemple de parcours RGD en java....................................................................119 8. Fonctions de manipulation d'arbres binaires.......................................................119 9. Implantation..................................................................................................120 10. Applications.................................................................................................120

X - Paquetages, importation 123 A. Paquetage........................................................................................123

B. Paquetage et visibilit........................................................................123

C. Importation......................................................................................124

D. Nommage des paquetages.................................................................124

E. Organisation en fichiers, compilation et excution..................................124

F. Paquetages standards de Java.............................................................125

XI - Complments sur les classes 127 A. Niveaux de visibilit...........................................................................127

B. Classes ou interfaces internes.............................................................128

C. Classes locales et classes anonymes....................................................128

D. Hritage, classe racine, .....................................................................129 1. Notion de hirarchie de classes.........................................................................129 2. Hritage........................................................................................................129 3. Hritage, attributs et mthodes........................................................................130 4. Hritage et visibilit........................................................................................130 5. Hritage et rfrences.....................................................................................130........................................................................................................................131 6. Hritage et constructeurs................................................................................131........................................................................................................................131 7. Redfinition, spcialisation, masquage...............................................................131........................................................................................................................132 8. Polymorphisme dynamique..............................................................................132 9. Mthode abstraite...........................................................................................132 10. Classe abstraite............................................................................................133

6

11. Classe non drivable.....................................................................................133 12. Mthode non redfinissable............................................................................133 13. Hritage et tableau.......................................................................................134 14. la classe Object .......................................................................................134 15. Mthode clone()...........................................................................................136 16. Programmation gnrique via la classe Object.............................................136

E. Introspection....................................................................................137

XII - Interfaces 139 A. Interfaces.........................................................................................139

B. Exemple d'interfaces..........................................................................140

C. Autres exemples d'interfaces..............................................................140

D. Interfaces prdfinies en Java............................................................141

E. Hritage entre interfaces....................................................................141

F. Implantation d'une interface par une classe..........................................141

G. Interface dans une dclaration d'attribut, variables, .............................141

H. Interfaces en paramtres de mthodes................................................142

I. Interfaces marqueurs ....................................................................142

J. Interfaces Serializable, Externalizable et mot-cl transient......................143

K. Interfaces fonctionnelles....................................................................144

L. Passage d'une fonction/mthode en paramtre de mthode....................144

M. Mthodes par dfaut.........................................................................146

N. Corps de mthodes statiques dans une interface...................................146

O. Comparaison interfaces / classes abstraites..........................................147

XIII - Collections (listes, ensembles, files, tables) 149 A. Introduction......................................................................................149

B. Deux versions : paramtre ou pas................................................150

C. Les classes Collections et Arrays.........................................................151

D. Fiches pratiques et exemple d'utilisation..............................................151 1. Utilisation d'une liste.......................................................................................151 2. Parcours avec un Iterator................................................................................151 3. Exemple d'utilisation de la classe LinkedList.......................................................152 4. Dfinition d'une relation d'ordre / l'interface Comparable.....................................153 5. Dfinition d'ordres multiples / l'interface Comparator..........................................153

E. Principales interfaces et classes...........................................................154 1. L'interface Collection.......................................................................................154 2. L'interface Iterator..........................................................................................154 3. Les listes / interface List..................................................................................154 4. L'interface ListIterator.....................................................................................155 5. Les piles / classe Stack....................................................................................155 6. Les ensembles / interfaces Set et SortedSet.......................................................156 7. Les files d'attente / interface Queue..................................................................156 8. Implantations de l'interface Queue....................................................................157 9. Les tables d'association / interface Map.............................................................157 10. Table d'association trie / interface SortedMap.................................................157 11. Principales implantations de l'interface Map......................................................158 12. Collections et enum.......................................................................................158

7

XIV - Le paquetage java.lang 159 A. Le paquetage java.lang......................................................................159

B. La classe Math..................................................................................160

C. La classe StrictMath...........................................................................161

D. La classe System..............................................................................161

E. La classe Runtime..............................................................................162

F. La classe Process...............................................................................162

G. Les classes enveloppes .................................................................162

H. La classe Character...........................................................................163

I. La classe Number et ses classes filles...................................................163

J. La classe Enum..................................................................................164

K. La classe Class..................................................................................164

L. La classe Field...................................................................................165

M. La classe Method..............................................................................166

N. Interfaces pr-dfinies connatre......................................................166

XV - Autres classes et interfaces connatre 167 A. Le paquetage java.util.......................................................................167

B. Les classes Scanner et Pattern............................................................168

C. La classe Random..............................................................................170

D. La classe Objects..............................................................................171

E. Localisation et internationalisation.......................................................172

XVI - Documentation automatique (javadoc) 175

XVII - Annotations 177 A. Annotations......................................................................................177

B. Annotations standards (prdfinies) en Java.........................................178

C. Dfinition d'annotations.....................................................................178

D. Le checker framework ..................................................................179

XVIII - Graphisme et Interface Homme-Machine (IHM) 181 A. Introduction......................................................................................181

B. Composants prdfinis d'AWT.............................................................182

C. Utilisation des conteneurs...................................................................184

D. Gestionnaires de prsentation.............................................................184

E. vnements et programmation vnementielle.....................................186

F. Dessiner...........................................................................................192

G. Couleurs..........................................................................................193

H. Polices de caractres.........................................................................193

I. Images.............................................................................................194

8

J. Dimensions de l'cran et des composants.............................................195

K. Applet vs application..........................................................................196

L. Ecrire une applet...............................................................................196

M. Ecrire une application graphique.........................................................201

N. Swing..............................................................................................202

O. Pour aller plus loin............................................................................205

XIX - Processus lgers (threads) 207 A. Programmation multi-threade...........................................................207

B. Thread.............................................................................................208

C. Classe Thread...................................................................................208

D. Cration de threads...........................................................................208

E. Suspension / arrt de thread..............................................................209

F. Exemple de thread.............................................................................209

G. Synchronisation des donnes..............................................................210

H. Synchronisation des excutions..........................................................210

I. Blocages...........................................................................................211

J. Priorits des threads..........................................................................211

K. Groupement de threads.....................................................................212

L. Penser utiliser la documentation.......................................................212

XX - Programmation rseau 215 A. Paquetage java.net............................................................................215

B. Accs aux protocoles Internet.............................................................215

C. Exemple d'utilisation de la classe URL..................................................216

D. Connexion rseau bas niveau.............................................................216

E. Exemple de Client..............................................................................217

F. Exemple de serveur...........................................................................217

G. Penser utiliser la documentation.......................................................218

XXI - Annexe : ressources complmentaires sur Java 219

XXII - Annexe : ressources complmentaires sur l'algorithmique 223

Index 225

9

Objectifs

Ce document est conu pour servir de support de cours principal au tronc commund'Informatique.Il couvre au plus prs les aspects algorithmique et programmation de cet enseignement(mais pas les aspects architecture des ordinateurs et systmes d'exploitation pour lesquelsd'autres documents ont t distribus) en suivant autant que possible l'ordre des sances.Il comporte un certain nombre de complments et d'exemples qui ne seront pasncessairement dtaills lors des petites classes.Il ne saurait toutefois remplacer un ouvrage de rfrence sur le langage Java, ousur l'algorithmique, et encore moins l'ensemble des documentations, cours etbases d'exemples disponibles via le site web de l'Ecole.NOTE : ce support de cours a pour origine un diaporama sur la programmation en Java,crit par Fabien Moutarde et Norbert Kajler. Il s'agit ici d'une version compltementrcrite, avec le concours actif de Norbert Kajler et Jean-Michel Viovy, et la participation detoute l'quipe du CCSI. Cette version utilise la chane ditoriale Scnari . Nous vous remercions par avance de signaler toute erreur ou imprcision auxauteurs.

11

Pourquoi Java ?

Java a t choisi par l'quipe enseignante en tant que compromis entre :

langage puissant, incluant un maximum de paradigmes de programmationpertinents enseigner car gnralement non matriss par la plupart des lvesadmis en 1 anne (typage fort, rfrences, programmation objet, exceptions,vnements et programmation ractive, threads, ...) ;

langage pouvant constituer un 2 langage idal pour des lves qui connaissent djsoit un langage moins riche et/ou moins gnral que Java (Maple, Mathematica,Pascal, Basic, JavaScript, PHP, ...) soit un langage essentiellement fonctionnel(CAML, Lisp, ...) de nature trs diffrente ;

langage relativement facile matriser sans avoir suivi au pralable unenseignement d'Informatique avanc ;

langage non-spcialis, permettant l'criture de programmes de toutes sortes,de toutes tailles, et dans tous les domaines ;

langage largement utilis dans l'industrie du logiciel 1 ; langage mature et trs bien document (existence de nombreux cours, FAQs,

bases d'exemples couvrant tous les aspects du langage) en anglais franais, et biend'autres langues si besoin ;

langage disponible gratuitement sur l'ensemble des matriels, et dot d'unevaste bibliothque de classes et de nombreux outils de dveloppementgalement gratuits.

Java n'est certes pas optimal sur l'ensemble de ces critres ; il constitue nanmoins dupoint de vue de l'quipe enseignante le meilleur compromis disponible tant donnl'objectif de cours et les connaissances pralables des lves.Par ailleurs, l'quipe enseignante considre que la matrise d'un langage de programmationdonn importe moins que la matrise des notions sous-jacentes mme si, dans le casparticulier de Java, l'exprience acquise peut tre directement valorise (stages, juniorentreprise, ...) tant donn le nombre de projets informatiques raliss l'aide de celangage (y compris le dveloppement d'applications Android).Ainsi, apprendre programmer en Java est avant tout un moyen d'tudier, et pratiquer, uncertain nombre de principes et styles de programmation essentiels (et que l'on retrouvedans beaucoup d'autres langages). Ce faisant, l'apprentissage de java constitue une tape dans l'tude de l'Informatique engnral, et en particulier dans la capacit crire des programmes non-triviaux dans unlangage fortement typ.A l'issue de cet enseignement, il devrait tre assez facile aux lves qui en auraient besoind'apprendre programmer dans n'importe lequel des autres langages trs rpandusaujourd'hui (C, C++, C#, Python ...) ou qui mergent depuis quelques annes (Scala,Ruby, ...).

1 - Java est en 1 ou 2 place dans les diffrents classements sur l'utilisation des langages de programmation(TIOBE, Transparent Language Popularity Index, PYPL, RedMonk Programming Language Rankings, ...)

13

I - Introduction

I

Les langages de programmation 15

Origine et historique de Java 18

Java aujourd'hui 18

Caractristiques techniques de Java 19

Qualits et dfauts de Java 20

JRE, Java SE, JDK, Eclipse, ... 21

Les diffrentes ditions du langage Java 22

Langages et technologies connexes 22

A. Les langages de programmation

Niveaux et catgories des langages de programmation : langage binaire assembleur : instructions de base du processeur (transferts entre registres,

addition, ...) langages impratifs : Cobol, Fortran, Basic, Pascal, C, Ada, PHP, ... langages de programmation logique : Prolog, Mercury, ... langages fonctionnels : Lisp, Scheme, Clojure, ML/CAML, Haskell,

Erlang, ... langages orients objets : SmallTalk, Objective C, C++, Java, C#, Scala,

...

Dfinition Langage binaire : langage natif de l'ordinateur, spcifique un type

d'ordinateur ; programmes constitus d'une suite de zros et de uns,directement excutables par l'ordinateur mais incomprhensibles ou presquepar un tre humain.

Assembleur : langage de bas niveau spcifique un processeur et trsproche du langage de l'ordinateur, donc difficile comprendre pour un trehumain mais trivial transcrire en langage binaire (en assembleur chaqueinstruction du langage correspond une instruction lmentaire du processeur,par exemple : affecter une valeur une case mmoire, comparer deux valeurs,poursuivre l'excution une adresse mmoire donne, ...)

Langage de haut niveau : par opposition au langage binaire et l'assembleur, langage relativement lisible pour un tre humain et ncessitant

15

un gros travail de transcription en langage binaire ; les langages de hautniveau se dclinent en plusieurs catgories pas forcment exclusives lesunes des autres selon le style de programmation qu'ils prconisent :- style impratif : le programme correspond une suite d'instructions

totalement explicites et regroupes en modules/procdures/instructions.- style logique : un programme correspond une suite de faits et de

rgles partir desquels sera cre automatiquement la squenced'instructions excute par l'ordinateur ; dans un langage de programmation logique tel que Prolog le code dcrit ce qui doit tre faiten termes abstraits, sans se proccuper du comment cela sera fait (ce quilimite en pratique les domaines d'applications et engendre des problmesde performances) ; en cela les langages de programmation logique sont l'oppos des langages impratifs.

- style fonctionnel : les programmes sont des fonctions au sensmathmatique fonctions d'ordre suprieur 2 y compris, ce qui fait qu'iln'existe pas de distinction fondamentale entre programmes et donnes enprogrammation fonctionnelle (un programme dans un langage fonctionneltel que Lisp, ML/CAML, Haskell, etc. peut typiquement en cours detraitement produire un autre programme qui cre un troisime programmequi s'applique des donnes dont la nature est elle-mme un programme).

- style orient objets : repose sur un certain nombre d'abstractionspositionnes au cur du langage encapsulation, classes, instances,attributs, mthodes, hritage, ... (voir plus loin) ; la plupart des langagesorients objets sont des langages essentiellement impratifs (C++, Java)avec des aspects fonctionnels plus ou moins prononcs.

Complment : Langages de programmation et architecturesmatriellesDe nos jours, la quasi totalit des ordinateurs (et smartphones) ont une architecturematrielle (processeur) conue :

1. pour privilgier la programmation imprative en termes d'efficacit (sansinterdire pour autant les autres styles de programmation) ;

2. pour tre programme dans n'importe quel langage (sous rserve qu'il puissetre traduit ou interprt dans le langage binaire du processeur).

Il est toutefois possible de crer des ordinateurs privilgiant le style fonctionnel (e.g.les machines Lisp conues dans les annes 70s et commercialises dans les annes80s mais disparues depuis) ou logique (quelques variantes d'architectures matriellesoptimises pour Prolog dans les annes 80-90s). Il est galement possible de concevoir des processeurs pour un langage deprogrammation prcis les auteurs de Java ont d'ailleurs un temps travaill sur unprocesseur optimis pour l'excution de bytecode Java avant d'y renoncer mais,depuis la fin des annes 90s, l'envie d'optimiser les performances d'un langage deprogrammation par la cration d'une architecture matrielle spcifique (processeurddi compris) se heurte un obstacle majeur d'ordre strictement conomique : lescots de dveloppement des processeurs sont tellement levs que seules une oudeux architectures polyvalentes par gnration se rvlent commercialement viables(prsentement : Intel et ARM). Dsormais, la puissance atteinte par les processeurs couple avec les progrsaccomplis dans l'optimisation des compilateurs rendent, de fait, peu pertinent ledveloppement de processeurs ddis un langage donn. Toutefois, une des

2 - On appelle fonction d'ordre suprieur une fonction prenant d'autres fonctions en paramtres. Par exemple,le calcul formel de la drive tant donnes une fonction et une variable est une fonction d'ordre suprieur.Autre exemple : une fonction qui prend en paramtres deux fonctions f et g et une liste l et qui applique lafonction f tous les lments de la liste dont l'image par g est vraie.

16

particularits des processeurs ARM (trs utiliss dans les smartphones, tablettes, ...)est leur formidable flexibilit, tel point que certaines versions disposent de mode(s)permettant d'excuter du bytecode Java plus efficacement3.

Principaux langages gnralistes :

ComplmentLe diagramme ci-dessus prsente quelques uns des langages de programmation gnralistes (permettant d'crire une grande varit de programmes dans denombreux domaines) qui ont t dvelopps depuis l'apparition des premiersordinateurs. Y sont ainsi visibles, les langages gnralistes ayant t les plus utilissau fil des ans et/ou ayant le plus influenc les langages utiliss aujourd'hui.Outre les langages gnralistes, il existe des milliers de langages de programmationplus ou moins spcialiss, autrement dit, des langages qui ont t dvelopps pourcrire des programmes dans des domaines spcifiques (e.g. VHDL4 pour la conceptionde circuits lectroniques), ou pour fonctionner exclusivement l'intrieur d'un logicieldonn (e.g. ceux utiliss dans Maple ou Mathematica).La frontire entre langages gnralistes et spcialiss est toutefois floue et poreuse :historiquement, de nombreux langages ont t initialement dvelopps pour satisfaireun besoin spcifique avant d'tre utiliss plus largement. C'est le cas de C (conupour crer Unix), de Python, et de Java comme on le verra plus loin. Inversement deslangages comme C++, C# ou Scala ont, d'emble, t conus pour tre des langagesgnralistes.De mme, la frontire entre langages impratifs / fonctionnels / orients objets n'est

3 - Le mode Jazelle DBX permet, au moins thoriquement, l'excution directe du bytecode sur les processeursARM sans l'intermdiaire d'une machine virtuelle. En pratique, tout dpend de l'implantation du mode JazelleDBX sachant qu'il existe des dizaines de fournisseurs de processeurs ARM. Au pire le code reste entirementexcut dans une machine virtuelle ; au mieux, seule une partie du bytecode est vritablement excutedirectement sur le processeur, les instructions les plus complexes et/ou les moins courantes tant toujoursinterprtes dans une machine virtuelle. Une variante Jazelle DBX est par ailleurs incluse dans lesprocesseurs ARM depuis 2005 : ThumbEE, conu comme le mode d'excution privilgi pour l'excution desprogrammes crits en Java, C#, Phython, Perl, etc. Dans ce mode, le processeur excute un jeu d'instructionsrduit optimis pour tre trs proche de tous ces langages la fois. L'usage de ThumbEE n'est cependant plusrecommand par ARM sur les dernires gnrations de ses processeurs, mme si il reste disponible pour desraisons de compatibilit avec les anciens processeurs.4 - VHSIC (Very High Speed Integrated Circuit) Hardware Description Language.

Introduction

17

pas fige : la plupart des langages voluent au fil des annes, et dans certains caschangent de catgorie, en ajoutant une couche objet par exemple (e.g. Pyhthon, PHPet bien d'autres) ou des aspects fonctionnels (Java 8). D'autres langages sont conuspour tre prcisment la frontire de diffrents styles comme Scala ou F# quitentent de concilier au mieux les styles impratifs, objets et fonctionnels.Par ailleurs il existe de nombreux langages informatiques qui ne sont pas deslangages de programmation : par exemple XML (Extensible Markup Language) est unlangage conu pour reprsenter/archiver/manipuler des donnes structures, il nepermet pas l'criture de programmes .

B. Origine et historique de Java

Initialement (1991) Oak tait un projet de langage pour l'lectronique grandpublic dvelopp au sein de la socit Sun (rachete depuis par Oracle)Principal concepteur : James GoslingTransform en langage pour le Web sous le nom de Java grce saportabilit (1994/95)Lancement officiel en mai 1995

Complment : Historique des versions du langage1996 : Java 1.01997 : Java 1.1

nombreuses optimisations, modification du modle des vnements pourAWT, ... ~400 classes prdfinies

1998 : Java 1.2 (renomm Java2 ou J2SE 1.2) ajouts : collections, Swing, Java2D, ... ~1200 classes prdfinies

2000 : Java 1.3 (J2SE 1.3)2002 : Java 1.4 (J2SE 1.4)2004 : Java 1.5 (J2SE 1.5)

ajouts : gnricit (proche des templates de C++), types numrs, webservices, ... ~2500 classes prdfinies

2006 : Java 1.6 (ou Mustang ou Java SE 6) amliorations des performances (Swing notamment) ajouts : interactions avec scripts (PHP, Python, Ruby, JavaScript), ...

2011 : Java 1.7 (ou Dolphin ou Java SE 7) amliorations de la gnricit et des instructions switch, catch, ... ajouts : NIO (new I/O), try-with, ... ~3000 classes prdfinies

2014 : Java 1.8 (ou Wolf ou Java SE 8) amliorations de la gestion du temps et des dures (classes Instant,

Duration, ...) ajouts : lambda expressions, streams, ... ~4000 classes prdfinies

~2016 : Java 1.9

C. Java aujourd'hui

Langage de programmation parmi les plus utiliss aujourd'hui : plus de 10 millions de dveloppeurs Java nombreux outils de dveloppement plusieurs milliards d'objets avec une machine virtuelle Java , dont :

18

- 5 milliards de cartes puce (y compris cartes SIM)- 3 milliards de tlphones portables- 100% des lecteurs de disque Blu-ray - 90% des PCs d'entreprise

D. Caractristiques techniques de Java

Un langage orient-objet : robuste (typage fort, pas de pointeurs, garbage collector) modulaire (packages) intgrant le multi-threading compilable en bytecode pouvant tre interprt (ou excut vole) au sein

d'une machine virtuelle Java (JVM) maximise la portabilit

Complment : Java et C / C++Java est proche du langage C++. Historiquement, sa syntaxe de base a tvolontairement calque sur celle de C / C++ afin de faciliter la transition pour lesmillions de programmeurs qui connaissent dj ces deux langages.Principales simplifications de Java (par rapport C++) :

pas de manipulations de pointeurs sous forme d'adresse mmoire ; gestion mmoire automatique (garbage collector) ; pas de surcharge des oprateurs ; pas d'hritage multiple 5 ; pas de prprocesseur.

Principaux ajouts (par rapport C++) : tableaux avec test de dpassement de bornes vrifi l'excution ; chanes de caractres sous forme de classe ; notion d'interface ; classe racine ; introspection ; structuration en paquetages ; aspects fonctionnels (depuis Java 1.8) ; multi-threading incorpor au langage ; vaste bibliothque de classes.

Complment : Java et JavaScriptLe langage JavaScript n'a rien ou presque voir avec Java au plan technique : il s'agitd'un langage faiblement typ, beaucoup moins riche que Java en termes deparadigmes de programmation et de bibliothque de classes. Concernant les usages il y a quelques points communs : l'utilisation l'intrieur denavigateurs web et de serveurs, mais pour JavaScript c'est quasiment sa seuleutilisation alors que pour Java c'est une utilisation parmi bien d'autres.JavaScript est maintenu par la fondation Mozilla ; il fait partie, comme Java, deslangages informatiques les plus rpandus ; il est en particulier une brique essentielle

5 - Du moins pas au sens de C++ qui permet l'hritage multiple des attributs et des mthodes : en Java seulsles mthodes peuvent dans une certaines mesure faire l'objet d'un hritage multiple via le mcanisme desmthodes par dfaut .

Introduction

19

de la technologie AJAX (asynchronous JavaScript and XML) utilise pour la cration depages web dynamiques dans lesquelles il y a des changes frquents et automatiquesentre le navigateur et le serveur (par exemple pour la mise jour d'une carte).JavaScript et Java sont en fait complmentaires : certains codes trs spcifiquess'crivent plus aisment avec JavaScript (pour la gestion de formulaires dans despages web par exemple) alors que Java est utilis beaucoup plus largement pourexcuter des programmes complexes l'intrieur de pages web ou de serveurs, etpour dvelopper des programmes autonomes de grande taille comme Eclipse. Cette complmentarit est telle qu'il existe plusieurs briques technologiques pourfaciliter l'utilisation conjointe des deux langages dont le moteur JavaScript Nahshorn (fournit avec Java depuis la version 8) et qui permet l'excution de codeJavascript au sein de la machine virtuelle Java (la JVM) et galement l'invocation decode Java depuis Javascript (et rciproquement).

E. Qualits et dfauts de Java

Principales qualits Programmes portables Programmes fiables (rigueur du langage => peu de bogues) Formidable bibliothque de classes (4000+ classes disponibles en standard) Dveloppement rapide Multiples possibilits de dploiement (applet, web start, ...) Langage trs rpandu grande disponibilit de comptences, documentation,

outils, ... Capacit prouve permettre la ralisation de trs gros programmes (e.g.

Eclipse = 58 millions de lignes de code !) Principaux dfauts

Vitesse d'excution des codes infrieure C/C++ (dpend des codes) Rputation de scurit ternie plusieurs reprises par des bugs dans les

implantations de rfrence Syntaxe relativement verbeuse Systme de type non entirement unifi (types lmentaires / tableaux /

classes) Poids du pass encombrement cognitif (beaucoup de classes a superflues

maintenues pour garantir la compatibilit ascendante des codes Java) Langage difficile pour des programmeurs occasionnels Inversement, langage possiblement trop banal/mature pour des programmeurs

expriments

Complment Une tude de 2012 sur un ensemble de codes de rfrence met en vidence

une vitesse d'excution des codes Java (J2SE 1.7) infrieure de 44% comparau langage C++. Il s'agit d'une diffrence importante dans l'absolu mais, enpratique, rares sont les applications pour lesquelles un tel gain de vitessejustifie lui seul le choix d'un langage de programmation : les critresessentiels sont bien plutt la rapidit et le cot de dveloppement desprogrammes, la fiabilit, la portabilit, ...

Concernant la verbosit, c'est un point relativiser : la verbosit de javadcoule en grande partie d'un choix de conception dlibr li d'une part au

20

typage fort et d'autre part la volont de faire prendre conscience de certainschoix au programmeur. Par ailleurs, l'tendue de la bibliothque de classespermet, dans certains cas, d'crire en quelques lignes ce qui prendrait plusieurspages en C ou C++. Un programmeur averti peut nanmoins prfrer unlangage moins verbeux.

Parmi les points qui peuvent manquer des programmeurs expriments enJava il y a : a. des mcanismes volontairement absents du langages alors qu'il sont

prsents dans beaucoup de langages de la mme gnration (pointeurs,hritage multiple, surcharge des oprateurs, ...) ;

b. des paradigmes disponibles uniquement dans des langages plus rcents queJava (valuation paresseuse, schmas de conceptions intgrs au langage,etc).

Il s'agit l aussi de points relativiser : peu de programmeurs sontvritablement limits par des manques dans le langage Java. En outre,certaines innovations qu'on retrouve dans des langages plus rcents tels queRuby on rail, Scala, ... apportent certes puissance et lgret mais sont parfoisdifficiles matriser sans un bon niveau technique et un minimum d'expriencedans le dveloppement logiciel. Enfin, Java volue rgulirement (ajout de lagnricit en 2004, ajout des lambda expressions et des Streams en 2014, ...)ce qui rduit l'attrait des langages les plus rcents. Toutefois, la volont desconcepteurs du langage de garantir une (quasi)-parfaite compatibilitascendante6 lorsque de nouveaux concepts sont ajouts tend alourdir lelangage au plan syntaxique. Au fil du temps, ce pourrait d'ailleurs tre unavantage dcisif pour les langages plus rcents que Java : force d'ajouter deslments au langage sans remettre en cause la syntaxe d'ensemble, Javadevient progressivement moins agrable utiliser que ses alternatives les plusrcentes.

F. JRE, Java SE, JDK, Eclipse, ...

Plusieurs implantations de Java sont disponibles, dont celle d'origine ORACLE/SUN(crateur du langage) et quelques autresPour excuter du code Java : le JRE (Java Runtime Environment) d'ORACLE/SUNsuffit (gratuit et largement disponible)Pour crer du code java, plusieurs possibilits (au choix) :

le Java SE (Standard Edition) dnomm aussi JDK (Java DevelopmentKit) d'ORACLE/SUN (gratuit) contient :compilateur (javac), interprteur /machine virtuelle (java), divers outils gnration doc (javadoc), debugger(jdb), ...

la plateforme de dveloppement Eclipse (gratuite, la plus utilise) la plateforme de dveloppement NetBeans (gratuite, dveloppe par

Oracle) ou l'une des nombreuses autres plateformes de dveloppement permettant de

dvlopper du code Java...

6 - En Java, compatibilit ascendante veut dire qu'un programme compil avec une version antrieure dulangage continuera fonctionner de la mme manire sur une machine virtuelle plus rcente, sans ncessiterde re-compilation ou de modification du code source ( de rares exceptions prs). Autrement dit, un codedvelopp pour Java 1.6 pourra fonctionner sur un ordinateur dot d'un environnement d'excution (JRE)plus rcent tel que Java 1.8. L'inverse est faux : un code Java rcent ne fonctionnera pas forcment sur unenvironnement d'excution plus ancien.Attention : la compatibilit ascendante concerne les programmes crits en langage Java ; si on considreles outils (compilateur et machine virtuelle Java) on doit alors parler de compatibilit descendante ou rtro-compatibilit (une JVM 1.6 pourra excuter tout code crit en Java 1.6 ou avec des versions plusanciennes, mais pas forcment des codes plus rcents).

Introduction

21

Complment : OpenJDK, licences, ... OpenJDK est une version de Java dont la totalit des composants est

strictement dans le domaine public (sources de toutes les classes, de lamachine virtuelle, du compilateur,...)

OpenJDK est distribu sous licence GNU OpenJDK est une initiative soutenue par une grande partie de l'industrie

informatique (Oracle, IBM, Apple, SAP, ...) La version standard distribue gratuitement par Oracle (JRE, Java SE, ...)

utilise les mmes codes sources qu'OpenJDK mais y ajoute des composants quine sont pas dans le domaine public ; le rsultat est distribu sous une licencespcifique (Binary Code License)

G. Les diffrentes ditions du langage Java

Plusieurs ditions (ou distributions ) du langage co-existent : 1. Java Standard Edition (J2SE ou Java SE) 2. Java Enterprise Edition (J2EE ou Java EE) applications rparties

(e.g. services web) 3. Java Micro Edition (J2ME ou Java ME) applications embarques (e.g.

smartphones, TVs, ...) 4. Java Card applications embarques sur cartes puce (smartcards)

Remarque : Diffrences au sein du langage Java selon lesditionsChaque dition :

inclut un ensemble dtermin de packages plus ou moins consquent ; utilise une machine virtuelle possiblement diffrente.

Le langage est donc sensiblement diffrent selon l'dition utilise mme si les basesrestent strictement les mmes (syntaxe, structures de donnes, classes de base).

H. Langages et technologies connexes

Il existe de nombreux langages et technologies connexes dans l'cosystme Java : GWT (Google) pour la cration de pages web dynamiques de type

googlemaps Xtend (Eclipse.org) variante de Java avec une syntaxe allge ; se compile

en code source Java ...

Aussi, la machine virtuelle Java est frquemment utilise pour excuter desprogrammes crits dans d'autres langages aprs compilation en bytecode :JavaScript, Scala, Groovy, Clojure, Jython, JRuby, ...

Remarque : Avantages pour d'autres langages d'utiliser lamachine virtuelle JavaAu moins trois avantages majeurs pour qui souhaite dvelopper un nouveau langage :

1. pouvoir excuter le code sur les milliards de machines physiques (PCs,tlphones, cartes de crdits, ...) dj quips d'une machine virtuelle Java ;

2. aboutir plus rapidement une premire version utilisable du langage : pas

22

besoin de dvelopper sa propre machine virtuelle, ni de multiplier lescompilateurs natifs , il suffit d'crire un compilateur qui produit du bytecodeJava) ;

3. disposer d'un accs aux 4000+ classes de la bibliothque Java via leurbytecode.

Complment : Java et AndroidL'essentiel d'Android (Google) est crit en C/C++ (le cur du systme est unevariante d'Unix/Linux) ; Java y est utilis pour la cration des applications .Le code java compil en bytecode (fichiers .class) est converti en fichiers .dex (pourDalvik executable) afin de pouvoir fonctionner sur la machine virtuelle Dalvik qui estune JVM optimise pour fonctionner sur des tlphones portables, tablettes, ...

AttentionCe cours correspond l'dition standard de Java (Java SE) et ne couvre pasles spcificits des autres ditions, ni les langages connexes Java.

Introduction

23

II - Syntaxe de base

II

Premiers exemples 25

Variables, types, porte, commentaires, 26

Oprateurs 31

Blocs, instructions de contrle (tests, boucles, ) 36

Entres-sorties 42

Exemple de programme, compilation, excution 45

A. Premiers exemples

Remarque : mots-clsDans l'exemple ci-dessus, int, for, class, public, static et void sont des mot-cls. Par mot-cl il faut comprendre un mot rserv par les concepteurs du langage,et qu'il est donc impossible d'utiliser dans un programme pour nommer une variable,une fonction, ...Java comporte une cinquantaine de tels mots-cls qui seront prsents au fil ducours.

25

B. Variables, types, porte, commentaires, 1. Variables et types

Dfinition : Notion de variablenom (identificateur) + type + zone mmoire

Deux grandes familles de types en Java :

1. les types primitifs (entiers, flottants, ...) 2. les types composites qui se manipulent par l'intermdiaire de

rfrences :- tableaux- numrations- objets- interfaces

RemarqueContrairement certains langages moins fortement typs (Python, Maple, ...), Javane cherche quasiment jamais infrer (deviner) le type des variables : en Java, ilfaut dclarer le type de chaque nouvelle variable. Cela alourdit l'criture du code maispermet de gagner en fiabilit (le compilateur interdit les manipulations risques, leprogrammeur est oblig d'expliciter ses choix).Par ailleurs, le type d'une variable en Java est fix une fois pour toute (i.e. il ne peutchanger au fur et mesure des affectations...)

2. Types primitifs

boolean

char (16-bit, Unicode) byte : entier (sign) 8-bit short : entier (sign) 16-bit int : entier (sign) 32-bit long : entier (sign) 64-bit

float : flottant (IEEE 754) 32-bit double : flottant (IEEE 754) 64-bit

RemarqueLe typage est particulirement strict en Java (compar C ou C++ par exemple),ainsi :

les conversions automatiques sont peu nombreuses (et seulement vers destypes plus larges , par exemple du type int vers le type long)

les conversions manuelles sont restreintes (il est, par exemple, interdit deconvertir un boolen en entier)

26

3. Le type boolen

Valeurs possibles : true ou falseVritable type Type retourn par les oprateurs de comparaisonType attendu dans tous les testsNe peut pas tre converti en entier

RemarqueContrairement d'autres langages, le type boolen est un type part entire enJava. En particulier, il n'y a pas de correspondance entre faux et 0 comme c'tait lecas historiquement en C/C++ (non-ISO).

4. Le type caractre

16-bit 65536 valeurs : quasiment tous les caractres de toutes les critures (maisaffichables uniquement si le systme possde les polices de caractres adquates !)Littraux entre simples quotes : 'a' 'Z' ...Caractres spciaux : '\n' '\t' '\b' '\\' '"' ...Possibilit d'utiliser la valeur Unicode : '\u03c0'7Convertibles automatiquement en int ou long (et manuellement en byte ou short)Inversement, (char)val est le caractre dont le code Unicode est l'entier valPossibilit de tester la nature du caractre : Character.isLetter(c), Character.isDigit(c), ...o c est une variable de type char

NOTA-BENE : nombreuses fonctions utilitaires dans la classe Character, voir plus loin(cf. La classe Character p 163) et dans la documentation en-ligne de Java

Attention Ne pas confondre 'a' et "a" ('a' est un char, i.e. UN SEUL caractre, "a"est

une chane de caractres de longueur 1) \ suivi directement d'un nombre indique un char donn par son code en octal

(base 8)ex. : `\43' est le char de code 4x8+3=35 (et pas le caractre de code 43)

Complment : Distance entre caractresL'oprateur - est disponible sur les caractres pour connatre la distance entre deuxcaractres.Ainsi 'c' - 'a' vaut 2.

7 - Cette valeur Unicode correspond (la lettre grecque PI en majuscule).

Syntaxe de base

27

5. Les types entiers

Littraux de type entier : en base dix : 139 en octal : 0213 en hexadcimal : 0x8b en binaire : 0b100101

Usage possible du caractre _ (augmente la lisibilit) : 17_500_000

L ou l pour spcifier un entier long :: 139L

Valeurs min/max :: byte = [-128; +127] short = [-32768 ; +32767] int = [-2.147.483.648 ; +2.147.483.647] long = [-9.223.372.036.854.775.808 ; +9.223.372.036.854.775.807]

Conversion automatique seulement vers les types entiers plus grands (int long,etc...) et vers les types flottants

RemarqueContrairement d'autres langages (C, C++, ...), il n'existe pas de variantes non-signes de ces types en Java (et donc pas de mot-cl unsigned).

Complment : Encodage des entiers en mmoireLe bit de gauche = le signe ; les autres bits = la valeur en binaire en complment deux , i.e. ~|x|+1, pour les

Valeurs spciales : Infinity, -Infinity, NaN

Conversion automatique : seulement de float double

ATTENTION, la conversion manuelle en entier tronque la partie dcimale :

double d = -2.8;int i = (int) d; // ici, i vaut -2

Complment : Encodage des nombres flottants en mmoire La reprsentation en mmoire suit strictement la norme IEEE-754 Il existe des valeurs spciales reprsentant +infini, -infini, et 0/0

(NaN=NotANumber) Principe : o est la mantisse sous forme d'un nombre dans [0 ; 1] crit en

base 2 () Pour les float, il y a : 1 bit de signe puis 8 bits pour l'exposant puis 23 bits pour

la mantisse Pour les double, il y a : 1 bit de signe puis 11 bits pour l'exposant puis 52 bits

pour la mantisse

7. Constantes

Variable dont la valeur ne peut plus tre change une fois fixeSe dclare avec le mot-cl final :

final double PI = 3.14159; . . . ce qui interdit d'crire ensuite : PI = 3.14; // ERREUR... Possibilit de calculer la valeur de la constante non pas lors de sa dclaration maisplus tard, l'excution :

final int MAX_VAL;// OK : constante blanche // ...

MAX_VAL = lireLaValeur();// ...

MAX_VAL = 1000; // ERREUR...

Complment : le mot-cl constEn Java, const ( ne pas confondre avec final) est un mot-cl au sens o on ne peutpas l'utiliser librement pour nommer une variable ; cependant il n'est pas utilis par lelangage, au moins dans sa version actuelle. C'est d'ailleurs avec goto le seul motainsi rserv par le langage sans tre effectivement utilis.

Syntaxe de base

29

8. Dclaration et porte des variables

Dclaration pralable obligatoire

Identificateurs :- caractres Unicode- commencent par une lettre, _ ou $- ensuite : lettre, chiffre, _ ou $

Exemples : int i;double x, y, z;char c = 'A', d;boolean flag = true; ATTENTION, initialisation obligatoire avant usage :

int i, j;j = i; // ERREUR : i non initialis Porte (ou scope ) des variables (= zone de validit de la dclaration) :jusqu' la fin du bloc englobant (voir plus loin)

9. Conventions de nommage

1. Identificateurs toujours en minuscules, sauf :- majuscule au dbut des sous-mots intrieurs : unNomDeVariableOuDeFonctionOrdinaire- dbut des noms en majuscule pour classes et interfaces (et elles seules) : UnNomDeClasse

2. Pour les constantes : tout en majuscules et sparation des mots par _ UNE_CONSTANTE

3. Pour les classes et interfaces : viter tous les noms dj utiliss dans le JDK(ex. String, System, ...)

4. Pas d'emploi du caractre $ (ni de caractres non ASCII8)

RemarqueCes conventions de nommage dictes par les auteurs du langage ne sont passtrictement obligatoires pour faire fonctionner un programme ; elles sont nanmoinsfortement recommandes dans la mesure o elles facilitent grandement lalisibilit du code et sa maintenance). Elle sont de fait trs largement respectes.

8 - ASCII = American Standard Code for Information Interchange. La norme ASCII date de 1963, c'estl'anctre de tous les systmes d'encodage de caractres en informatique ; les caractres y sont cods sur unoctet ce qui limite leur nombre 256. ASCII a t conu pour la langue anglaise dont il couvre tous lescaractres et symboles usuels. Pour des raisons de compatibilit ascendante, les normes plus rcentes quicouvrent davantage de langues sont gnralement calques sur l'ASCII pour ce qui concerne les caractrescouverts par cette norme (lettres latines sans accents, chiffres, ponctuation courante...) . En particulier, sousUnicode, le standard ASCII est intgr sous le label Basic Latin (ou C0 Controls and Basic Latin).

30

10. Commentaires

Plusieurs sortes de commentaires en Java :

a/ commentaires techniques sur une ligne :

// commentaire -> fin de la ligneint x; // autre commentaire b/ commentaires techniques sur plusieurs lignes : /* commentaire qui s'tend comme icisur plusieurs lignes */ c/ commentaires destins la documentation automatique (javadoc) :

/** commentaire pour javadoc */ NOTA-BENE : javadoc = outil qui analyse le code Java, et produit automatiquementune documentation HTML avec la liste des classes, attributs, mthodes... (en yintgrant, le cas chant, les commentaires de documentation )

Remarque : javadoc

Les commentaires javadoc se placent juste avant l'entit (classe, attribut,mthode) laquelle ils se rapportent

Voir la section sur javadoc (cf. Documentation automatique (javadoc) p 175)pour plus de dtails.

C. Oprateurs 1. Principaux oprateurs

affectation : = arithmtique : + - * / % comparaison : < >= == != boolen : && || ! ^ & | opration bit--bit (sur les entiers) : & | ^ ~ > >>> opration et affectation simultanes : += -= *= /= %= &= |= ^=

= >>>= pr/post-incrmentation : ++ pr/post-dcrmentation : -- oprateur ternaire : ?: cration tableau ou objet (allocation mmoire) : new

Syntaxe de base

31

2. Oprateurs arithmtiques

Oprateur Fonction Usage

+ addition expr1 + expr2 - soustraction expr1 - expr2 - changement de signe - expr2 * multiplication expr1 * expr2 / division expr1 / expr2 % modulo expr1 % expr2

Attention L'arithmtique entire est circulaire : elle produit des rsultats

mathmatiquement faux en cas de dpassement, mais pas d'erreur au sensinformatique, sauf lors d'une division par zro.

L'arithmtique dcimale (en virgule flottante) produit des erreurs d'arrondismais n'est pas circulaire : elle produit des valeurs de type infini en cas dedpassement.

En cas de division par zro, l'arithmtique entire produit une erreurinformatique (ArithmeticException) tandis que l'arithmtique dcimaleretourne la valeur spciale NaN (NotANumber).

Les divisions entre entiers produisent le quotient9 (pas de passage automatique l'arithmtique dcimale).

Consquence : le comportement de l'oprateur / diffre totalement selon la naturedes oprandes :

/ entre deux entiers quotient (donc 5/2 vaut 2 alors que 5.0/2 vaut 2.5) 1/0 ArithmeticException (division par zro prohibe entre entiers)

alors que 1.0/0 retourne la valeur Infinity (et 0.0/0 produit la valeur NaN)

Les constantes et fonctions mathmatiques usuelles sont dans la classe Math (cf. Laclasse Math p 160) :

Math.E Math.PI Math.pow(x,y) Math.sin(x) Math.log(x)

9 - En java, tant donns deux entiers et , vaut avec qui vaut , ou selon que est .Exemples : 18/10 vaut 1 ; -18/10 vaut -1 ; -18/-10 vaut 1.

32

3. Oprateurs de comparaison

Oprateur Fonction

== galit!= ingalit< infrieur strict suprieur strict>= suprieur ou gal

NOTA-BENE : rsultat de type boolen

AttentionNe surtout pas confondre == (test d'galit) et = (affectation)

4. Oprateurs boolens

Oprateur Fonction Usage

&& et (version optimise) expr1 && expr2|| ou (version optimise) expr1 || expr2^ ou exclusif (xor) expr1 ^ expr2! ngation ! expr1& et (version non optimise) expr1 & expr2| ou (version non optimise) expr1 | expr2

NOTA-BENE : les oprandes doivent tre des expressions valeur boolenne

RemarqueDiffrence entre les versions optimises et non-optimises :

avec le et optimis : &&, le deuxime oprande n'est pas valu si le premierest faux

avec le ou optimis : ||, le deuxime oprande n'est pas valu si le premierest vrai

Syntaxe de base

33

5. Oprateurs bit--bit

Oprateur Fonction Usage

& et op1 & op2| ou op1 | op2^ ou exclusif (xor) op1 ^ op2~ ngation ~ op1 dcalage droite op1 >> op2>>> dcalage droite non sign (/2) op1 >>> op2

Travaillent sur la reprsentation binaire

NOTA-BENE : oprandes de type entier

6. Oprateurs d'affectation

int i, j, k ;final int TMAX = 100 ; // Exemples d'affectations ordinaires :i = 0 ;j = i ;k = TMAX ; // Exemple d'affectations en srie :// (valuation de droite gauche)i = j = 2 ; // i et j valent 2 // Exemple avec opration combine :i += 3 ; // quivaut i = i+3 ;

Complment : Diffrence subtile !L'quivalence entre oprateurs combins et opration arithmtique suivie d'uneaffectation n'est pas totale, car (bizarrement) pour les affectation combines, il y aconversion automatique.Exemple : si i est de type int, i+=3.7; est quivalent i = (int)(i+3.7); et donc i+=3; !!!

34

7. Oprateurs d'incrmentation et de dcrmentation

Oprateur Fonction Usage

++ post-incrmentation i++pr-incrmentation ++i

-- post-dcrmentation i--pr-dcrmentation --i

Ces oprateurs permettent de compacter le code :

n = i++; quivaut n = i;i = i + 1;

n = ++i; quivaut i = i + 1;n = i;

8. Autres oprateurs

Ternaire conditionnel : bool ? expr1 : expr2 int v = (x < y) ? x : y// v vaut le minimum entre x et y Conversion explicite (ou casting) : (type) double x = 1.7;int i = (int) x; // i vaut 1double y = -1.7;int j = (int) y; // i vaut -1

9. Priorit des oprateurs

Oprateurs Java (par ordre de priorit dcroissante)

[ ] - (params) expr++ expr-- ++expr --expr +expr -expr ~ ! new (type)expr * / % + - > >>> < > = instanceof == !=

Syntaxe de base

35

Oprateurs Java (par ordre de priorit dcroissante)

& ^ | && || ? :

= += -= *= /= &=

2. Instructions de contrle

Les instructions de contrle permettent de modifier l'ordre normal (squentiel)d'excution des instructions :

1. excution conditionnelle : if(...) ... else 2. cas multiples : switch(...) case ... 3. boucles :

- while(...) ... - do ... while(...)- for(...)

3. Excution conditionnelle

Forme minimale (pas de clause else, une seule instruction) : if (boolExpr) instruction; Forme standard : if (boolExpr) { instruction(s); // excute(s) si VRAI} else { instruction(s); // excute(s) si FAUX} Possibilit d'imbrication : if (boolExpr) { instruction(s); // excute(s) si VRAI} else if (boolExpr2) { instruction(s); } else { // . . . }}

Exemple

if ( a!=10 ) x = 4;else { //bloc car plusieurs instructions x = 5; y = t+2;}

Remarque Dans tous les cas : le test est plac entre parenthses. La partie sinon (else) est facultative. Les accolades sont facultatives si il n'y a qu'une seule instruction. Contrairement d'autres langages, il n'y a pas de mot-cl then en Java.

Syntaxe de base

37

4. Cas multiples

switch (e) {case cst1: // instruction(s) si e==cst1 break;case cst2: // instruction(s) si e==cst2case cst3: // instruction(s) si e==cst3 ou e==cst2 break;default: // instruction(s) si aucun des cas prvus break;} Avec :

e : de type entier ou char ou String ou bien type numr (enum) cst1, cst2, ... : littral ou constante (final)

Exemple final int ERREUR=-1;int x, y;//...switch(x) {case 0 : y=x; break;case 1 : x=y; break;case ERREUR : System.exit(1); break;default : y=0;}

Exemple enum Temperature { FROID, TIEDE, CHAUD } ;Temperature t;// ..switch(t) {case FROID : // ...case TIEDE : // ...case CHAUD : // ...}

38

Attention Le paramtre de l'instruction switch ne peut pas tre de n'importe quel type

(les nombres flottants en particulier sont interdits, de mme que les instancesde classes autres que String).

Sauf cas particuliers, une clause break est ncessaire la fin de chaquebranche du switch. A dfaut, chacun des codes correspondant aux branchessuivantes sera excut sans mme vrifier la validit des tests associs, ce quine correspond que trs rarement au fonctionnement souhait.

5. Boucles de rptitions

Deux sortes de boucles while en Java :

while (boolExpr) { // corps excut tant que// boolExpr est vrai :

instruction(s); }

do { // corps excut // au moins 1 fois : instruction(s);

} while (boolExpr); NOTA-BENE : les accolades sont optionnelles si le corps comporte une seuleinstruction :

while (boolExpr) instruction;

do instruction; while (boolExpr);

Exemples : int y = 10 ;while (y

6. Boucles d'itration

for (init ; boolExpr ; incr) { instructions; // corps de la boucle}

Avec : init : dclarations et/ou affectations, spares par des virgules

(typiquement : initialisation des variables utilises dans la boucle) incr : expressions spares par des virgules

(typiquement : incrmentation des variables utilises dans la boucle)

Equivaut :

init;while (boolExpr) { instructions; incr;} Exemples :

int somme=0;for (int i=1 ; i

Exemple int[] prems = { 2, 3, 5, 7, 11};// prems : tableau d'entiersint somme = 0;for (int i : prems) { somme += i*i;}

String[] rep = { "oui", "non", "peut-tre" };// rep : tableau de chanes de caractresfor (String s : rep) { System.out.println(s);}

Attention Contrairement la version classique du for, le 1 paramtre entre

parenthse n'est pas forcment de type entier (son type doit tre celui deslments du tableau).

Par ailleurs, les valeurs successives affectes ce paramtre lors dudroulement de la boucle correspondent aux diffrentes valeurs prsentes dansle tableau (et pas aux indices comme dans la version classique du for).

DONC ATTENTION : risque d'erreur lorsque le type des lments est entier si onconfond les deux versions de l'instruction for .

8. Interruptions des boucles, labels

Trois instructions permettent d'interrompre le droulement normal d'une boucle enJava :

continue : fait sortir du tour de boucle en cours (passe immdiatement auprochain test de la boucle)

break : fait sortir de la boucle return (cf. Type de retour et instruction return p 58) : fait sortir

immdiatement de la fonction en cours, et donc, a fortiori, de la boucle encours

Complment : label devant une boucleOn peut mettre un label devant une boucle Java et utiliser les instructionscontinue et break (suivies du nom du label) pour indiquer une boucle spcifique.Intrt : gestion de cas particuliers dans des boucles imbriques complexes ( viterdans les autres cas dans la mesure o ces labels rendent le code difficile relire/vrifier).

Syntaxe de base

41

Exemple

nomDuLabel:while ( f(x) > 0 ) { for ( x : tab) { // .... if ( tab[x] > 100 ) { break; // sort de la boucle la plus interne (for) } if ( tab[x] < 0 ) { break nomDuLabel; // sort de la boucle englobante (while) } if ( tab[x] == 0 ) { continue nomDuLabel; // saute au prochain test de la boucle // englobante (while) } // .... }}

Complment : le mot-cl gotoEn Java, goto est un mot-cl au sens o on ne peut pas l'utiliser librement pournommer une variable ; cependant il n'est pas utilis par le langage, au moins dans saversion actuelle. C'est d'ailleurs avec const le seul mot ainsi rserv par lelangage sans tre effectivement utilis.

E. Entres-sorties

Exemple d'criture sur le flux de sortie standard (crit sur la console par dfaut) : double z = 0.43;System.out.print("z=");System.out.print(z);System.out.println(" et 2z=" + (2*z)); Exemple de lecture sur le flux d'entre standard (lit depuis le clavier par dfaut) : // Lecture d'un caractre la foisint car = System.in.read();

// Lecture de 10 caractres byte buf[] = new byte[10];int nbLus = System.in.read(buf);

ConseilUtiliser la classe Scanner pour lire autre chose que des caractres ou tableaux decaractres (voir ci-aprs).

42

Exemple de lecture avec la classe Scanner import java.util.Scanner;

//

Scanner sc = new Scanner(System.in);String ch = sc.next(); // lecture d'un motint k = sc.nextInt(); // lecture d'un entierdouble val;// teste si un double suit sur le flux d'entre // (ici il s'agit du clavier) :if ( sc.hasNextDouble() ) { val = sc.nextDouble(); // lecture d'un double}String s = sc.nextLine(); // lecture d'une ligne ATTENTION : Java utilise, par dfaut, le format local des nombres (par exempleen franais : 2,5 et pas 2.5) ; possibilit de choisir une localisation avec lamthode useLocale() (cf. Localisation et internationalisation p 172)

Complment : la classe Scanner Il existe une mthode nextXyz() et une mthode hasNextXyz() pour chaque

type primitif Xyz exemple pour le type double : nextDouble() et hasNextDouble()

Lance InputMismatchException si l'lment suivant n'est pas convertible dansle type demand d'o l'intrt de tester la prsence d'une donne d'un certain type avant de la

lire ! Possibilit de choisir un sparateur avec useDelimiter(Pattern) Voir plus loin dans le cours pour plus de dtails sur les exceptions (cf. Principe

des exceptions p 91) et les classes Scanner et Pattern (cf. Les classes Scanneret Pattern p 168)

Ecriture formate avec printf()printf(String, Object...) est une mthode nombre d'arguments variable quifacilite l'affichage format : double rac2 = Math.sqrt(2);System.out.printf("sqrt(2)=%.3f", rac2);// imprime : sqrt(2)=1,414

int i=3;int j=30;int k=303;System.out.printf("|%3d|%3d|%3d|", i, j, k); // imprime : | 3| 30|303|

double x=2.5;double y=-3.755;System.out.printf("x:%+.2f\ny:%+.2f", x, y); // imprime quoi ?

Syntaxe de base

43

Complment : printf(), format() et la classe Formatterprintf() est une mthode d'affichage puissante mais plus complexe d'emploi queprint() et println(). Son principal intrt est de permettre un contrle fin duformatage des donnes, en particulier numriques (mais pas seulement)10.Le principe gnral est de passer en 1 paramtre une chane de caractres avec dutexte afficher, et comportant un nombre quelconque de squences introduitespar le caractre %.A chaque squence doit correspondre une variable passe en paramtre la suite dela chane de caractres comme dans les exemples ci-dessus.Les squences doivent suivre une syntaxe spcifique dtaille dans la documentationen-ligne de la classe Formatter.Pour comprendre les exemples ci-dessus il suffit de savoir que :

chaque squence commence par un caractre % et se termine par une lettre quispcifie la nature de la variable qui sera substitue cette squence, savoir :- s pour une chane de caractres- c pour un caractre- d pour un entier,- f pour un nombre flottant- e pour un nombre flottant afficher en notation scientifique - ...

le contrle de l'affichage s'effectue en ajoutant, si besoin, des directives entrele caractre % et la lettre qui termine la squence, ainsi :- %f indique qu'on souhaite afficher cet endroit un nombre flottant- %.3f indique en outre que l'affichage devra comporter exactement 3

chiffres aprs la virgule- %2.3f indique en outre que la partie gauche de la virgule devra occuper

au minimum 2 caractres (quitte ajouter des blancs)- %+2.3f indique en outre que le signe (+ ou -) devra imprativement

s'afficher (par dfaut seuls les - s'affichent)[ beaucoup d'autres directives sont disponibles pour les nombres flottants, etpour chacun des autres types. ]

%% permet d'inclure un caractre % sans qu'il soit interprt comme le dbutd'une squence

Au del, se souvenir que printf() est une mthode la fois puissante et flexible ; privilgier ds qu'un simple print() ou println() ne suffit pas, et ce d'autant plusqu'elle permet de formater des donnes cres par l'utilisateur ds lors que cesdonnes se conforment l'interface Formattable .Outre printf(), il peut tre utile de connatre la mthode statique String.format()qui s'appuie sur la mme syntaxe que printf() mais se contente de retourner lachane de caractres produite au lieu de l'afficher.NOTA-BENE : comme pour tout aspect non-trivial de Java, il ne faut pas chercher tout dcouvrir et encore moins tout mmoriser par avance. Concernant, parexemple, printf(), il faut bien comprendre et mmoriser le mode gnral defonctionnement, puis, lorsque ncessaire, approfondir ses connaissances enparcourant la documentation de rfrence en-ligne (l'ensemble des possibilits deformatage permises par la classe Formatter occupe 5 pages) et/ou en cherchant desexemples dans une base telle que http://www.java2s.com.

10 - Accessoirement, elle prsente l'avantage de fonctionner de manire similaire la fonction de mme nomdu langage C, et donc d'tre facile d'utilisation pour tous les programmeurs en C.

44

F. Exemple de programme, compilation, excution

Exemple de programme // Dbut du fichier : les import import java.util.Scanner;

// Toutes les autres instructions sont dans une // (ou plusieurs) classe(s)public class MonProgramme {

// Un programme ordinaire contient toujours // une fonction principale (main) : public static void main(String[] args) { System.out.print("Entrez un int : "); Scanner sc = new Scanner(System.in); int n = sc.nextInt(); for (int i=0 ; i

III - Rfrences, tableaux, chanes de caractres, types numrs simples

III

Rfrences 47

Tableaux 48

Chanes de caractres 53

Types numrs simples 55

Rfrences constantes 56

A. Rfrences

Les rfrences servent manipuler toutes les variables dont le type n'est pasprimitif (i.e. tableaux, objets, types numrs)

A voir comme une sorte de poigne , un mcanisme intermdiaire entre un nomde variable et l'emplacement en mmoire o est stocke sa valeur

NOTA-BENE : plusieurs rfrences diffrentes peuvent rfrencer un mme objet ou tableau les rfrences sont types le mot-cl null dsigne une rfrence vers rien (compatible avec tous

types de rfrence) une affectation entre rfrences modifie la rfrence en partie gauche de

l'affectation, et non la chose rfrence

Exemple : int t1[] = {1, 2, 3};int t2[] = t1; // t2 rf. le mme tableau que t1t2 = new int[5]; // t1 reste rf. {1,2,3}t1 = null; // t1 ne pointe plus vers rien

47

B. Tableaux

Principes Manipuls par des rfrences Allocation dynamique par new ( taille dfinissable l'excution) Taille fixe une fois pour toute aprs allocation Taille accessible tout moment par le champ length Indices variant entre 0 et length-1 (et vrification systmatique des bornes

l'utilisation)

Complment : stockage des tableaux en mmoireContrairement C/C++, les tableaux en Java ne sont pas stocks sous forme d'unesimple zone mmoire de taille gale la longueur du tableau multiplie par la tailled'un lment (avec possibilit de naviguer librement dans la zone mmoire ainsidlimite, et mme au del tant donn le niveau de libert offert par les oprationssur pointeurs dans ces deux langages). En Java, le stockage d'un tableau inclut sa taille. Surtout, l'accs aux cases du tableauest strictement contrl pour interdire toute lecture/criture en dehors des limitesqu'il occupe en mmoire, et plus gnralement toute opration non conforme entermes de typage (en Java, chaque lment d'un tableau doit tre du type indiqulors de sa dclaration).Par ailleurs, les tableaux en Java ne sont pas des instances d'une classe (voir plusloin) comme dans d'autres langages objet : ce sont des entits particulires, ni typeprimitif, ni instance de classe.

Dclaration, cration, initialisation

Dclaration : int tab[]; // 1 forme autoriseint [] tab2; // 2 forme autorise (quivalente)

Cration : - par new aprs la dclaration (ou lors de la dclaration) : int tab[]; // dclarationtab = new int[5]; // cration - cration implicite en cas d'initialisation lors de la cration (voir ci-dessous)

Initialisation : // A la dclaration :int tab[] = {1, 2, 3}; // Lors de la cration :tab = new int[] {1, 2, 3}; NOTA-BENE : par dfaut, les cases du tableau sont initialises 0, '\u0000', false ounull (selon le type de base)

48

AttentionIl ne faut jamais spcifier de dimension (entier entre les crochets) lors :

d'une simple dclaration : on doit crire int tab[]; et surtout pas inttab[5];

d'une cration comportant la liste des valeurs initiales : on doit crire tab =new tab[]{1,2,3,4,5}; et surtout pas tab = new tab[5]{1,2,3,4,5};

Manipulations usuelles

Accs la taille : int [] tab = new int[5];int size = tab.length; // size vaut 5

Accs aux valeurs stockes : tab[0] = 1;tab[4] = -1;// RAPPEL : les indices varient entre 0 et length-1

Affichage : for(val : tab) { System.out.println(val) ;}// affiche quoi ? // ATTENTION :System.out.println(tab) ;// affiche tab en tant que rfrence// (adresse mmoire o est stocke le contenu)

Affectation (attention, l'affectation ne modifie que la rfrence ) : int t1[] = {1, 2, 3};int t2[] = {4, 5};t1 = t2; // t1 rfrence le mme tableau que t2// NOTA-BENE : le tableau {1, 2, 3} n'est plus rfrenc,// l'espace mmoire correspondant sera automatiquement// rcupr par le ramasse-miette (GC) afin de// pouvoir le r-allouer ultrieurement.

Recherche, tri, etc. : voir fonctions utilitaires de la classe Arrays (cf.Introduction p 149)

AttentionLancement de l'exception (cf. Principe des exceptions p 91)ArrayIndexOutOfBoundsException en cas de tentative d'accs hors des bornes d'untableau (indice ngatif ou >= t.length)

DfinitionOn appelle ramasse-miettes (en anglais : garbage collector ou encore GC) lemcanisme intgr l'interprteur du langage (la machine virtuelle dans le cas de

Rfrences, tableaux, chanes de caractres, types numrs simples

49

Java) qui rcupre de manire automatique les zones mmoires alloues puis renduesinaccessibles au fil de l'excution du programme. Tous les langages n'incluent pas de ramasse-miette , l'alternative tant deconfier au programmeur la tche de librer explicitement les zones mmoire dont iln'a plus l'usage (cas des langages C et C++ par exemple). En pratique, la prsence d'un ramasse-miette simplifie la programmation etrend les programmes plus fiables, mais cela se paye par :

une dgradation (et une moindre prvisibilit) des performances l'excution ;

l'impossibilit de procder certaines optimisations trs spcifiques lies l'organisation des donnes en mmoire.

Dans tous les cas, il est essentiel de recycler les zones mmoire sans quoi la taille desprogrammes grossit inutilement au cours de l'excution (on parle alors de fuite demmoire ou memory leak en anglais).

Exemple public class ExempleTableau { public static void main(String[] args) {

// DECLARATION : double[] tab;

// CREATION ET DIMENSIONNEMENT : int lg = 1 + (int)( 9*Math.random() ); tab = new