Version enseignant                                Module IP1 Programmation Orient´e Objets                     e       Le ...
2
Table des mati`res              e1 Avant propos                                                                           ...
4                                                                                                  `                      ...
`TABLE DES MATIERES                                                                                                       ...
6                                                                                                                         ...
Chapitre 1Avant propos    Ce polycopi´ de cours a pour objectif d’introduire les concepts fondamentaux de la program-     ...
8   CHAPITRE 1. AVANT PROPOS
Chapitre 2Introduction : le langage JAVA2.1      Pr´sentation           e    Java est une technologie compos´e d’un langag...
10                                       CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA         form´ de byte code et est comp...
2.4. STRUCTURE D’UN PROGRAMME JAVA                                                                 112.3.1    Le concept d...
12                                      CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA}    Une classe contient une ou plusieur...
2.4. STRUCTURE D’UN PROGRAMME JAVA                                                              13    {        System.out....
14                                     CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA         resultat = entier1 + entier2;   ...
ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES                                    15   – Si ce n’est pas...
16                                      CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVALes constantes peuvent s’´crire sous for...
ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES                                  17    En JAVA, les d´cla...
18                                          CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA                               p1   ...
ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES                                     19      fait ´crire n...
20                                      CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA2.6.3      Les structures de contrˆle   ...
ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES                                 21    }}switch    L’instr...
22                                       CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVAExemplepublic class Boucle{  public sta...
ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES                             23   – initialisation est une...
24                                     CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA{     public static void main(String args...
`2.7. UNE PREMIERE INTRODUCTION AU TYPE STRING                                                 25        {            Syst...
26                                     CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVAAcc`s ` un caract`re   e a           echa...
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Polycope java enseignant
Prochain SlideShare
Chargement dans…5
×

Polycope java enseignant

4 766 vues

Publié le

Cours POO très interessant niveau débutant

Publié dans : Formation
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
4 766
Sur SlideShare
0
Issues des intégrations
0
Intégrations
2
Actions
Partages
0
Téléchargements
138
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Polycope java enseignant

  1. 1. Version enseignant Module IP1 Programmation Orient´e Objets e Le Langage JAVA Amaury Habrard Universit´ de Provence Aix-Marseille I e amaury.habrard@lif.univ-mrs.fr
  2. 2. 2
  3. 3. Table des mati`res e1 Avant propos 72 Introduction : le langage JAVA 9 2.1 Pr´sentation . . . . . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 9 2.2 Historique du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.2.1 Quelques mots cl´s . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 10 2.3 Java et la programmation orient´e objet . . . . . . . . . . e . . . . . . . . . . . . . . 10 2.3.1 Le concept d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.3.2 Ind´pendance vis ` vis de la plateforme . . . . . . e a . . . . . . . . . . . . . . 11 2.4 Structure d’un programme JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.4.1 Que contient un fichier source ? . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.4.2 Execution d’un programme Java . . . . . . . . . . . . . . . . . . . . . . . . 12 2.4.3 La machine virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.4.4 La m´thode main . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 12 2.4.5 Utilisation d’arguments dans la fonction main . . . . . . . . . . . . . . . . . 13 2.5 Installation et utilisation de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.6 Types, expressions et structures de contrˆle fondamentales o . . . . . . . . . . . . . . 15 2.6.1 les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 La notion de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 le type entier (int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Les flottants/r´els (float ou double) . . . . . . . . e . . . . . . . . . . . . . . 16 Le type caract`re (char) . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 16 Le type bool´en (boolean) . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 16 Initialisations et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.6.2 Op´rateurs et expressions . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 17 Op´rateurs arithm´tiques . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 17 Op´rateurs de comparaison . . . . . . . . . . . . . e . . . . . . . . . . . . . . 17 Op´rateurs logiques . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 18 Op´rateurs d’affectation . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 18 Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Op´rateur conditionnel . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 19 Priorit´ des op´rateurs . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 19 2.6.3 Les structures de contrˆle . . . . . . . . . . . . . . o . . . . . . . . . . . . . . 20 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Les instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . 24 2.6.4 Les ´l´ments sp´cifiques au langage JAVA . . . . . ee e . . . . . . . . . . . . . . 25 2.7 Une premi`re introduction au type String . . . . . . . . . e . . . . . . . . . . . . . . 25 2.8 R`gles d’´criture d’un programme JAVA . . . . . . . . . e e . . . . . . . . . . . . . . 26 3
  4. 4. 4 ` TABLE DES MATIERES 2.8.1 Les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.8.2 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 2.8.3 Mots cl´s r´serv´s . . . . . . . . . . . . . . . . . e e e . . . . . . . . . . . . . . . 27 2.8.4 Remarques globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 2.8.5 Commentaires sur le rendu d’un programme Java . . . . . . . . . . . . . . . 27 2.8.6 Liens sur la programmation JAVA . . . . . . . . . . . . . . . . . . . . . . . 28 2.8.7 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.9 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.9.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.9.2 Mots crois´s . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . 313 La notion d’objets : d´finition et utilisation e 33 3.1 Introduction au d´veloppement objets . . . . . . . . . . . e . . . . . . . . . . . . . . 33 3.2 La notion de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.2.1 Exemple de classe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 3.2.2 Cr´ation d’un objet ` l’aide d’une classe . . . . . . e a . . . . . . . . . . . . . . 36 3.2.3 Exemple d’utilisation dans un programme complet . . . . . . . . . . . . . . 37 3.3 La notion de constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 3.4 Affectation et comparaison d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 3.4.1 La r´f´rence null . . . . . . . . . . . . . . . . . . . ee . . . . . . . . . . . . . . 40 3.5 Le ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 3.6 L’encapsulation de donn´es . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 41 3.7 Champs et m´thodes statiques . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 43 3.7.1 Variables statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.7.2 Les m´thodes statiques . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 45 3.8 Surd´finition/surcharge de m´thodes . . . . . . . . . . . . e e . . . . . . . . . . . . . . 46 3.8.1 Surd´finition de constructeurs . . . . . . . . . . . . e . . . . . . . . . . . . . . 47 3.9 La copie d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 3.10 Autor´f´rencement : le mot cl´ this . . . . . . . . . . . . ee e . . . . . . . . . . . . . . 49 3.11 Remarques sur la d´finition de m´thodes . . . . . . . . . . e e . . . . . . . . . . . . . . 51 3.11.1 M´thodes de type proc´dures et fonctions . . . . . e e . . . . . . . . . . . . . . 51 3.11.2 Les arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 3.11.3 Les variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 3.11.4 La r´cursivit´ . . . . . . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 53 3.12 Les paquetages (packages) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 3.12.1 Attribution d’une classe ` un paquetage . . . . . . a . . . . . . . . . . . . . . 53 3.12.2 Utilisation d’une classe situ´e dans une paquetage e . . . . . . . . . . . . . . 54 3.12.3 Droits d’acc`s . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 55 3.13 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 3.13.1 D´claration et cr´ation . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . 55 3.13.2 Tableau en argument ou en retour . . . . . . . . . . . . . . . . . . . . . . . 58 3.13.3 Les tableaux ` plusieurs indices . . . . . . . . . . . a . . . . . . . . . . . . . . 59 3.14 Exercices de cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 3.14.1 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 3.14.2 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 3.14.3 Compilateur 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 3.14.4 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 3.14.5 Compilateur 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 3.14.6 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 68 3.14.7 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . 69
  5. 5. `TABLE DES MATIERES 54 Les concepts d’H´ritage et de Polymorphisme e 71 4.1 Pr´sentation et d´finition . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . 71 4.2 Construction et initialisation des objets d´riv´s e e . . . . . . . . . . . . . . . . . . . . 74 4.3 Red´finition, surd´finition et h´ritage . . . . . . e e e . . . . . . . . . . . . . . . . . . . . 76 4.3.1 Red´finition . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . 76 4.3.2 La surchage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 4.3.3 En r´sum´ . . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . 77 4.4 Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 4.4.1 Tableaux h´t´rog`nes d’objets . . . . . . ee e . . . . . . . . . . . . . . . . . . . . 79 4.4.2 R`gles du polymorphisme en Java . . . e . . . . . . . . . . . . . . . . . . . . 80 4.5 La super-classe Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 4.6 Acc`s par membres prot´g´s : protected . . . e e e . . . . . . . . . . . . . . . . . . . . 82 4.7 M´thodes et classes finales . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . 82 4.8 Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 4.9 Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 4.9.1 D´finition et mise en œuvre . . . . . . . e . . . . . . . . . . . . . . . . . . . . 84 4.9.2 Int´rˆt des interfaces . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . . 85 4.10 Connaˆ la classe et les types d’un objet . . . ıtre . . . . . . . . . . . . . . . . . . . . 85 4.10.1 L’op´rateur instanceof . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . 85 4.10.2 La class Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 4.11 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 4.11.1 Classes abstraites - classes concr`tes . . e . . . . . . . . . . . . . . . . . . . . 87 4.11.2 Compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 4.11.3 Qui suis-je ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 4.11.4 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905 La gestion d’exceptions 91 5.1 Pr´sentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . 91 5.2 Gestion de plusieurs exceptions et transmission d’informations . . . . . . . . . . . 92 5.3 D´rivation et red´clenchement d’exceptions . . . . . . . . . . . e e . . . . . . . . . . . 95 5.4 Le bloc finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 5.5 Les exceptions standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 5.6 Exercices de Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.6.1 Vrai ou Faux ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.6.2 Mots crois´s . . . . . . . . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . 1016 Les chaˆınes de caract`res en Java e 103 6.1 Le type String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.1.1 Les chaˆ ınes de caract`res sont des objets . . . . . e . . . . . . . . . . . . . . . 103 6.1.2 Affichage d’une chaˆ . . . . . . . . . . . . . . . ıne . . . . . . . . . . . . . . . 103 6.1.3 Longueur d’une chaˆ . . . . . . . . . . . . . . . ıne . . . . . . . . . . . . . . . 103 6.1.4 acc`s aux caract`res . . . . . . . . . . . . . . . . e e . . . . . . . . . . . . . . . 103 6.1.5 Concat´nation : l’op´rateur + . . . . . . . . . . . e e . . . . . . . . . . . . . . . 104 6.1.6 Recherche dans une chaˆ : la m´thode indexOf ıne e . . . . . . . . . . . . . . . 104 6.1.7 La comparaison de chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Tester l’´galit´ de deux chaˆ e e ınes . . . . . . . . . . . . . . . . . . . . . . . . . 104 Comparer deux chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.1.8 Modification d’un caract`re . . . . . . . . . . . . e . . . . . . . . . . . . . . . 105 6.1.9 Extraction de sous-chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.1.10 Passage en majuscules/minuscules . . . . . . . . . . . . . . . . . . . . . . . 105 6.1.11 Conversion d’une chaˆ vers un type primitif . . ıne . . . . . . . . . . . . . . . 105 6.1.12 Conversion d’un type primitif vers une chaˆ . . ıne . . . . . . . . . . . . . . . 105 6.1.13 Chaˆınes et tableaux de caract`res . . . . . . . . . e . . . . . . . . . . . . . . . 106 6.1.14 Tableau de chaˆ ınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
  6. 6. 6 ` TABLE DES MATIERES 6.2 La classe StringBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.3 La classe StringTokenizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067 Les entr´es/sorties e 109 7.1 Les fichiers, la classe File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.1.1 Les champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.1.2 Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.1.3 Les m´thodes . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.2 Les flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 7.3 Lecture/´criture . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1118 Quelques ´l´ments de l’API ee 113 8.1 La classe Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 8.2 Les classes enveloppes pour les valeurs primitives . . . . . . . . . . . . . . . . . . . 113 8.3 Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 8.3.1 D´finition . . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . 114 8.3.2 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 L’ancienne classe Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 8.3.3 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 8.3.4 Les algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 Recherche de maximum ou minimum . . . . . . . . . . . . . . . . . . . . . . 118 Algorithme de tris et m´langes . . . . . . e . . . . . . . . . . . . . . . . . . . 119 8.3.5 Les tables associatives (HashMap) . . . . . . . . . . . . . . . . . . . . . . . . 120 8.4 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 8.4.1 El´ments disponibles a partir de Java 1.5 e ` . . . . . . . . . . . . . . . . . . . 123 Boucle for am´lior´e . . . . . . . . . . . . e e . . . . . . . . . . . . . . . . . . . 123 8.4.2 G´n´ricit´ . . . . . . . . . . . . . . . . . . e e e . . . . . . . . . . . . . . . . . . . 123 8.4.3 R´flection et Manipulation des types . . . e . . . . . . . . . . . . . . . . . . . 123 8.5 Les autres ´l´ments de l’API . . . . . . . . . . . ee . . . . . . . . . . . . . . . . . . . 125
  7. 7. Chapitre 1Avant propos Ce polycopi´ de cours a pour objectif d’introduire les concepts fondamentaux de la program- emation objet ` l’aide du langage java. Il est compos´ de 4 chapitres de cours et de 3 chapitre a epr´sentant des ´l´ments de la biblioth`que du langage. A l’issue de chaque chapitre de cours, un e ee eensemble d’exercices originaux sont propos´s. Ces exercices sont compl´mentaires au exercices de e etravaux dirig´s et au travaux pratiques. Ils ont pour objectif de faire travailler les notions vues en ecours sous une forme diff´rente et d’insister sur le vocabulaire sp´cifique ` java ou ` la program- e e a amation objets, il est donc fortement conseill´ de chercher s´rieusement ces exercices. Voici un bref e edescriptif des diff´rents chapitres : e – Chapitre 2 : chapitre d’introduction pr´sentant le langage dans sa globalit´, son historique e e et les principes de bases pour ´crire un premier programme. On y d´taille tous les types e e primitifs, les structures de contrˆles et quelques structures fondamentales du langage. On o pr´sente ´galement les conventions ` suivre lorsque l’on programme en Java. e e a – Chapitre 3 : ce chapitre pr´sente la philosophie du langage : l’objet. On d´taille les diff´rentes e e e structures permettant de d´clarer et de cr´er les objets ainsi que les implications de chacune e e d’elles. – Chapitre 4 : on y introduit des concepts fondamentaux de la programmation objet l’h´ritagee et le polymorphisme. Ils font la force de ce type de programmation en permettant notam- ment une meilleure lisibilit´ des programmes et une plus grande facilit´ de r´utilisation de e e e l’existant. – Chapitre 5 : dans ce chapitre la gestion d’erreurs via la notion d’exception est pr´sent´e. Ce e e type de gestion est propre au langage java. – Chapitre 6 : premier chapitre pr´sentant une partie de la biblioth`que. On parle de l’acc`s ` e e e a des fonctions math´matiques, de l’utilisation de listes ou de tables associatives et quelques e algorithmes utilisables. – Chapitre 7 : pr´sentation des ´l´ments permettant de lire des flux et notamment de lire et e ee d’´crire dans des fichiers. e – Chapitre 8 : d´tail de toutes les classes de la biblioth`que permettant de g´rer des chaˆ e e e ınes de caract`res, type fondamental et traiter de mani`re sp´cifique en Java. e e e Ce document en est ` sa deuxi`me version, il existe de mani`re certaine des coquilles, des a e efautes de frappes, des oublis de mot, des erreurs de code involontaire, des copier/coller non perti-nents, . . . Dans le but d’am´liorer ce document, merci de signaler toutes ces erreurs. Si vous avez equelques suggestions pour am´liorer certaines parties, corriger certaines affirmations, elles sont les ebienvenues. Bonne lecture et bon travail ! 7
  8. 8. 8 CHAPITRE 1. AVANT PROPOS
  9. 9. Chapitre 2Introduction : le langage JAVA2.1 Pr´sentation e Java est une technologie compos´e d’un langage de programmation orient´ objet et d’un en- e evironnement d’ex´cution. Pr´alablement nomm´ Oak, il a ´t´ cr´´ par James Gosling et Patrick e e e e e eeNaughton chez Sun Microsystems avec le soutien de Bill Joy. Le langage Java fut officiellement pr´sent´ le 23 mai 1995 au SunWorld. e e Java est ` la fois un langage de programmation et une plateforme d’ex´cution. Le langage Java a ea la particularit´ principale d’ˆtre portable sur plusieurs syst`mes d’exploitation tels que Windows, e e eMacOS ou Linux. C’est la plateforme qui garantit la portabilit´ des applications d´velopp´es en e e eJava. Le langage reprend en grande partie la syntaxe du langage C++, tr`s utilis´ par les infor- e ematiciens. N´anmoins, Java a ´t´ ´pur´ des concepts les plus subtils du C++ et ` la fois les e ee e e aplus d´routants, tels que les pointeurs. Les concepteurs ont privil´gi´ l’approche orient´e objet de e e e esorte qu’en Java, tout est objet ` l’exception des primitives (nombres entiers, nombres ` virgule a aflottante, etc.). Java permet de d´velopper des applications autonomes mais aussi, et surtout, des applications eclient-serveur. Cˆt´ client, les applets sont ` l’origine de la notori´t´ du langage. C’est surtout cˆt´ o e a ee o eserveur que Java s’est impos´ dans le milieu de l’entreprise grˆce aux servlets, le pendant serveur e ades applets, et plus r´cemment les JSP (Java Server Pages) qui peuvent se substituer ` PHP et e aASP. Les applications Java peuvent ˆtre ex´cut´es sur tous les syst`mes d’exploitation pour lesquels a e e e e´t´ d´velopp´e une plateforme Java, dont le nom technique est JRE (Java Runtime Environment -ee e eEnvironnement d’ex´cution Java). Cette derni`re est constitu´e d’une JVM (Java Virtual Machine e e e- Machine Virtuelle Java), le programme qui interpr`te le code Java et le convertit en code natif. eMais le JRE est surtout constitu´ d’une biblioth`que standard ` partir de laquelle doivent ˆtre e e a ed´velopp´s tous les programmes en Java. C’est la garantie de portabilit´ qui a fait la r´ussite de e e e eJava dans les architectures client-serveur en facilitant la migration entre serveurs, tr`s difficile epour les gros syst`mes. e Dans le cadre de ce cours notre objectif sera d’´tudier les concepts fondamentaux de la pro- egrammation objet ` l’aide du langage java. Le but est d’acqu´rir les bases permettant ensuite de a ed´velopper des applications plus consistantes. e2.2 Historique du langage – Naissance ≡ 1991 : conception d’un langage applicable ` de petits appareils ´lectriques (on a e parle de code embarqu´) par la soci´t´ Sun Microsystem. La syntaxe est proche du C++, e ee utilisant le concept de machine virtuelle. Le code source est traduit dans un langage universel disposant de fonctionnalit´s communes ` toutes les machines. Ce code interm´diaire est dit e a e 9
  10. 10. 10 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA form´ de byte code et est compact et portable sur n’importe quelle machine : il suffit qu’elle e dispose d’un programme permettant d’interpr´ter le langage, on parle de machine virtuelle. e Ce projet s’appelait Oak. – Et´ 1992 : premi`re pr´sentation interne des possibilit´s de Oak. Un appareil appel´ ”Star e e e e e Seven” permet de visualiser une animation montrant Duke, l’actuelle mascotte de Java. – 1994 : d´veloppement de HotJava, un navigateur internet enti`rement ´crit en Java capable e e e d’ex´cuter des applets ´crites en byte code. e e – 1995 : lancement officiel de Java 1.0 – 1996 : lancement du JDK 1.0 et des versions 1.01 et 1.02 du langage JAVA (250 classes dans la biblioth`que). e – 1998 : version 1.1 du JDK (500 classes). – 1999 : version 1.2 JDK que l’on appelle Java2 (1500 classes) – 2000 : version de J2SE (Java 2 Standard Edition) 1.3 (1800 classes) – 2002 : version de J2SE (Java 2 Standard Edition) 1.4 (2700 classes), applications web et entreprises. – 2003 : version de J2EE (Java 2 Entreprise Edition) 1.4. – 2004 : version du J2SE 1.5 ´galement appel´ J2SE 5.0 ou Java 5 (3500) classes e e – 2006 : version du J2SE 1.6 ´galement appel´ J2SE 6.0 ou Java 6 (3500) classes e e2.2.1 Quelques mots cl´s e – JRE : Java Runtime Environnement logiciel permettant d’ex´cuter des applications java. e – JDK : Java Development Kit logiciel permettant de concevoir et d’ex´cuter des applications e java. – J2SDK : Java 2 Software Development Kit mˆme chose que pr´c´demment. e e e – API : Application Programming Interface (interface de programmation) qui d´finit la mani`re e e dont un composant informatique peut communiquer avec un autre. Dans le cas de Java, ce terme d´signe une biblioth`que de classes et de fonctionnalit´s mises ` disposition du e e e a programmeur. – J2EE : Java 2 Platform, Enterprise Edition Java 2 Platform, Enterprise Edition est une sp´cification pour le langage de programmation Java de Sun plus particuli`rement des- e e tin´e aux applications d’entreprise. Dans ce but, toute impl´mentation de cette sp´cification e e e contient un ensemble d’extension au cadre d’applications Java standard (J2SE, Java 2 standard edition) afin de faciliter la cr´ation d’applications r´parties. Voici quelques API e e pr´sentes dans cette extension : Servlets, JSP, JDBC, JAXB, RMI, . . . e – javac programme contenu dans le JDK pour compiler des programmes java. – java nom du langage programme contenu dans le JDK ou JRE pour lancer des programmes java. – javadoc programme contenu dans le JDK pour cr´er automatiquement une documentation e HTML ` partir de sources java. a – jar programme contenu dans le JDK pour compresser un (ou des programmes java) dans un seul fichier.2.3 Java et la programmation orient´e objet e La programmation orient´e objets se caract´rise par 3 points importants : e e – une programmation structur´e, e – fiabilit´ des logiciels accrue, e – facilite la r´utilisation du code existant. e
  11. 11. 2.4. STRUCTURE D’UN PROGRAMME JAVA 112.3.1 Le concept d’objets En programmation imp´rative (par exemple le langage C), un programme est form´ de diff´rentes e e eproc´dures et structures de donn´es g´n´ralement ind´pendantes des proc´dures. e e e e e e En programmation orient´e objets, on met en œuvre diff´rents objets. Chaque objet associe e edes donn´es et des m´thodes agissant exclusivement sur les donn´es de l’objet. e e e – On parle de m´thodes plutˆt que de proc´dures. e o e – On utilise indiff´remment le mot champ, donn´e ou encore attribut pour les variables as- e e soci´es ` l’objet. e a L’encapsulation de donn´es : il n’est pas possible d’agir directement sur les donn´es d’un objet, e eil est n´cessaire de passer par des m´thodes associ´es ` l’objet. Ces m´thodes jouent le rˆle d’in- e e e a e oterface obligatoire. L’appel d’une m´thode peut ˆtre vu comme l’envoi d’un message ` un objet. e e aVu de l’ext´rieur, un objet se caract´rise uniquement par ses sp´cification (donn´es attributs) et e e e eses m´thodes. e La notion de classe : – elle g´n´ralise la notion de type de donn´e, e e e – elle permet de d´crire un ensemble d’objets ayant une structure de donn´es commune et e e disposant de mˆmes m´thodes. e e – Les objets apparaissent comme des variables d’un type de classe donn´e, on parle d’instances e de classe. La notion d’h´ritage. Elle permet de d´finir une nouvelle classe ` partir d’une autre. On r´utilise e e a ecette derni`re en bloc et on lui ajoute de nouvelles fonctionnalit´s. La conception d’une nouvelle e eclasse, qui h´rite (r´cup`re) toutes les propri´t´s et aptitudes de l’ancienne. Il est ainsi possible e e e eede s’appuyer sur des r´alisations ant´rieures parfaitement au point et les sp´cifier ` volont´. Ceci e e e a efacilite donc la r´utilisation de code ou de logiciel d´j` existant. e ea La programmation objet facilite ´norm´ment la r´alisation d’interfaces graphiques. Chaque e e e´l´ment de l’interface est vu comme un objet, par exemple un objet fenˆtre, plusieurs objets bou-ee etons, un objet ascenseur, etc.2.3.2 Ind´pendance vis ` vis de la plateforme e a La portabilit´ du code. Un programme est portable si un mˆme code source peut ˆtre exploit´ e e e edans des environnements diff´rents moyennant une nouvelle compilation. En Java, il existe la enotion de machine virtuelle java - la JVM (pour Java Virtual Machine) - qui peut ex´cuter le emˆme code sur n’importe quelle plateforme en utilisant un code source sous forme de bytecode : un elangage machine sp´cifique ` la plateforme Java. La cr´ation d’un programme Java s’effectue en e a e2 temps : une phase de compilation qui transforme le code source en bytecode. Le code est ensuiteinterpr´t´ sur une machine virtuelle Java ee2.4 Structure d’un programme JAVA2.4.1 Que contient un fichier source ? Un fichier source porte l’extension .java et contient la d´finition de classe. La d´finition d’une e eclasse est d´finie par 2 accolades. epublic class Chien{//code de la classe JAVA
  12. 12. 12 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA} Une classe contient une ou plusieurs m´thodes. Par exemple dans la classe Chien, la m´thode e eaboyer() va contenir des instructions sp´cifiant la fa¸on dont un chien aboie. Les m´thodes sont e c eobligatoirement d´clar´es dans une classe. e epublic class Chien{ void aboyer() { // code de la methode aboyer o` l’on indique comment u // la m´thode doit ^tre ex´cut´e e e e e }}2.4.2 Execution d’un programme Java Source Compilation Execution On compile le(s) fichier(s) source(s) avec le programme L’ex´cution est lanc´e en uti- e e javac, par exemple javac lisant le programme java On cr´e un document source e Toto.java. Si la compilation avec le nom du fichier princi- avec une extension .java, par a r´ussi, un fichier .class e pal du programme sans l’ex- exemple Toto.java Toto.class est cr´´, ce fi- ee tension .class. Par exemple chier est constitu´ de byte e java Toto. code2.4.3 La machine virtuelle Un programme s’ex´cute en lan¸ant la JVM sur le fichier principal (Toto.class). Ce fichier e ccontient du byte code et la JVM traduit ce byte code en code machine compr´hensible par la eplateforme sous-jacente et ex´cute le programme. e Lorsque la JVM d´marre elle cherche la classe sp´cifi´e ` l’ex´cution, puis elle recherche une e e e a em´thode sp´ciale – la m´thode main – qui ressemble exactement ` ceci : e e e apublic static void main(String [] args){ //le code de la methode main} La JVM ex´cute ensuite tout ce qui se trouve entre les accolades{ } de la m´thode main. e e2.4.4 La m´thode main e Toute application java a au moins une m´thode main. Attention, pas une par classe, mais au emoins une par application. La m´thode main correspond ` l’endroit o` le programme commence e a ua` s’ex´cuter. e Voici un exemple de programme complet :public class PremiereAppli{ public static void main(String [] args)
  13. 13. 2.4. STRUCTURE D’UN PROGRAMME JAVA 13 { System.out.println("Bonjour ` tous"); a System.out.println("Je m’appelle toto"); }} 1. Enregistrement dans le fichier PremiereAppli.java 2. Compilation javac PremiereAppli.java 3. Lancement du programme java PremiereAppli 4. Le r´sultat du programme consiste ` afficher les 2 lignes suivantes : e a Bonjour a tous ` Je m’appelle toto2.4.5 Utilisation d’arguments dans la fonction main Les arguments de la m´thode main sont plac´s dans le tableau args, qui est un tableau constitu´ e e ede chaˆınes. Lors du lancement d’un programme, les arguments se placent a la suite de l’identificateur de `classe du programme lanc´ et sont s´par´s par un espace. Exemple : e e ejava AfficheArguments Le langage Java Voici le programme correspondant :public class AfficheArguments{ public static void main(String [] args) { for(int i=0;i<args.length;i++) { System.out.println("contenu de args[".i."] : ".args[i]); } }} A l’ex´cution, ce programme affiche le r´sultat suivant : e eargs[0] : Leargs[1] : langageargs[2] : JavaN.B. Les arguments sont pass´s sous la forme de chaˆnes de caract`res, si nous voulons des e ı enombres nous devons convertir les arguments.Exemple.public class Addition2Entiers{ public static void main(String [] args) { int entier1, entier2, resultat; entier1=Integer.parseInt(args[0]); entier2=Integer.parseInt(args[1]);
  14. 14. 14 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA resultat = entier1 + entier2; System.out.println("La somme de "+entier1+" et "+entier2+" est : "+resultat); }} Pour lancer le programme : java Addition2Entiers 1 3. Autre exemple.public class ConversionFrancsEuros{ public static void main(String [] args) { final float taux = 6.55957; float somme = 0, resultat; somme=Float.parseFloat(args[0]); resultat = somme / taux; System.out.println("Le resultat de la convertion de "+somme+"francs est "+resultat+" euros."); }}2.5 Installation et utilisation de Java Pour installer un outil de d´veloppement java, il suffit de r´cup´rer un outil de d´veloppement e e e e(JDK ou SDK) sur http://java.sun.com/javase/downloads/index.jsp, puis de lancer le pro-gramme d’installation. Sous linux vous pouvez l’installer dans /usr/local pour le rendre accessiblea` tout le monde, ou sous votre compte. Ensuite nous allons principalement utiliser les programmes situ´s dans le r´pertoire bin - e e/usr/local/jdk1.6.0 06/bin par exemple si vous avez r´cup´r´ la version 06 du jdk 1.5 - javac, e e ejava, javadoc, jar, . . .). Pour faciliter leur utilisation vous pouvez mettre le r´pertoire bin dans evotre variable d’environnement PARH (cf le cours syst`me). e Pour ´crire nos programmes nous aurons seulement besoin d’un ´diteur (par exemple emacs e esous linux, ou tout un autre ´diteur si vous le souhaitez) et d’un terminal (xterm). e Vous pourrez ´ventuellement avoir de besoin de configurer une variable d’environnement CLASSPATH equi indique les r´pertoires o` sont situ´s les programmes java. Ce n’est pas obligatoire, par d´faut e u e eles programmes sont cherch´s dans le r´pertoire courant et il est possible d’indiquer des r´pertoires e e een sp´cifiant des options aux diff´rents programmes disponibles dans le jdk (voire la documentation e eofficielle indiqu´e dans les liens ci-dessous). e Quand vous serez plus exp´riment´ (par exemple ` partir du 4`me TP), vous pourrez essay´ e e a e ed’autres ´diteurs facilitant le d´veloppement de programmes java tels qu’eclipse ou NetBeans. A e evous de les essayer et ´ventuellement d’en adopter un. N´anmoins, il est d’abord conseill´ d’utiliser e e eun ´diteur non sp´cifique pour commencer, puis de passer ` un ´diteur sp´cialis´ une fois que l’on e e a e e emaˆ ıtrise les bases du langage. Pour ceux qui souhaitent essayer leurs programmes sous windows, la proc´dure d’installation est ela mˆme. Il peut cependant ˆtre n´cessaire de cr´er une variable d’environnement suppl´mentaire. e e e e eVoici la proc´dure ` suivre. e a – V´rifier que la variable d’environnement JAVA HOME est sp´cifi´e. e e e
  15. 15. ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 15 – Si ce n’est pas le cas allez dans Menu D´marrer → Settings → Control Panel → System → e Advanced, menu variables d’environnement. Entrez le nom de JAVA HOME puis sa valeur (par exemple C :2sdk1.6.0 06/). – Pour v´rifier tapez echo %JAVA HOME dans une console MS-DOS. e Vous pouvez utiliser la mˆme m´thode pour modifier le contenu de la variable PATH ou confi- e egurer CLASSPATH. En guise de terminal vous utiliserez alors une console MS-DOS.2.6 Types, expressions et structures de contrˆle fondamen- o tales Cette partie a pour objectif de pr´senter rapidement l’utilisation des types, des expressions eet des instructions de contrˆle en JAVA. Les ´l´ments abord´s ne sont pas forc´ment toujours o ee e ecaract´ristiques du langage JAVA mais sont n´cessaires pour l’utilisation de n’importe quel lan- e egage de programmation. Lorsque certaines situations sont sp´cifiques au langage JAVA, nous le epr´cisons. e2.6.1 les types primitifs Ils servent ` d´finir les champs (attributs) de toutes les classes que vous pourrez d´finir, ainsi a e eque les variables que vous pourrez utiliser dans les diff´rentes m´thodes. Attention, les types e eprimitifs ne sont pas des classes.La notion de type La m´moire centrale est un ensemble de ” positions binaires ” appel´es. Ces bits sont regroup´s e e een octets, un octet correspondant ` 8 bits. Les ordinateurs (actuels) ne savent repr´senter et traiter a eque des informations repr´sent´es sous forme binaire. Il est donc n´cessaire de savoir comment une e e einformation a ´t´ cod´e pour pouvoir attribuer une signification ` une suite de bits d’un emplace- ee e ament de la m´moire. eIl existe 4 cat´gories de type primitif en JAVA : e – nombres entiers – nombres flottants – caract`res e – bool´ens ele type entier (int) Il sert ` repr´senter les nombres entiers relatifs. Il existe quatre sortes d’entier permettant de a erepr´senter des valeurs diff´rentes. Le tableau suivant d´crit chacun de ces types avec le nom du e e etype, la taille occup´e en m´moire en octets, la valeur minimale et la valeur maximale possible e eavec la constante correspondante dans le langage. Nom Taille Valeur minimale Valeur maximale byte 1 -128 127 Byte.MIN VALUE Byte.MAX VALUE short 2 -32768 32767 Short.MIN VALUE Short.MAX VALUE int 4 -2,147,483,648 2,147,483,647 Integer.MIN VALUE Integer.MAX VALUE long 8 -9,223,372,036,854,775,808 9,223,372,036,854,775,807 Long.MIN VALUE Long.MAX VALUE
  16. 16. 16 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVALes constantes peuvent s’´crire sous forme d´cimale (548, -78, +5), ou sous forme hexad´cimale e e een pr´cisant la valeur de 0x ou 0x (0x1A 0X12), ou octale en faisant pr´c´der la valeur de 0 (032, e e e05). Une constante enti`re est forc´ment de l’un des types int ou long. On peut forcer une constante e e` ˆtre du type long en faisant suivre sa valeur de la lettre l ou L, exemple 25L. Le compilateuraerejettera toute constante ayant une valeur sup´rieure la capacit´ du type long. e eLes flottants/r´els (float ou double) e Il en existe deux sortes. Le tableau suivant d´crit chacun d’eux avec leur nom, la taille occup´e e een m´moire en octets, la pr´cision correspondant au nombre de chiffres significatifs pris en compte e edans la partie d´cimale, la valeur minimale et la valeur maximale possible avec la constante ecorrespondante dans le langage. Nom Taille Pr´cision e Valeur absolue minimale Valeur absolue maximale float 4 7 −1.40239046 × 10−45 3, 40282347 × 1038 Float.MIN VALUE Float.MAX VALUE double 8 15 4.9506564584124654 × 10− 324 1, 797693134862316 × 10308 Double.MIN VALUE Double.MAX VALUE Pour les constantes, il existe deux notations : – la notation d´cimale : 12.43 -0.38 -.38 4. .27 e – la notation exponentielle : 4.25E4 ou 4.25e+4 pour 4.25 × 104 54.2e-32 pour 54.2 × 10−32 48e13 pour 48 × 1013 Par d´faut toutes les constantes cr´´es sont de type double, pour forcer ` avoir un type float e ee aon fait suivre la valeur de la lettre f, exemple : 12.5fLe type caract`re (char) e Les caract`res, d´sign´s par le type char, sont cod´s sur 2 octets, notation d’une constante e e e ecaract`re : ’a’, ’B’, ’´’, ’+’. Exemple e echar lettre=’a’ ; Certains caract`res avec notation sp´ciale : e e – ’b’ pour le retour arri`re (backspace) e – ’t’ pour une tabulation – ’n’ pour un saut de ligne – ’f’ pour un saut de page – ’r’ pour un retour chariot – ’"’ pour un guillemet – ’’’ pour une apostrophe – ’’ pour .Le type bool´en (boolean) e Il sert ` repr´senter une valeur logique de type vrai ou faux, il existe deux valeurs possibles pour a eun bool´en en java : true et false (pour vrai et faux). Exemple boolean est ordonne=false ;. e Attention, en JAVA, les valeurs logiques ne sont pas repr´sent´es par des valeurs mais par un e etype sp´cifique : le type boolean, toute utilisation de valeur num´rique dans des tests provoquera e eune erreur !Initialisations et constantesVariables Exemples : int n=15 ; ´galement ´quivalent ` int n ; n=15 ;. e e a
  17. 17. ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 17 En JAVA, les d´clarations peuvent apparaˆ ` n’importe quel endroit du programme. D’un e ıtre apoint de vue m´thodologique, il est souvent conseill´ d’effectuer la d´claration de toutes les e e evariables (importantes) ensembles au d´but puis de les initialiser avant de les utiliser. eN.B. Les variables n’ayant pas re¸u de valeur ne peuvent pas ˆtre utilis´es sous peine d’aboutir c e ea une erreur de compilation. Il est donc important de penser a initialiser les variables d`s leur` ` ecr´ation. eConstantes : le mot cl´ final Pour indiquer qu’une variable ne peut pas ˆtre modifi´e pendant e e el’ex´cution d’un programme, on peut utiliser le mot cl´ final : e efinal int nombre de mois=12 ;Toute modification de la variable nombre de mois, de valeur initiale 12, sera rejet´e par le compi- elateur.2.6.2 Op´rateurs et expressions eOp´rateurs arithm´tiques e e Il existe cinq op´rateurs principaux : e – + : addition a+b – - : soustraction a-b – / : division a/b – * : multiplication a*b – % : modulo, a % b calcule le reste de la division de a par b. Le probl`me de la conversion de type : efloat x ; float res ;int n ; int p ;res=n*x+p ;La variable n ´tant de type int, x de type float, le compilateur va convertir n en float puis faire le ecalcul. Le r´sultat final sera de type float, comme le montre la Figure 2.1. e n * x + p int float long float * float + float float Fig. 2.1 – Evaluation de res=n*x+p ; La hi´rarchie de conversion permettant de ne pas d´naturer la valeur initiale : int → long e e→ float → double.Note : par d´faut, pour les types byte, char, short, si un de ces types apparaˆ dans une expression, e ıtla valeur est d’abord convertie en int. Exemple :short p1=1, p2=1 ,p3=1 ;float x=2 ;L’´valuation de p1*p2+p3*x est faite comme le montre la Figure 2.2. eOp´rateurs de comparaison e Ils servent ` faire des comparaisons relatives et sont principalement utilis´s dans les tests a econditionnels.
  18. 18. 18 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA p1 * p2 + p3 * x int int int * float * float int float float + float Fig. 2.2 – Evaluation de p1*p2+p3*x – < : inf´rieur strictement ` e a – <= : inf´rieur ou ´gal ` e e a – > : sup´rieur ` e a – >= : sup´rieur ou ´gal ` e e a – == : ´gal ` e a – ! = : diff´rent de. eCes op´rateurs peuvent s’utiliser avec des expressions : 2 ∗ a > b + 5, x + y < (a + 2) ∗ 5, . . . eNote : ordre sur les caract`res 0 < 1 < . . . < 9 < A < B < . . . < Z < a < . . . < z . eOp´rateurs logiques e Ces op´rateurs permettent de manipuler des valeurs logiques. e – ! : n´gation e – & : ”ET” – ∧ : ”OU” exclusif – | : ”OU” inclusif – && : ”ET” avec court-circuit – || : ”OU” inclusif avec court-circuitExemples : – (a < b) && (c < d), (a < b) & (c < d) : ces deux expressions prennent la valeur true (vrai) si les deux expressions a < b et c < d sont toutes les deux vraies, la valeur false (faux) dans le cas contraire. – (a < b) || (c < d), (a < b) | (c < d) : prend la valeur true si l’une au moins des deux conditions a < b ou c < d est vraie, la valeur false dans le cas contraire. – (a < b) ∧ (c < d) prend la valeur true si une et une seule des deux conditions a < b et c < d est vraie, la valeur false dans le cas contraire. – !(a < b) prend la valeur true si la condition a < b est fausse, la valeur false dans le cas contraire. Cette expression poss`de en fait la mˆme valeur que a >= b. e e – Les deux op´rateurs && et || poss`dent une propri´t´ int´ressante : leur second op´rande e e ee e e (celui qui figure ` droite de l’op´rateur) n’est ´valu´ que si la connaissance de sa valeur est a e e e indispensable pour d´cider si l’expression est vraie ou fausse. Par exemple, si on a l’expression e (a < b)&&(c < d), on commence par ´valuer (a < b), si le r´sultat est faux on n’´value pas e e e c < d puisque le r´sultat est d´j` connu. Les op´rateurs ∧ et | ´valuent toujours les deux e ea e e op´randes, il est donc plutˆt conseill´ d’utiliser les op´rateurs && et ||. e o e eOp´rateurs d’affectation e – = : exemples c=b+3 ; c=i ;. L’op´rateur poss`de une associativit´ de gauche ` droite, ainsi e e e a dans l’expression i = j = 5 ; on ´value j=5 d’abord, puis i=j, i et j ont ` la fin la mˆme e a e valeur 5. Attention aux probl`mes de conversion, supposons que nous ayons une variable de type int n e et une variable de type float x, l’expression n=x+5 ; est rejet´e par le compilateur. Il faut en e
  19. 19. ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 19 fait ´crire n=(int) x + 5 ;. Il est n´cessaire de faire une conversion explicite. Les conversions e e pour lesquelles il n’y a pas besoin de faire une conversion explicite sont les suivantes : – byte → short → int → long → float → double – char → int → long → float → double – L’incr´mentation et la d´cr´mentation. Ces op´rations consistent respectivement ` augmen- e e e e a ter une variable (en g´n´ral enti`re) 1 et ` diminuer une variable de 1 (i = i-1 ; n = n+1 ;). e e e a Ces op´rations sont d´finies par les op´rateurs ++ et -- : i-- ; n++ ; ou --i ; ++n ;. Il existe e e e cependant un diff´rence suivant o` est plac´ l’op´rateur lors de l’´valuation d’une expression, e u e e e s’il est plac´ avant(on parle d’op´rateur pr´fix´) la variable l’op´ration est effectu´e avant e e e e e e l’´valuation de l’expression, s’il est plac´ apr`s (on parle d’op´rateur postfix´) l’op´ration est e e e e e e effectu´e apr`s. e e – n= ++i -5 ; : on affecte d’abord la valeur 6 ` i puis la valeur 1 ` n. a a – n= i++ - 5 ; : on affecte d’abord la valeur 0 ` n puis la valeur 6 ` i. a a – Affectation ´largie, les instructions suivantes sont ´quivalentes : e e – i = i + k ; et i+=k ; Il existe la mˆme chose avec les op´rateurs *, / et -. e eConversion de types Lorsque l’on d´sire convertir un type vers autre qui a une taille de repr´sentation inf´rieure, e e eles r`gles suivantes s’appliquent : e – entier vers entier (long vers int, short vert byte, . . .) les octets les moins significatifs sont conserv´s. e – double vers float : arrondi au plus proche. – flottant vers entier : il y a d’abord un arrondi au plus proche dans le type long ou int, puis on effectue la conversion en conservant les octets les moins significatifs.Op´rateur conditionnel e condition ? etape1 : etape2 ; : si condition est vraie alors etape1 sinon etape 2. Exemple :max = a<b ? a :b ;Si a < b, alors la variable max re¸oit la valeur de la variable a, sinon elle re¸oit la valeur de la c cvariable b.Priorit´ des op´rateurs e e Op´rateurs e associativit´ e () [] . ++(postfix´) –(postfix´) e e g`d a +(unaire) -(unaire) ++(pr´fix´) –(pr´fix´) (unaire) ! cast new e e e e d`g a /% g`d a +- g`d a << >> >>> g`d a < <= > >= instanceof g`d a == != g`d a & g`d a ∧ g`d a — g`d a && g`d a — g`d a ?: g`d a = += -= *= /= %= <<= >>= >>>= & = | = ∧ = d`g a
  20. 20. 20 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA2.6.3 Les structures de contrˆle o Dans cette partie, les crochets [] signifient que ce qu’ils renferment est facultatif. Il servent soita` exprimer le fait que pour lier plusieurs instructions ` une structure de contrˆle il est n´cessaire a o ede mettre ces instructions dans un bloc entre accolades ({}) (si on n’a besoin que d’une seuleinstruction on n’a pas besoin de bloc) ; soit ` indiquer qu’une instruction facultative. a Le terme condition correspond ` une expression qui peut ˆtre ´valu´e sous forme logique (vrai a e e eou faux).if L’instruction if (si) est une instruction de choix.if(condition)[{] instruction_1[instruction_2...instruction_n}][else [{] instruction_1[instruction_2...instruction_n}]Exemple :public classTva { public static void main(String [] args) { double taux_tva=21.6; double ht, ttc, net, taux_remise, remise; ht=200.5; ttc=ht * (1.0 + taux_tva/100.0); if(ttc < 1000.0) taux_remise=0.; else if(ttc < 2000) taux_remise=1.; else if(ttc < 5000){ taux_remise=2.; System.out.println("Message: Prix ttc entre 2000 et 5000"); }else{ taux_remise=5.; System.out.println("Message: Prix ttc superieur a 5000"); } remise = ttc * taux_remise/100; net = ttc - remise; System.out.println("Prix ttc: "+ttc); System.out.println("Remise: "+remise); System.out.println("Net a payer: "+net);
  21. 21. ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 21 }}switch L’instruction switch (branchement) est une instruction de choix, permettant de tester plusieursvaleurs d’une expression. L’expression peut ˆtre de type byte, short, char ou int. e Syntaxe :switch(expression){ case constante_1: [suite d’instructions1] case constante_2: [suite d’instructions2] case constante_n: [suite d’instructionsn] [default: suite d’instructions]}Exemple :public class ExSwitch{ public static void main(String [] args) { int n; n=Integer.parseInt(args[0]); switch(n) { case 0: System.out.println("zero"); break; case 1: System.out.println("un"); break; case 3: System.out.println("trois"); default: System.out.println("Rien"); System.out.println("Fin"); } System.out.println("Fin du programme"); }}while Il s’agit d’une boucle tant que qui ex´cute un ensemble d’instructions tant qu’une condition eest vraie. Syntaxe :while(condition)[{] instruction_1 [instruction_2 ... instruction_n}]
  22. 22. 22 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVAExemplepublic class Boucle{ public static void main(String [] args) { int x=1; System.out.println("Avant la boucle"); while(x<4) { System.out.println("Dans la boucle, la valeur de x est "+x); x=x+1; } System.out.println("Apr`s la boucle"); e }}do-while Il s’agit d’une boucle faire-tant que similaire ` la boucle while sauf que la condition est ´valu´e a e eapr`s chaque parcours de boucle. La boucle do-while est ex´cut´e au moins une fois, alors que la e e eboucle while peut ne jamais ˆtre ex´cut´e. e e e Syntaxe :do [{] instruction_1 [instruction_2 ... instruction_n }] while(condition);N.B. Il y a un point virgule a la fin de l’instruction ! `Exemple :public class Boucle2{ public static void main (String [] args){ int x=1; System.out.println("Avant la boucle"); do{ System.out.println("Dans la boule, la valeur de x est "+x); x=x+1; }while(x<4); System.out.println("Apr`s la boucle"); e }}for L’instruction for est une boucle (pour) dont la syntaxe est divis´e en trois expressions. e Syntaxe :for([initialisation] ; [condition] ; [incr´mentation]) e[{]instruction_1[instruction_2...instruction_n}]
  23. 23. ˆ2.6. TYPES, EXPRESSIONS ET STRUCTURES DE CONTROLE FONDAMENTALES 23 – initialisation est une d´claration ou une suite d’expressions quelconques s´par´es par des e e e virgules, cette partie est ´valu´e une seule fois avant d’entrer dans la boucle. e e – condition est une expression bool´enne (logique) quelconque, cette partie conditionne la e poursuite de la boucle et est ´valu´e avant chaque parcours. e e – incr´mentation est une suite d’expressions quelconques s´par´es par des virgules, cette e e e partie est ´valu´e ` la fin de chaque parcours. e e aExemple classique :public class ExFor1{ public static void main (String args []) { int i; for(i=1; i<=5; i++) { System.out.println("bonjour"); System.out.println(i + "fois"); } }}Remarque : l’exemple pr´c´dent est ´quivalent ` e e e apublic class ExFor2{ public static void main (String args []) { int i; i=1; while(i<=5) { System.out.println("bonjour"); System.out.println(i+"fois"); i++; } }}Autre exemple :public class ExFor3{ public static void main(String args []) { int i,j; for(i=1, j=3;i<=5; i++, j+=i) { System.out.println("i= " +i+ "j= " +j); } }} Ce dernier exemple pourrait ´galement ˆtre ´crit de la mani`re suivante : e e e epublic class ExFor4
  24. 24. 24 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVA{ public static void main(String args []) { for(int i=1, j=3;i<=5; i++, j+=i) { System.out.println("i= " +i+ "j= " +j); } }}Les instructions break et continue Ces instructions s’emploient principalement au sein de boucles. L’instruction break (casser) sert ` interrompre le d´roulement d’une boucle en passant ` a e al’instruction situ´e apr`s la boucle. L’ex´cution de cette instruction est conditionn´e par un choix. e e e eExemple :public class ExBreak{ public static void main (String args []) { int i; for(i=1;i<=10;i++) { System.out.println("debut tour"+i); System.out.println("bonjour"); if(i==3) break; System.out.println("fin tour"+i); } System.out.println("apres ma boucle") }}Le r´sultat du programme pr´c´dent est le suivant : e e edebut tour 1bonjourfin tour 1debut tourbonjourfin tour 2debut tour 3bonjourapres la boucle En cas de boucles imbriqu´es, l’instruction break fait sortir de la boucle la plus interne. e L’instruction continue permet de passer directement au tour de boucle suivant. Exemple.public class ExContinue{ public static void main (String args[]) { int i; for(i=1; i<=5; i++)
  25. 25. `2.7. UNE PREMIERE INTRODUCTION AU TYPE STRING 25 { System.out.println("debut tour"+i); if (i<4) continue; System.out.println("fin tour"+i); } System.out.println("apres la boucle"); }}Exemple d’ex´cution : edebut tour 1debut tour 2debut tour 3debut tour 4fin tour 4debut tour 5fin tour 5apres la boucle2.6.4 Les ´l´ments sp´cifiques au langage JAVA ee e Parmi les points abord´s ci-dessus, quatre sont plutˆt sp´cifiques au langage JAVA. e o e – Le mot cl´ final qui permet de d´clarer des constantes ` l’aide de variables. e e a – Le type byte qui permet de repr´senter des entiers entre -128 et 127. e – Le type boolean pour repr´senter les valeurs true (vrai) et false (faux). Tous les tests e conditionnels doivent ˆtre compatibles avec le type boolean. Mettre une valeur enti`re dans e e un test provoque une erreur de compilation en JAVA (par exemple if(1)... est interdit en JAVA). – Les conversions de type doivent ˆtre explicites en JAVA chaque que l’on veut convertir un e type g´n´ral vers une repr´sentation plus petite. Exemple : e e e int n=2; float x=1.0; ... n=(int) x; Un autre ´l´ment est trait´ de mani`re sp´cifique en JAVA : le type chaˆ de caract`res ee e e e ıne e(String). Une introduction est propos´e dans la section suivante. e2.7 Une premi`re introduction au type String e En JAVA, les chaˆınes de caract`res sont d´finies par un type sp´cifique : le type String. Nous e e epr´sentons ici une courte introduction, nous reviendrons sur ce type plus tard. eD´claration eString chaineSalutation = "bonjour"; Une chaˆ de caract`re constante se d´clare toujours entre guillemets "... ". ıne e eConnaˆ ıtre la longueur d’une chaˆ ıneint l = chaineSalutation.length();
  26. 26. 26 CHAPITRE 2. INTRODUCTION : LE LANGAGE JAVAAcc`s ` un caract`re e a echar cara1 = chaineSalutation.charAt(0);char cara1 = chaineSalutation.charAt(2);La variable cara1 contient le caract`re b, la variable cara2 contient le caract`re n. e eConcat´nation : l’op´rateur + e eString ch1 = "Bonjour";String ch2 = " ` tous"; aString ch = ch1 + ch2; La variable ch contient la chaˆ ”Bonjour a tous”. ıne `Impression d’une chaˆ de caract`res ıne eSystem.out.println(chaineSalutation);System.out.println(ch1+ch2);System.out.println(ch);Comparaison de chaˆ ınes La m´thode equals qui teste l’´galit´ de deux chaˆ e e e ınes de caract`res : ech1.equals(ch2) ou ch1.equals("Bonjour"). La m´thode compareTo pour comparer deux chaˆ e ınes de caract`res dans l’ordre lexicographique e(alphab´tique) : ch1.compareTo(ch2) e – renvoie un entier strictement n´gatif si ch1 est situ´e avant ch2 dans l’ordre lexicographique e e – renvoie un entier strictement positif si ch1 est situ´e apr`s ch2 dans l’ordre lexicographique e e – 0 si ch1 contient la mˆme chaˆ que ch2. e ıne2.8 R`gles d’´criture d’un programme JAVA e e Ce document a pour objectif de synth´tiser les r`gles d’´criture g´n´ralement utilis´es pour le e e e e e ed´veloppement d’applications en JAVA. e2.8.1 Les identificateurs Les identificateurs sont des suites de caract`res servant ` d´signer les entit´s manipul´es par e a e e eun programme (variables, m´thodes, classes, objets, . . .). En JAVA, un identificateur est form´ de e elettres et de chiffres ou du caract`re . Le premier caract`re est forc´ment une lettre A-Z, a-z ou e e e´ventuellement . Il n’existe aucune limitation sur le nombre de caract`res. Exemples :e eligne, valeur 5, total, 56, ma variable 1, i, MaClasse, ...Attention, on distingue les minuscules des majuscules (ligne = Ligne). Certaines conventions sont traditionnellement utilis´es : e – Les noms de variables et de m´thodes sont ´crits en minuscule sauf s’ils sont form´s de la e e e juxtaposition de plusieurs mots, auquel cas chaque sous-mot, sauf le premier, comporte une majuscule ` la premi`re lettre. Exemples : valeur, nombreValeur, tauxEmprunt, a e calculNombreReponsesExactes, getX2, ... – Les noms de classe suivent la mˆme r`gle, mais leur premi`re lettre est ´crite en majuscule. e e e e Exemples : PremierProgramme, Clavier, CalculMoyenne, ... Remarque : cette convention permet de distinguer le fait que System est une classe et que out n’en est pas une (System.out.println).

×