Apprenez A Programmer en Java

Apprenez programmer en Java
Par cysboy
www.siteduzero.com
Licence Creative Commons BY-NC-SA 2.0 Dernire mise jour le 16/04/2012
Sommaire
1/669
Sommaire
Sommaire ........................................................................................................................................... Partager .............................................................................................................................................. Apprenez programmer en Java ....................................................................................................... Partie 1 : Bien commencer en Java .................................................................................................... 1 3 5 6
Parlons d'Eclipse ............................................................................................................................................................... 7

Prambule ................................................................................................................................................................................................................... 7 Tlchargement .......................................................................................................................................................................................................... 7 Installation ................................................................................................................................................................................................................... 8 Prsentation rapide de l'interface ................................................................................................................................................................................ 9 D'autres outils la hauteur ........................................................................................................................................................................................ 15 1. JBuilder ................................................................................................................................................................................................................ 16 2. NetBeans ............................................................................................................................................................................................................... 16
Votre premier programme ............................................................................................................................................... 17

Mieux connaitre son environnement Java ................................................................................................................................................................. Avant de commencer ................................................................................................................................................................................................ Votre premier programme ......................................................................................................................................................................................... Compilation en ligne de commande (Windows) ........................................................................................................................................................ Les diffrents types de variables ............................................................................................................................................................................... Les oprateurs arithmtiques .................................................................................................................................................................................... Les oprateurs arithmtiques .................................................................................................................................................................................... Les conversions, ou "cast" ........................................................................................................................................................................................ Astuce d'Eclipse ........................................................................................................................................................................................................ 18 19 22 24 27 30 30 33 35
Les variables et les oprateurs ....................................................................................................................................... 26
Lire les entres clavier .................................................................................................................................................... 36

Utilisation de l'objet Scanner ..................................................................................................................................................................................... 37 Rcuprez ce que vous tapez ................................................................................................................................................................................... 38
Les conditions ................................................................................................................................................................. 42

Les oprateurs logiques ............................................................................................................................................................................................ La structure if....else .................................................................................................................................................................................................. Les conditions multiples ............................................................................................................................................................................................ La structure switch .................................................................................................................................................................................................... La condition ternaire .................................................................................................................................................................................................. 42 42 45 46 48
Les boucles ..................................................................................................................................................................... 50

La boucle while .......................................................................................................................................................................................................... 51 La boucle do....while .................................................................................................................................................................................................. 55 La boucle for .............................................................................................................................................................................................................. 56
TP n1 : un tableau de conversion Celsius - Fahrenheit ! .............................................................................................. 58

laboration ................................................................................................................................................................................................................ 59 Conception ................................................................................................................................................................................................................ 61 Correction .................................................................................................................................................................................................................. 61
Les tableaux .................................................................................................................................................................... 63

Dclarer et initialiser un tableau ................................................................................................................................................................................ 64 Les tableaux multi-dimensionnels ............................................................................................................................................................................. 65 Utiliser et rechercher dans un tableau ! ..................................................................................................................................................................... 66 Un tableau multi-dimensionnel .................................................................................................................................................................................. 69
Les mthodes de classe ................................................................................................................................................. 74

Quelques mthodes bien utiles ! ............................................................................................................................................................................... Des mthodes concernant les mathmatiques ......................................................................................................................................................... Crer et utiliser sa propre mthode ! ......................................................................................................................................................................... La surcharge de mthode ......................................................................................................................................................................................... 75 77 78 81
Partie 2 : Java Orient Objet ............................................................................................................. 84

Les premiers pas en "Orient Objet" ............................................................................................................................... 84
Les classes ............................................................................................................................................................................................................... 84 Les constructeurs ...................................................................................................................................................................................................... 86 Votre objet sait parler : accesseurs et mutateurs ...................................................................................................................................................... 92 Travaillez avec votre objet : les mthodes ................................................................................................................................................................ 96 Les variables de classes ......................................................................................................................................................................................... 101 Astuce Eclipse ......................................................................................................................................................................................................... 105 Ce qu'il faut retenir .................................................................................................................................................................................................. 108
L'hritage ! ..................................................................................................................................................................... 109

La notion d'hritage ................................................................................................................................................................................................. Construction d'un objet hrit .................................................................................................................................................................................. Le polymorphisme ................................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. 109 113 116 121
Apprendre modliser .................................................................................................................................................. 122

UML, mais qu'est-ce donc ? .................................................................................................................................................................................... 123 Modliser un objet ................................................................................................................................................................................................... 124 Modliser les interactions entre objets .................................................................................................................................................................... 125
Les classes abstraites ................................................................................................................................................... 128

Qu'est-ce que c'est ? ............................................................................................................................................................................................... 129 Une classe Animal trs abstraite ............................................................................................................................................................................. 130 toffons notre exemple ........................................................................................................................................................................................... 132
www.siteduzero.com
Sommaire
2/669
Astuce d'Eclipse ...................................................................................................................................................................................................... 138 Ce qu'il faut retenir .................................................................................................................................................................................................. 141
Les interfaces ................................................................................................................................................................ 141

Une petite devinette ................................................................................................................................................................................................ Votre premire interface .......................................................................................................................................................................................... Implmentation de l'interface Rintintin .................................................................................................................................................................... Astuce d'Eclipse ...................................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. Premier exemple d'exception et le bloc try{....} catch{...} ........................................................................................................................................ Les exceptions personnalises ............................................................................................................................................................................... La gestion de plusieurs exceptions ......................................................................................................................................................................... Astuce d'Eclipse ...................................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. L'objet LinkedList ..................................................................................................................................................................................................... L'objet ArrayList ....................................................................................................................................................................................................... L'objet Hashtable ..................................................................................................................................................................................................... L'objet HashSet ....................................................................................................................................................................................................... Notion de base ........................................................................................................................................................................................................ Plus loin dans la gnricit ! ................................................................................................................................................................................... Gnricit et collection ............................................................................................................................................................................................ Hritage et gnricit .............................................................................................................................................................................................. Ce qu'il faut retenir .................................................................................................................................................................................................. Commenons par le commencement ..................................................................................................................................................................... Interroger un objet Class ......................................................................................................................................................................................... Instanciation dynamique ......................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. 142 142 144 147 151 152 154 162 165 167 169 170 171 172 174 177 180 181 185 186 186 190 194
Les exceptions .............................................................................................................................................................. 151
Les collections d'objets ................................................................................................................................................. 168
La gnricit en Java .................................................................................................................................................... 173
Java et la rflexivit ....................................................................................................................................................... 185
Partie 3 : Java et la programmation vnementielle ....................................................................... 195

Votre premire fentre .................................................................................................................................................. 195
L'objet JFrame ......................................................................................................................................................................................................... Votre fentre hrite ................................................................................................................................................................................................ Des mthodes et encore des mthodes ................................................................................................................................................................. Ce que vous cache votre fentre ............................................................................................................................................................................ Ce qu'il faut retenir .................................................................................................................................................................................................. Crez un conteneur pour votre fentre ................................................................................................................................................................... L'objet Graphics ...................................................................................................................................................................................................... Plus loin dans le Graphics ....................................................................................................................................................................................... Le cousin cach : l'objet Graphics2D ...................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. Les dplacements : principe ................................................................................................................................................................................... Continue, ne t'arrtes pas si vite ! ........................................................................................................................................................................... Attention aux bords, ne va pas te faire mal... .......................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. Utiliser la classe JButton ......................................................................................................................................................................................... Les layout managers ............................................................................................................................................................................................... Continuons dans notre lance ................................................................................................................................................................................ Une classe Bouton personnalise ........................................................................................................................................................................... Interaction avec la souris : l'interface MouseListener .............................................................................................................................................. Ce qu'il faut retenir .................................................................................................................................................................................................. 195 197 198 199 200 201 202 204 211 216 217 221 223 224 225 228 233 235 238 246
Une histoire de conteneur ............................................................................................................................................. 200
Faire une animation simple ........................................................................................................................................... 216
Votre premier bouton ..................................................................................................................................................... 224
Interaction bouton(s) - application ................................................................................................................................. 247

Dclencher une action : l'interface ActionListener ................................................................................................................................................... 247 Parlez avec votre classe intrieure ......................................................................................................................................................................... 256 Contrler votre animation : lancement et arrt ........................................................................................................................................................ 261 Cadeau : votre bouton personnalis optimis ! ....................................................................................................................................................... 266 Ce qu'il faut retenir .................................................................................................................................................................................................. 269
TP : une calculatrice ...................................................................................................................................................... 269

laboration .............................................................................................................................................................................................................. Conception .............................................................................................................................................................................................................. Correction ................................................................................................................................................................................................................ Astuce Eclipse : faire un jar excutable .................................................................................................................................................................. Principes et bases ................................................................................................................................................................................................... Une classe hrite de Thread ................................................................................................................................................................................. Utiliser l'interface Runnable ..................................................................................................................................................................................... Synchronisez vos threads ....................................................................................................................................................................................... Contrlez votre animation ....................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. 270 270 271 276 285 285 290 294 295 297
Les threads .................................................................................................................................................................... 284
Les listes : l'objet JComboBox ...................................................................................................................................... 298

Premire utilisation .................................................................................................................................................................................................. 299 L'interface ItemListener ........................................................................................................................................................................................... 302 Changer la forme de notre animation ...................................................................................................................................................................... 305 Ce qu'il faut retenir ................................................................................................................................................................................................... 311
Les cases cocher : l'objet JCheckBox ........................................................................................................................ 311

Premier exemple ..................................................................................................................................................................................................... 312
www.siteduzero.com
Partager
3/669
Un pseudo-morphing pour notre animation ............................................................................................................................................................. 314 Les boutons radio : l'objet JRadioButton ................................................................................................................................................................. 321 Ce qu'il faut retenir .................................................................................................................................................................................................. 324
Les champs de texte : l'objet JTextField ....................................................................................................................... 324

Utilisation ................................................................................................................................................................................................................. 325 Un objet plus restrictif : le JFormattedTextField ...................................................................................................................................................... 326 Contrlez vos donnes post-saisie ......................................................................................................................................................................... 331 Premire approche .................................................................................................................................................................................................. 333 Utiliser des expressions rgulires ......................................................................................................................................................................... 336 Utiliser des regex ..................................................................................................................................................................................................... 336 Les regex et l'objet String ........................................................................................................................................................................................ 337 Les regex et l'API regex .......................................................................................................................................................................................... 340 Contrle du clavier : l'interface KeyListener ............................................................................................................................................................ 343 Utiliser les classes anonymes ................................................................................................................................................................................. 347 Ce qu'il faut retenir .................................................................................................................................................................................................. 351
Les applets .................................................................................................................................................................... 352

Les applets : qusaco ? .......................................................................................................................................................................................... Votre premire applet .............................................................................................................................................................................................. Codage de l'applet .................................................................................................................................................................................................. Insertion dans une page HTML ............................................................................................................................................................................... Nota Bene ............................................................................................................................................................................................................... Interaction page web - applet .................................................................................................................................................................................. Interaction applet - page web .................................................................................................................................................................................. Applets et scurit ................................................................................................................................................................................................... Ce que vous devez retenir ...................................................................................................................................................................................... Les botes d'information .......................................................................................................................................................................................... Les types de botes ................................................................................................................................................................................................. Les botes de confirmation ...................................................................................................................................................................................... Les botes de saisie ................................................................................................................................................................................................ Des botes de dialogue personnalises .................................................................................................................................................................. Voici des screenshots obtenus ................................................................................................................................................................................ Ce qu'il faut retenir .................................................................................................................................................................................................. La barre de menus et les lments de menu .......................................................................................................................................................... Un menu simple ...................................................................................................................................................................................................... Les raccourcis clavier .............................................................................................................................................................................................. Faire un menu contextuel ........................................................................................................................................................................................ Les points importants pour notre menu contextuel ................................................................................................................................................. Les barres d'outils ................................................................................................................................................................................................... Utiliser les actions abstraites ................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. Cahier des charges ................................................................................................................................................................................................. Prrequis ................................................................................................................................................................................................................. Correction ................................................................................................................................................................................................................ Point.java ................................................................................................................................................................................................................ DrawPanel.java ....................................................................................................................................................................................................... Fenetre.java ............................................................................................................................................................................................................ Amliorations possibles .......................................................................................................................................................................................... Les flux : qu'est-ce donc ? ....................................................................................................................................................................................... L'objet File ............................................................................................................................................................................................................... Les objets FileInputStream et FileOutputStream .................................................................................................................................................... Les flux filtrs : les classes FilterInputStream et FilterOutputStream ...................................................................................................................... La srialisation : les objets ObjectInputStream et ObjectOutputStream ................................................................................................................. Cas pratique ............................................................................................................................................................................................................ Ce qu'il faut retenir .................................................................................................................................................................................................. 353 354 354 356 360 361 362 366 366 368 372 372 379 381 389 390 391 391 403 407 407 424 435 445 446 447 448 448 449 451 454 455 456 457 461 465 470 479
Les botes de dialogue .................................................................................................................................................. 367
Les menus ..................................................................................................................................................................... 390
TP : l'ardoise maZique .................................................................................................................................................. 446
Les flux d'entres / sorties (1/2) .................................................................................................................................... 454
Les flux d'entres / sorties (2/2) .................................................................................................................................... 480

Les objets CharArray(Writer/Reader) et String(Writer/Reader) ............................................................................................................................... 481 les classes File(Writer/Reader) et Print(Writer/Reader) .......................................................................................................................................... 483 Du renouveau chez les flux : le package java.nio ................................................................................................................................................... 484
TP : Le penduZ .............................................................................................................................................................. 486

Cahier des charges ................................................................................................................................................................................................. 487 Prrequis ................................................................................................................................................................................................................. 488 Correction ................................................................................................................................................................................................................ 489
Grez vos conteneurs ................................................................................................................................................... 490

Rendre vos conteneurs fractionnables .................................................................................................................................................................... Ajouter des scrolls ................................................................................................................................................................................................... Avoir plusieurs contenus ......................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. La composition des arbres ...................................................................................................................................................................................... Des arbres qui vous parlent .................................................................................................................................................................................... Dcorez vos arbres ................................................................................................................................................................................................. Jouons avec nos arbres .......................................................................................................................................................................................... Ce que vous devez retenir ...................................................................................................................................................................................... 491 495 499 504 505 509 516 522 537
Les arbres ..................................................................................................................................................................... 504
Les tableaux, les vrais ................................................................................................................................................... 537

Premiers pas ........................................................................................................................................................................................................... 538 Les cellules, c'est la vie ........................................................................................................................................................................................... 539 Contrlez l'affichage de vos cellules ....................................................................................................................................................................... 547
www.siteduzero.com
Partager
4/669
Des tableaux trs actifs ! ......................................................................................................................................................................................... 552 Ajouter des lignes et des colonnes ......................................................................................................................................................................... 559 Ce qu'il faut retenir .................................................................................................................................................................................................. 570
Ce que vous pouvez voir en plus .................................................................................................................................. 571

D'autres conteneurs graphiques ............................................................................................................................................................................. 571 D'autres objets graphiques ...................................................................................................................................................................................... 573 Enjoliver vos IHM .................................................................................................................................................................................................... 578
Partie 4 : Les Design patterns ......................................................................................................... 581

Les limites de l'hritage : le pattern strategy ................................................................................................................. 582
Posons le problme ................................................................................................................................................................................................ Voici le tableau ........................................................................................................................................................................................................ Le code source de ces classes ............................................................................................................................................................................... Un problme supplmentaire .................................................................................................................................................................................. Une solution simple et robuste : le pattern strategy ................................................................................................................................................ Ce qu'il faut retenir .................................................................................................................................................................................................. Posons le problme ................................................................................................................................................................................................ Le pattern decorator ................................................................................................................................................................................................ Les mystres de java.io .......................................................................................................................................................................................... Ce qu'il faut retenir .................................................................................................................................................................................................. Posons le problme ................................................................................................................................................................................................ Des objets qui parlent et qui coutent : le pattern observer .................................................................................................................................... le pattern observer : le retour .................................................................................................................................................................................. Ce qu'il faut retenir .................................................................................................................................................................................................. 582 582 584 589 594 605 607 611 619 622 623 625 631 632
Ajouter des fonctionnalits dynamiquement vos objets : le pattern decorator .......................................................... 606
Soyez l'coute de vos objets : le pattern observer .................................................................................................... 623
Un pattern puissant : le pattern MVC ............................................................................................................................ 632

Premiers pas ........................................................................................................................................................................................................... 633 Le modle ............................................................................................................................................................................................................... 634 Le contrleur ........................................................................................................................................................................................................... 638 La vue ...................................................................................................................................................................................................................... 640 MVC pour le web : le pattern M2VC ........................................................................................................................................................................ 645 Ce qu'il faut retenir .................................................................................................................................................................................................. 647
Un vritable assemblage : le pattern composite ........................................................................................................... 648

Creusez-vous les mninges .................................................................................................................................................................................... Comment feriez-vous pour grer ce genre de hirarchie d'objets ? ....................................................................................................................... La solution : le pattern composite ........................................................................................................................................................................... Le composite et Java .............................................................................................................................................................................................. Ce qu'il faut retenir .................................................................................................................................................................................................. 649 650 650 658 659
Partie 5 : Annexes ........................................................................................................................... 660

Annexe A : liste des mots cls ....................................................................................................................................... 661
Les mots cls .......................................................................................................................................................................................................... 661
Annexe B : Les objets travaillant avec des flux ............................................................................................................. 665

Les objets traitant des flux d'entre (in) .................................................................................................................................................................. Sous-classes de InputStream ................................................................................................................................................................................. Sous-classes de Reader ......................................................................................................................................................................................... Les objets traitant les flux de sortie (out) ................................................................................................................................................................ Sous-classes de OutputStream .............................................................................................................................................................................. Sous-classes de Writer ........................................................................................................................................................................................... Installation ............................................................................................................................................................................................................... Installation Windows ............................................................................................................................................................................................... Installation Linux ..................................................................................................................................................................................................... Raccourcis utiles ..................................................................................................................................................................................................... 665 665 665 665 665 666 667 667 667 668
Annexe C : Eclipse ........................................................................................................................................................ 666
www.siteduzero.com
5/669
Par
cysboy
Mise jour : 12/02/2010 Difficult : Intermdiaire 104 822 visites depuis 7 jours, class 4/778 Bonjour tous, amis Zros ! Bienvenue dans mon cours de programmation en Java. C'est un langage trs utilis, notamment par un grand nombre de programmeurs professionnels, ce qui en fait un langage incontournable actuellement. V oici les caractristiques de Java en quelques mots : Java est un langage de programmation moderne dvelopp par Sun Microsystems (aujourd'hui rachet par Oracle). Il ne faut surtout pas le confondre avec JavaScript (langage de scripts utilis principalement sur les sites web), car Java n'a rien voir. Une de ses plus grandes forces est son excellente portabilit : une fois votre programme cr, il fonctionnera automatiquement sous Windows, Mac, Linux, etc. On peut faire de nombreuses sortes de programmes avec Java : des applications, sous forme de fentre ou de console ; des applets, qui sont des programmes Java incorpors des pages web ; des applications pour appareils mobiles, avec J2ME ; et bien d'autres ! J2EE, JMF, J3D pour la 3D... Comme vous le voyez, Java permet de raliser une trs grande quantit d'applications diffrentes ! Mais... comment apprendre un langage si vaste qui offre autant de possibilits ? Heureusement, ce cours est l pour tout vous apprendre de Java partir de zro .
Exemples de programmes raliss en Java
Ce cours vous plat ? Si vous avez aim ce cours, vous pouvez retrouver le livre " Apprenez programmer en Java " du mme auteur, en vente sur le Site du Zro, en librairie et dans les boutiques en ligne. V ous y trouverez ce cours adapt au format papier avec une srie de chapitres indits. Plus d'informations
N.B. : je tiens faire une ddicace spciale ptipilou, zCorrecteur mrite, sans qui ce tuto n'aurait pas vu le jour !
www.siteduzero.com
Partie 1 : Bien commencer en Java

Un grand merci pour ton travail et ton soutien !
6/669
www.siteduzero.com
7/669

Bon, vous ne connaissez rien Java ? Eh bien c'est par ici que a se passe ! Java est normalement un langage fait pour dvelopper des applications graphiques, mais pour arriver cela, nous devons tout de mme passer par la programmation Java en mode console. Donc, dans cette premire partie, nous allons voir les bases du langage, ainsi que leur fidle compagnon Eclipse.
Parlons d'Eclipse
Pour ceux qui l'avaient devin, Eclipse est le petit logiciel qui va nous permettre de dvelopper nos applications, ou nos applets, et aussi celui qui va compiler tout a. Eh oui ! Java est un langage compil. Je ne l'avais pas dit, je crois... Donc, notre logiciel va permettre de traduire nos futurs programmes Java en langage compil. Mais celui-ci ne peut pas tre compris par l'ordinateur. Ce code compil s'appelle du Byte Code. Il n'est comprhensible que par un environnement Java, vulgairement appel JRE (Java Runtime Environment ) disponible sur le site de Sun MicroSystems.
Prambule
Avant toute chose, quelques mots sur le projet Eclipse. Eclipse IDE est un environnement de dveloppement libre permettant potentiellement de crer des projets de dveloppement mettant en uvre n'importe quel langage de programmation (C++, PHP...). Eclipse IDE est principalement crit en Java. La spcificit d'Eclipse IDE vient du fait que son architecture est totalement dveloppe autour de la notion de plug-in. Cela signifie que toutes les fonctionnalits de celui-ci sont dveloppes en tant que plug-in. Pour faire court, si vous voulez ajouter des fonctionnalits clipse, vous devez : tlcharger le plug-in correspondant, copier les fichiers spcifis dans les rpertoires spcifis, dmarrer Eclipse, et a y est !
Lorsque vous tlchargez un nouveau plug-in pour clipse, celui-ci se prsente souvent comme un dossier contenant gnralement deux sous-dossiers. Un dossier plugins et un dossier features . Ces dossiers existent aussi dans le rpertoire d'clipse. Il vous faut donc copier le contenu des dossiers de votre plug-in dans le dossier correspondant dans clipse (plugins dans plugins, et features dans features).
C'est pour toutes ces raisons que j'ai choisi Eclipse comme outil de dveloppement ; de plus, vous verrez qu'il est relativement simple d'utilisation. Maintenant que ces quelques mots ont t dits, je vous invite donc passer l'tape suivante.
Tlchargement
Avant de vous lancer dans le tlchargement d'clipse, vous devez Java, ou JRE sur votre machine.
avant tout vous assurer d'avoir un environnement
Un JRE (ou J ava Runtime Environment) va vous servir lire les programmes qui ont t cods en Java. Comme je vous l'ai dit plus tt, Eclipse est cod en Java : donc, pour utiliser Eclipse, il vous faut un JRE.
Rendez-vous donc sur la page de tlchargement des JRE sur le site de SUN Microsystem (fondateur du langage). Choisissez la dernire version du JRE. Aprs avoir cliqu sur " Download", vous arrivez sur une nouvelle page, o vous devez choisir votre systme d'exploitation et cocher le bouton " Accept License Agreement ". Slectionnez votre systme d'exploitation (ici, j'ai mis Windows) et n'oubliez pas de cocher la case : " I agree to the Java SE Development Kit 6 License Agreement" afin d'accepter la licence.
www.siteduzero.com
8/669
Euh... a veut dire quoi, JSE ?
Alors on va faire simple. Je vous ai dit plus tt que Java permet de dvelopper diffrents types d' applications. Eh bien il faut des outils diffrents pour les diffrents types d'applications. J2SE ou Java 2 Standard dition : permet de dvelopper des applications dites "client", par exemple... euh... clipse est une application "client". C'est ce que nous allons faire dans ce tutoriel. J2EE ou Java 2 Enterprise dition : permet de dvelopper des applications web en Java. J2ME ou Java 2 Micro dition : permet de dvelopper des applications pour appareil portable, comme des tlphones portables, des PDA... V oil, fin de l'apart... V ous pouvez maintenant tlcharger et installer votre JRE. Ceci fait, je vous invite donc tlcharger clipse IDE sur cette page en choisissant "clipse IDE for java developers", en choisissant la version d'Eclipse correspondant votre OS. Slectionnez maintenant le miroir que vous souhaitez utiliser pour obtenir clipse. V oil, vous n'avez plus qu' attendre la fin du tlchargement.
Installation
Maintenant que vous avez un JRE et que vous avez tlcharg clipse, nous allons voir comment nous servir de celui-ci. V ous devez maintenant avoir une archive contenant clipse. Dcompressez-la o vous voulez, puis, entrez dans ce dossier. Si comme moi vous tes sous Windows, vous devriez avoir ceci :
www.siteduzero.com
9/669
Ne travaillant pas sous Mac OS ni sous Linux, je ne peux malheureusement pas vous proposer de screenshot pour ces OS, mais je pense que a doit fortement y ressembler... La suite sera donc pour Windows, mais cela ne doit pas tre trs diffrent sur les autres OS.
Ensuite, si vous le souhaitez, vous pouvez crer un raccourci de l'excutable " eclipse.exe" pour pouvoir y accder plus facilement. Ceci fait, lancez Eclipse. Peu de temps aprs, vous devriez avoir une fentre comme celle-ci :
Ici, Eclipse vous demande dans quel dossier vous souhaitez enregistrer vos projets. Libre vous de choisir celui-ci. J'ai coch la checkbox pour qu'clipse se souvienne de ma dcision. Mais lorsque vous crerez des projets, rien ne vous empche de spcifier un autre dossier que celui de votre "workspace". Une fois cette tape effectue, vous arrivez sur la page d'accueil d'clipse. Je n'ai jamais trop regard ce que celle-ci propose ; donc, si vous avez envie de jeter un coup d'oeil, allez-y.
Prsentation rapide de l'interface

Je vais maintenant vous faire faire un tour rapide de l'interface que vous propose Eclipse, en gros, des lments dont nous allons nous servir dans ce tutoriel. Je ne connais malheureusement pas toutes les fonctionnalits d'Eclipse... Par consquent, je peux trs bien omettre certains points qui peuvent tre importants pour d'autres dveloppeurs. Merci de me tenir au courant le cas chant. Avant de commencer, regardez bien les raccourcis clavier prsents dans les menus... Ils sont trs utiles et peuvent vous faire gagner beaucoup de temps ! On est obligs ?
Bien sr que non, mais croyez-moi, quand on y a got, on ne peut plus s'en passer... Allez, trve de bavardages, on est partis.
Menu "File"
www.siteduzero.com
10/669
C'est ici que nous pourrons crer de nouveaux projets Java, enregistrer ceux-ci, les exporter le cas chant... Ici, les raccourcis retenir sont : ALT + SHIFT + N : Nouveau projet CTRL + S : enregistrer la classe * Java o on est positionns CTRL + SHIFT + S : tout sauvegarder CTRL + W : fermer la classe Java o on est positionns CTRL + SHIFT + W : fermer toutes les classes Java ouvertes.
* classe : on y reviendra.
Menu "Edit"
www.siteduzero.com
11/669
Dans ce menu, nous pourrons utiliser les commandes "copier", "coller"... Ici, les raccourcis retenir sont : CTRL + C : copier la slection CTRL + X : couper la slection CTRL + V : coller la slection CTRL + A : tout slectionner CTRL + F : chercher / remplacer.
Menu "Window"
Dans celui-ci, nous pourrons configurer Eclipse selon nos besoins.
La barre de navigation
www.siteduzero.com
12/669
Nous avons dans l'ordre : 1 : "nouveau" gnral. Cliquer sur ce bouton revient faire "Fichier - Nouveau" 2 : enregistrer. Revient faire CTRL + S. 3 : imprimer. 4 : excuter la classe ou le projet spcifi. Nous verrons ceci plus en dtail. 5 : crer un nouveau projet Java. Revient faire "Fichier - Nouveau - Java project". 6 : crer une nouvelle classe dans un projet. Revient faire "Fichier - Nouveau - Classe".
Je vous demande maintenant de crer un nouveau projet Java. V ous devriez arriver cette fentre sans trop de difficults :
www.siteduzero.com
13/669
Renseignez le nom de votre projet comme je l'ai fait plus haut (encadr 1). V ous pouvez aussi voir o sera enregistr ce projet (encadr 2). Un peu plus compliqu maintenant, vous avez donc un environnement Java sur votre machine, mais dans le cas o vous en auriez plusieurs, vous pouvez aussi spcifier Eclipse quel JRE utiliser pour ce projet. En fait, vous pourrez changer ceci tout moment dans Eclipse en allant dans Window / Prfrences, en dpliant l'arbre "Java" dans la fentre et en choisissant " Installed JRE". Par contre, n'utilisez a que si vous tes srs de vous !
V ous devriez avoir un nouveau projet dans la fentre de gauche, comme ceci :
www.siteduzero.com
14/669
Pour boucler la boucle, ajoutons ds maintenant une nouvelle classe dans ce projet. Je suis sr que vous allez y arriver sans moi... V ous tes donc devant cette fentre :
www.siteduzero.com

Dans l'encadr 1, nous pouvons voir o seront enregistrs nos fichiers Java. Dans l'encadr 2, nommez votre classe Java, moi j'ai sdz1 . Dans l'encadr 3, Eclipse vous demande si cette classe a un truc particulier. Eh bien oui ! Cochez " public static void main(String[] args) ", puis cliquez sur " finish " (nous allons revenir sur ce dernier point dans la partie suivante). Une fois ces oprations termines, vous tes devant ceci :
15/669
Alors avant de commencer coder, nous allons un peu explorer notre espace de travail. Dans l'encadr vert ( gauche), vous trouverez le dossier de votre projet ainsi que son contenu. Ici, vous pourrez grer votre projet comme bon vous semble (ajout, suppression...). Dans l'encadr bleu (au centre), je pense que vous avez devin... C'est ici que nous allons crire nos codes sources. Dans l'encadr rose (en bas), c'est l que vous verrez apparatre le contenu de vos programmes ainsi que les erreurs ventuelles ! Et enfin pour finir, dans l'encadr violet ( droite), ds lors que nous aurons appris coder nos propres fonctions ainsi que des objets, c'est ici que la liste des mthodes et des variables sera affich. Maintenant que vous avez Eclipse bien en main, nous allons faire un tour rapide des autres IDE de dveloppement pour Java.
D'autres outils la hauteur

Surtout gardez en mmoire qu'un IDE est un outil de dveloppement. Comment a, je ne vous l'avais pas dit... Ce qu'il faut garder en tte, c'est qu'un IDE, comme n'importe quel outil, est :
www.siteduzero.com

fonctionnel, adapt, volutif.
16/669
Ce que j'entends par l, c'est que comme un menuisier, vous utiliserez des outils pour travailler et comme lui, vous choisirez celui qui vous convient le mieux. Partez du principe que les IDE ont grosso-modo les mmes fonctionnalits, compiler en byte code, excuter, debugger... Les IDE de la liste suivante sont tout aussi adapts qu'Eclipse pour dvelopper en Java. A vous de vous faire un avis. Testez, comparez et choisissez.
1. JBuilder
Celui-ci est idal pour le dveloppement grande chelle, pour les projets d'entreprise, etc. Il intgre tout un tas de technologies comme XML, jsp/servlet, concept d'ingnierie, outils UML... C'est simple : je crois mme qu'il fait du caf... Tout ceci fait de lui un outil puissant, mais trs lourd pour les configurations moyennes. En gros, vous serez peut-tre amens l'utiliser, mais en entreprise... Bon : pour les curieux de nature, vous pouvez faire un tour ici. Ne cherchez pas de version gratuite, JBuilder est payant. Mais je crois que vous pouvez avoir une version d'valuation... A vrifier...
2. NetBeans
NetBeans est l'IDE cr par Sun Microsystems, il contient donc toutes les fonctionnalits d'un bon IDE : un debugger, un outil de modlisation UML, tout le ncessaire pour faire des applications J2EE, il est GRATUIT ! ...
De plus, il semblerait qu'on puisse customiser l'environnement de celui-ci.
www.siteduzero.com
17/669
Si vous voulez vous faire une opinion, ce que je vous conseille vivement, vous pouvez le tlcharger ici.
Il existe bien d'autres IDE pour dvelopper en Java, mais ceux-ci (Eclipse compris) reprsentent la majorit des IDE utiliss. En voici d'autres, pour information : JCreator IntelliJ Sun ONE Studio JDeveloper JEdit Le Bloc-notes de Windows (vi sous Linux), ou encore Notepad++.
Qu... Quoi ? On peut faire des programmes Java avec le Bloc-notes de Windows ?
Tout fait... En fait, lorsque vous crerez un programme Java dans votre IDE prfr et que vous l'excuterez, celui-ci va pr-compiler votre code Java en byte code pour qu'ensuite votre JVM (J ava V irtual M achine, cf chapitre suivant ) l'interprte et l'excute. Mais toutes ces tapes peuvent tre faites la main, en ligne de commande, mais nous n'en parlerons pas maintenant. Bon, je crois qu'il est temps pour un petit QCM... V oil ! Une partie pnible de termine ! Par contre, Eclipse regorge de fonctionnalits. Je n'en ai pas parl pour le moment car je pense que vous comprendrez mieux le moment venu, avec un exemple concret d'utilisation. J'espre que vous avez encore de l'nergie, car, dans le chapitre suivant, nous aborderons quelque chose de bien plus passionnant... Bon ! Tenez-vous prts pour faire vos premiers codes Java ! !
www.siteduzero.com
18/669
Votre premier programme

Dans ce chapitre, nous allons faire nos premiers programmes en Java. Mais tout d'abord, quelques explications sur le fonctionnement du JRE s'imposent. Alors... go !
Mieux connaitre son environnement Java

Bon : cette partie s'annonce riche en informations et pour certains, elle sera mme "pompeuse"... Mais afin de bien coder en Java, il vaut mieux comprendre comment tout cela fonctionne. Dans le JRE, que je vous ai fait tlcharger dans la partie prcdente, se trouve le coeur mme de Java. Celui-ci s'appelle la JVM (pour Java Virtual Machine) que j'appellerai dornavant machine virtuelle. Celle-ci a pour rle, comme je vous l'ai dit dans le chapitre prcdent, d'excuter les programmes Java sur votre machine, c'est ce qui fait que les programmes Java sont dit "portables". Qu'est-ce tu entends par l ?
J'allais y venir... Comme je vous l'ai maintes fois rpt, les programmes Java sont, avant d'tre utiliss par la machine virtuelle, pr-compils en byte code (par votre IDE ou encore la main). Ce byte code n'est comprhensible que par une JVM, et c'est celle-ci qui va faire le lien entre ce code et votre machine. V ous aviez srement remarqu que sur la page de tlchargement du JRE, plusieurs liens taient disponibles : un lien pour Windows, un lien pour Mac, un lien pour Linux. Ceci car la machine virtuelle Java se prsente diffremment selon qu'on se trouve sous Mac, sous Linux ou encore sous Windows. Par contre le byte code, lui, reste le mme quelque soit l'environnement o a t dvelopp et pr-compil votre programme Java. Consquence directe :
quel que soit l'OS sous lequel a t cod un programme Java, n'importe quelle machine pourra l'excuter si elle dispose d'une JVM !
Tu n'arrtes pas de nous rabcher byte code par-ci... byte code par-l... Mais c'est quoi, au juste ? Eh bien un byte code - et je dis bien UN byte code - n'est autre qu'un code intermdiaire entre votre code Java et le code machine. Ce code particulier se trouve dans les fichiers pr-compils de vos programmes ; en Java, un fichier source a l'extension .java et un fichier pr-compil a l'extension .class ; c'est dans ce dernier que vous pourrez voir du byte code. Par contre, vos fichiers .java sont de btes fichiers texte, seule l'extension est change... V ous pouvez donc les ouvrir, les crer ou encore les mettre jour avec... le Bloc-notes de Windows par exemple... Pour en revenir notre byte code, je vous invite regarder un fichier .class la fin de cette partie (vous en aurez au moins un), mais je vous prviens, c'est illisible ! ! Inutile de vous dire que votre machine est incapable d'interprter du byte code !
Alors pourquoi je vous ai dit UN byte code ? Tout simplement parce que la machine virtuelle de Java se moque que le byte code soit la base du Java ou autre chose. Son rle est d'interprter ce code et de le faire fonctionner. Donc, si un jour vous arrivez faire du byte code avec comme fichier source un .cpp (pour C++), a devrait (et j'insiste sur le devrait) fonctionner.
www.siteduzero.com

V ous pouvez avoir un aperu de ce qui devrait fonctionner sur cette page. Ce qu'il faut retenir : la JVM est le coeur de Java, celle-ci fait fonctionner vos programmes Java, pr-compils en byte code, les fichiers contenant le code source de vos programmes Java ont l'extension .java, les fichiers pr-compils correspondant vos codes sources Java ont l'extension .class , le byte code est un code intermdiaire entre votre programme et votre machine, un programme Java, cod sous Windows peut tre pr-compil sous Mac et enfin excut sous Linux, votre machine NE PEUT PAS interprter du byte code.
19/669
Je pense qu' aprs cette partie purement thorique, vous avez hte de commencer taper des lignes de code... Mais avant, il me reste quelques choses vous dire !
Avant de commencer
Avant de commencer, vous devez savoir que tous
les programmes Java sont composs d'au moins une
classe.
Cette classe doit contenir (applet mise part) une mthode main. Celle-ci est la mthode principale du programme, c'est elle que la JVM va chercher afin de lancer votre programme. Pour faire court, c'est le point de dpart du programme. V ous voyez donc son importance ! Et pour qu'on se comprenne bien, une mthode est une suite d'instructions excuter. Une mthode contient : une entte : celle-ci va tre un peu comme la carte d'identit de la mthode. Nous y reviendrons. un corps : le contenu de la mthode. Ce qui va tre fait ! Dlimit par des accolades {}. une valeur de retour : le rsultat que la mthode va retourner. SAUF pour les mthodes de type void qui ne renvoient rien. Nous y reviendrons aussi. V ous verrez, un peu plus tard, qu'un programme n'est qu'une multitude de classes qui s'utilisent l'une l'autre. Mais pour le moment, nous n'allons travailler qu'avec une seule classe. Dans la partie prcdente, je vous avais demand de crer un projet Java ; ouvrez-le si ce n'est pas dj fait. Donc pour rappel, voici ce que vous aviez sous votre nez :
V ous voyez la fameuse classe dont je vous parlais ? Ici, elle s'appelle sdz1 . V ous pouvez voir que le mot class est prcd du mot public, nous verrons la signification de celui-ci lorsque nous programmerons des objets. Pour le moment, ce que vous devez retenir c'est que votre classe est dfinie par un mot cl, class, qu'elle a un nom ; ici, sdz1 et que le contenu de celle-ci est dlimit par des accolades, {}.
www.siteduzero.com
20/669
Comme je vous l'ai dit plus haut, notre unique classe contient la mthode main. La syntaxe de cette mthode est toujours la mme : Code : Java public static void main(String[] args){ // Contenu de votre classe }
Ce sera entre les accolades de la mthode main que nous crirons nos codes sources. Excuse-nous, mais... Pourquoi as-tu crit "//Contenu de votre classe" et non "Contenu de votre classe" ?
Bonne question ! Je vous ai dit plus haut que votre programme Java, avant de pouvoir tre excut, doit tre pr-compil en byte code. Eh bien la possibilit de forcer le compilateur ignorer certaines instructions existe ! On appelle a des commentaires et il existe deux syntaxes : les commentaires unilignes : introduits par les symboles // , ils mettent tous ce qui les suit en commentaires, du moment que le texte se trouve sur la mme ligne que les // . Code : Java public static void main(String[] args){ //Un commentaire //un autre //Encore un autre Ceci n'est pas un commentaire ! ! ! ! }
les commentaires multilignes : ils sont introduits par les symboles /* et se terminent par les symboles */ .
Code : Java public static void main(String[] args){ /* Un commentaire Un autre Encore un autre */ Ceci n'est pas un commentaire ! ! }
D'accord ! Mais a sert quoi ?
C'est simple : au dbut, vous ne ferez que de trs petits programmes. Mais ds que vous aurez pris de la bouteille, la taille de ceux-ci, ainsi que le nombre de classes qui les composera, augmentera. V ous serez contents de trouver quelques lignes de commentaires au dbut de votre classe pour vous dire quoi elle sert, ou encore des commentaires dans une mthode qui fait des choses compliques afin de savoir ou vous en tes dans vos traitements...
www.siteduzero.com
21/669
Il existe en fait une troisime syntaxe, mais celle-ci a un but particulier. Elle permettra de gnrer une documentation de votre programme ! Une Javadoc (Java Documentation). Je n'en parlerai que trs peu, et pas dans ce chapitre. Nous verrons cela lorsque nous programmerons des objets mais, pour les curieux, je vous conseille le trs bon tutoriel de dworkin. Je profite de cet apart sur les commentaires pour vous donner une astuce bien pratique ! Il vous arrivera forcment un moment donn de vouloir mettre une partie de code en commentaire. Dans ce cas, il y a 99,99999999 % de chance que vous choisissiez les commentaires multilignes. L'inconvnient, c'est que lorsque vous voudrez remettre votre morceau de code en activit, il vous faudra retirer les /* */. Mais si 5 minutes plus tard, vous voulez remettre la mme portion de code en commentaire . Regardez ce morceau de code (il ne fait rien du tout, c'est un exemple) : Code : Java public static void main(String[] args){ String str = "toto"; int entier = 0; if(entier != 0){ /* for(int i = 0; i < 20; i++){ System.out.println("oui ! ! ! ! !"); } //*/ } }
V ous pouvez voir que j'ai utilis les commentaires multilignes ! Mais avec une variante... La ligne qui ferme les commentaires est prcde... de // . Mais c'est ce qui met une ligne en commentaires... C'est idiot de mettre a l... Ils sont en commentaire !
Je le sais bien, et c'est l qu'est l'astuce. Pour le moment, les deux // sont en commentaires comme les lignes qui se trouvent entre /* et */ . Mais que se passe-t-il si j'ajoute un / devant ma premire instruction de commentaire ? Code : Java public static void main(String[] args){ String str = "toto"; int entier = 0; if(entier != 0){ //* for(int i = 0; i < 20; i++){ System.out.println("oui ! ! ! ! !"); } //*/ } }
Eh bien l, ce sont mes commentaires multilignes qui sont devenus des commentaires, et mes lignes sont de nouveau actives dans mon code !
www.siteduzero.com

Explique-nous a !
22/669
C'est trs simple. Le fait d'ajouter un / devant /* met l'toile en commentaire... Dans ce cas, il ne s'agit plus d'un commentaire multilignes, mais uniligne ! Et l je crois que vous avez devin l'utilit de cette ligne //*/... Sur celle-ci, c'est l'instruction de commentaire multiligne fermante qui est en commentaire ! Donc, plus besoin d'ajouter de commentaire, d'en effacer, de les remettre, de les r-effacer... V ous encadrez la portion de code que vous souhaitez enlever de /* .... //*/ et lorsque vous la voulez nouveau, vous ajoutez un / devant l'instruction ouvrante des commentaires ! Et si vous voulez remettre la mme portion de code en commentaire, enlevez le / ajout devant /* ! A partir de maintenant et jusqu' ce que nous programmions des interfaces graphiques, nous allons faire ce qu'on appelle des programmes procduraux . Cela signifie que le programme se droulera de faon procdurale. Euh... ksako ?
En fait, un programme procdural est un programme qui s'effectue de haut en bas , une ligne aprs l'autre. Bien sr, il y a des instructions qui permettent de rpter des morceaux de code, mais le programme en lui mme se terminera une fois arriv la fin du code. Ceci vient en opposition la programmation vnementielle (ou graphique) qui elle, est base sur des vnements (clic de souris, choix dans un menu...). Je pense que j'ai fait le tour de ce que je voulais vous dire... Bon : pour votre premier programme, je pense que le traditionnel "Hello World ! ! " est de mise... Donc, allons-y !
Votre premier programme

Nous entrons enfin dans le vif du sujet ! Mais ne vous attendez pas faire un vrai programme tout de suite... Maintenant, vous pouvez taper les lignes suivantes entre les accolades de votre mthode main : Code : Java System.out.print("Hello World !");
N'oubliez surtout pas le la fin de la ligne ! Toutes les instructions en Java sont suivies d'un point virgule.
Une fois que vous avez saisi cette ligne de code dans votre mthode main, vous devez lancer le programme. Si vous vous souvenez bien de la prsentation du chapitre prcdent, vous avez d cliquer sur la flche blanche dans un rond vert :
www.siteduzero.com
23/669
Si vous regardez dans votre console, fentre en bas sous Eclipse, vous devez avoir :
Expliquons un peu cette ligne de code. Littralement, elle signifie "la mthode print() va crire Hello World ! en utilisant l'objet out de la classe System ". System : ceci correspond l'appel d'une classe qui s'appelle " System". C'est une classe utilitaire qui permet surtout d'utiliser l'entre et la sortie standard. out : objet de la classe System qui gre la sortie standard. print : mthode qui crit dans la console la chane passe en paramtre. Si vous mettez plusieurs System.out.print, voici ce qui ce passe. Prenons ce code : Code : Java System.out.print("Hello World ! !"); System.out.print("My name is"); System.out.print("Cysboy");
Lorsque vous l'excutez, vous devriez avoir une chane de caractres qui se suivent, sans saut la ligne. En gros, vous devez avoir ceci dans votre console : Hello World ! !My name isCysboy Je me doute que vous souhaiteriez faire un retour la ligne pour que votre texte soit plus lisible... avez plusieurs solutions. Soit vous utilisez un caractre d'chappement, ici, \n. Soit vous utilisez la mthode println() la place de la mthode print(). Pour russir cela, vous
Donc, si nous reprenons notre prcdent code et que nous appliquons ceci, voil ce que a donnerait : (notre code modifi) :
www.siteduzero.com

Code : Java System.out.print("Hello World ! ! \n"); System.out.println("My name is"); System.out.println("\nCysboy");
24/669
Le rsultat : Hello World ! ! My name is Cysboy V ous pouvez voir que : lorsque vous utilisez le caractre d'chappement \n, quelle que soit la mthode appele, celle-ci intgre immdiatement un retour la ligne l'emplacement de ce dernier. lorsque vous utilisez la mthode println(), celle-ci ajoute automatiquement un retour la ligne la fin de la chane passe en paramtre. rien ne vous empche de mettre un caractre d'chappement dans la mthode println().
J'en profite au passage pour vous donner deux autres caractres d'chappement : \r : va mettre un retour chariot. \t : va faire une tabulation.
V ous avez srement remarqu que la chane de caractres que l'on affiche est entoure de <chaine> . En Java, les double quotes sont des dlimiteurs de chanes de caractres ! Si vous voulez afficher un double quote avec la sortie standard, vous devrez " l'chapper" avec un , ce qui donnerait System.out.println("coucou mon \"choux\" ! ");
"
"
Maintenant que vous savez faire un "Hello World", je vous propose de voir la compilation de vos programmes en ligne de commande. Cette sous-partie n'est ici que pour les plus curieux d'entre vous. V ous pouvez passer outre cette sous-partie si vous le voulez, et aller directement au QCM mais, partez du principe que a pourrait vous servir un jour...
Compilation en ligne de commande (Windows)

Donc bienvenue aux plus curieux ! Avant de vous apprendre compiler et excuter un programme en ligne de commandes, il va vous falloir le JDK de SUN (J ava SE Development Kit). C'est dans celui-ci que nous aurons de quoi compiler nos programmes. Le ncessaire l'excution des programmes est aussi dans le JRE... Mais vous l'aurez en plus dans le JDK. Je vous invite donc retourner sur le site de SUN et tlcharger celui-ci. Une fois cette opration effectue, il est conseill de mettre jour votre variable d'environnement %PATH%. Euh... Quoi ?
V otre variable d'environnement. C'est grce celle-ci que Windows arrive trouver des excutables sans lui spcifier le chemin d'accs complet. V ous, enfin Windows, en a plusieurs, mais nous nous intresserons qu' une seule. En gros, cette variable contient le chemin d'accs certains programmes. Par exemple, si vous spcifiez le chemin d'accs d'un programme X dans votre variable d'environnement et que, comme par un malheureux hasard, vous n'avez plus aucun raccourci vers X, c'est simple : vous l'avez dfinitivement perdu dans les mandres
www.siteduzero.com
25/669
de votre PC. Eh bien vous pourrez le lancer en faisant " dmarrer > Excuter" et en tapant la commande " X.exe" (en partant du principe que le nom de l'excutable est X.exe). D'accord, mais comment on fait ? Et pourquoi on doit faire a pour le JDK ?
J'y arrive... Une fois votre JDK install, ouvrez le rpertoire bin de celui-ci, mais galement celui-ci de votre JRE. Nous allons nous attarder sur deux fichiers. Dans le rpertoire bin de votre JRE, vous devez avoir un fichier appel java.exe. Fichier que vous retrouvez aussi dans le rpertoire bin de votre JDK. C'est grce ce fichier que votre ordinateur peut lancer vos programmes par le biais de la JVM. Lorsque vous lancez une application sous Eclipse, ce fichier est lanc de faon implicite !
Le deuxime ne se trouve que dans le rpertoire bin de votre JDK, il s'agit de javac.exe (java compiler). C'est celui-ci qui va prcompiler vos programmes Java en byte code. Alors pourquoi le faire pour le JDK ? Eh bien, compiler-excuter en ligne de commande revient utiliser ces deux fichiers en leur prcisant o se trouvent les fichiers traiter. Cela veut dire que si on ne met pas jour la variable d'environnement de Windows, nous devons : ouvrir l'invite de commande, se positionner dans le rpertoire bin de notre JDK, appeler la commande souhaite, prciser le chemin du fichier .java, renseigner le nom du fichier. Avec notre variable d'environnement mise jour, nous n'aurons plus qu' : nous positionner dans le dossier de notre programme, appeler la commande, renseigner le nom du fichier Java.
Comme un exemple vaut mieux que de grands discours, mettons notre variable d'environnement jour... Allez dans le " panneau de configuration" de votre PC, de l, cliquez sur l'icne " Systme" ; choisissez l'onglet " avanc" et vous devriez avoir un bouton, en bas, intitul " Variables d'environnement" ; cliquez dessus. Une nouvelle fentre s'ouvre. Dans la partie infrieure intitule " Variables systme" chercher la variable Path. Une fois slectionne, cliquez sur Modifier. Encore une fois, une fentre, plus petite celle-l, s'ouvre devant vous. Elle contient le nom de la variable et sa valeur. Ne changez pas son nom et n'effacez pas le contenu de valeur ! Nous allons juste ajouter
un chemin d'accs.
Pour ce faire, allez jusqu'au bout de la valeur de la variable, ajoutez-y un point-virgule (;) s'il n'y en a pas, et ajoutez maintenant le chemin d'accs au rpertoire bin de votre JDK, en terminant celui-ci par un point-virgule !. Chez moi, a donne ceci : " C:\Sun\SDK\jdk\bin". Alors, ma variable d'environnement contenait avant ajout : % SystemRoot% \system32;% SystemRoot% ;% SystemRoot% \System32\Wbem; Et maintenant : % SystemRoot% \system32;% SystemRoot% ;% SystemRoot% \System32\Wbem;C:\Sun\SDK\jdk\bin; Validez les changements, et c'est tout !
www.siteduzero.com

V ous tes maintenant prts compiler en ligne de commande. Pour bien faire, allez dans le rpertoire de votre premier programme et effacez le .class . Ensuite, faites " dmarrer > Excuter" (ou encore touche Windows + r), et tapez " cmd". Pour rappel, dans l'invite de commande, on se dplace de dossier en dossier grce l'instruction cd. cd <nom du dossier enfant> : pour aller dans un dossier contenu dans celui dans lequel nous sommes. cd .. : pour remonter d'un dossier dans la hirarchie.
26/669
Par exemple : lorsque j'ouvre la console, je me trouve dans le dossier C:\toto\titi et mon application se trouve dans le dossier C:\sdz, je fais donc : Code : Bash cd .. cd .. cd sdz
Lors de la premire instruction, je me retrouve dans le dossier C:\toto. Lors de la deuxime instruction, je me retrouve la racine de mon disque. Lors de la troisime instruction, je me retrouve dans le dossier C:\sdz. Nous sommes maintenant dans le dossier contenant notre fichier Java ! Mais nous pouvons condenser ceci en : Code : Bash cd ../../sdz
Maintenant, vous pouvez crer votre fichier .class en utilisant la commande javac <nomDeFichier.java>. Si, dans mon dossier, j'ai un fichier test.java, je le compile en faisant : javac test.java Et si vous n'avez aucun message d'erreur, vous pouvez vrifier que le fichier test.class est prsent en utilisant l'instruction dir qui liste le contenu d'un rpertoire. Cette tape russie, vous pouvez lancer votre programme Java en faisant java <nomFichierClassSansExtension> Ce qui nous donne : java test Et normalement, vous avez le rsultat de votre programme Java qui s'affiche sous vos yeux bahis ! Attention : il ne faut pas mettre l'extension du fichier pour le lancer, mais la mettre pour le compiler.
Donc voil : vous avez compil et excut un programme Java en ligne de commande... V ous en aurez peut tre besoin un jour... En tout cas, j'espre que vous tes d'attaque pour un petit QCM... J'espre que maintenant vous arrivez mieux cerner comment fonctionne Java, et crire ce que vous voulez l'cran. prsent, nous allons voir comment stocker des donnes en mmoire afin de les afficher, de les calculer... En avant pour les variables et les oprateurs .
www.siteduzero.com
27/669
Les variables et les oprateurs

Nous y voil. Encore un chapitre barbant... Mais celui-l aussi est ncessaire, et je dirais mme vital ! En Java, comme dans beaucoup de langages de programmation, avant d'utiliser une variable, nous devons d'abord dfinir ce qu'elle va contenir. T'es bien gentil, mais c'est quoi, une variable ?
Oups ! Dsol ! Je parle, je parle et j'oublie l'essentiel... Une variable, c'est ce qui va nous permettre de stocker des informations de toute sorte (chiffres, rsultats de calcul, des tableaux, des renseignements fournis par l'utilisateur...). Bref, vous ne pourrez pas faire de programme sans variables. Et comme je viens de vous le dire, et j'insiste l dessus, il faut tout prix dfinir ce que nos variables vont contenir avant de les utiliser. Une dclaration de variable se fait comme suit : <Type de la variable> <Nom de la variable> ; Cette opration se termine toujours par un ";" (comme toutes les instructions de ce langage) ; ensuite, on l'initialise en rentrant une valeur.
Bon. Assez de bla-bla, on y va. (Dcidment, moi, les rimes en ce moment...
Les diffrents types de variables

Tout d'abord, je vous conseille vivement de lire le chapitre qu'a crit M@teo21 sur les variables dans son tutoriel sur le C. Je pense que vous y verrez plus clair. Bon. En Java, nous avons deux type de variables : des variables de type simple ou "primitif", des variables de type complexe ou encore des objets. Ce qu'on appelle des types simples, ou types primitifs, en Java ce sont tout bonnement des nombres entiers, des nombres rels, des boolens ou encore des caractres. Mais vous allez voir qu'il y a plusieurs faons de dclarer certains de ces types.
Commenons par les variables de type numrique

- Le type byte (1 octet) peut contenir les entiers entre -128 et +127. Ex. : Code : Java byte temperature; temperature = 64;
- Le type short (2 octets) contient les entiers compris entre -32768 et +32767. Ex. : Code : Java short vitesseMax; vitesseMax = 32000;
- Le type int (4 octets) va de -2*109 2*109 (2 et 9 zros derrire... ce qui fait dj un joli nombre). Ex. : Code : Java int temperatureSoleil;
www.siteduzero.com

temperatureSoleil = 15600000;
28/669
C'est en kelvins... - Le type long(8 octets) de -9*1018 9*1018 (encore plus gros...). Ex. : Code : Java long anneeLumiere; anneeLumiere = 9460700000000000;
- Le type float (4 octets) correspond des nombres avec virgule flottante. Ex. : Code : Java float pi; pi = 3.141592653f;
ou encore Code : Java float nombre; nombre = 2.0f;
V ous remarquerez que nous ne mettons pas de virgule mais un point ! Et vous remarquerez aussi que mme si le nombre en question est rond, on met tout de mme .0 derrire celui-ci ! - Le type double (8 octets) est identique float, si ce n'est qu'il contient un nombre plus grand derrire la virgule. Ex. : Code : Java double division; division = 0.333333333333333333333333333333333333333333334;
Nous avons aussi des variables stockant du caractre

- Le type char contient UN caractre stock entre de simples quotes ' ' comme ceci... Ex. : Code : Java char caractere; caractere = 'A';
Nous avons aussi le type boolen

- Le type boolean qui lui contient true (vrai) ou false (faux). Ex. : Code : Java boolean question; question = true;
www.siteduzero.com
29/669
Et aussi le type String

- Celle-ci correspond de la chane de caractres. Ici, il ne s'agit pas d'une variable mais d'un objet qui instancie une classe qui existe dans Java ; nous pouvons l'initialiser en utilisant l'oprateur unaire new() dont on se sert pour rserver un emplacement mmoire un objet (mais nous reparlerons de tout ceci dans la partie deux, lorsque nous verrons les classes), ou alors lui affecter directement la chane de caractres. V ous verrez que celle-ci s'utilise trs facilement et se dclare comme ceci : Ex. : Code : Java String phrase; phrase = "Titi et gros minet"; //Deuxime mthode de dclaration de type String String str = new String(); str = "Une autre chane de caractres"; //La troisime String string = "Une autre chane"; //Et une quatrime pour la route String chaine = new String("Et une de plus ! ");
Attention : String commence par une majuscule ! Et lors de l'initialisation, on utilise ici des doubles quotes " " .
En fait, String n'est pas un type de variable mais un objet. Notre variable est "un objet", on dit aussi "une instance", ici, une instance de la classe String . Nous y reviendrons lorsque nous aborderons les objets. On te croit sur parole, mais pourquoi String commence par une majuscule et pas les autres ?
C'est simple. Il s'agit d'une convention de nommage. En fait, c'est une faon d'appeler nos classes, nos variables, etc. Il faut que vous essayiez de respecter cette convention au maximum. Cette convention, la voici : tous vos noms de classes doivent commencer par une majuscule ! tous vos noms de variables doivent commencer par une minuscule. Si un nom de variable est un nom compos, celui-ci commence par une minuscule et son compos par une majuscule. Et ce, sans sparation. Tout ceci sans
accent ! !
Je sais que la premire classe que je vous ai demand de crer ne respecte pas cette convention, mais je ne voulais pas vous dire a ce moment-l... Donc, prsent, je vous demanderai de ne pas oublier ces rgles ! Sinon ! Chtiment corporel. V oici quelques exemples de noms de classes et de variables : Code : Java public class Toto{} public class Nombre{} public class TotoEtTiti{} String chaine; String chaineDeCaracteres; int nombre; int nombrePlusGrand; //...
www.siteduzero.com
30/669
Donc, pour en revenir au pourquoi du comment, je vous ai dit que les variables de type String sont des objets. Les objets sont dfinis par une ossature (un squelette) qui est en fait une classe. Ici, nous utilisons un objet String qui est dfini dans une classe qui s'appelle " String" ; c'est pourquoi String une majuscule et pas int, float... qui eux ne sont pas dfinis par une classe. Pfiou ! a en fait des choses retenir d'un coup ! Mais je ne vous cache pas que les deux premiers types de variables ne sont pas trop utiliss... Chose importante : veillez bien respecter la casse (majuscules et minuscules) car une dclaration de CHAR la place de char ou autre chose provoquera une erreur, tout comme une variable de type string la place de String ! Alors faites bien attention lors de vos dclarations de variables... Sinon une petite astuce quand mme, enfin deux plutt ! On peut trs bien compacter la phase de dclaration et d'initialisation en une seule phase ! Comme ceci : Code : Java int entier float pi = char carac String mot = 32; 3.1416f; = 'z'; = new String("Coucou");
Et lorsque nous avons plusieurs variables d'un mme type, nous pouvons compacter tout ceci en une dclaration comme ceci : Code : Java int nbre1 = 2, nbre2 = 3, nbre3 = 0;
Ici, toutes les variables sont des entiers et toutes initialises. Bon, t'es bien mignon, mais on code quand, nous ?
Minute papillon ! On va y arriver ! Mais avant, nous avons encore quelque chose de trs important voir pour pouvoir travailler sur et avec nos variables : Les oprateurs arithmtiques
Les oprateurs arithmtiques

Ceci est notre avant dernire ligne droite avant de commencer coder ! Et aprs, vous regretterez le temps o vous n'aviez pas vous creuser la tte !! Bon, allez ! Je vois bien que vous brlez d'impatience, alors on va y aller tout de suite.
Les oprateurs arithmtiques

Ce sont ceux que l'on apprend l'cole primaire...
+ permet d'ajouter deux variables numriques (mais aussi de concatner des chanes de caractres ! Ne vous inquitez pas, on
aura l'occasion d'y revenir).
- permet de soustraire deux variables numriques. * permet de multiplier deux variables numriques. / Permet de diviser deux variables numriques.(mais je crois que vous aviez devin ). % permet de renvoyer le reste de la division de deux variables de type numriques, cet oprateur s'appelle le modulo.
Quelques exemples de calcul
Code : Java int nbre1, nbre2, nbre3;//dclaration des variables
www.siteduzero.com

nbre1 = nbre2 = nbre3 = 0;//initialisation nbre1 nbre2 nbre3 nbre1 nbre2 nbre3 aucun = 1 + 3; // ici nbre1 vaut 4 = 2 * 6; // ici nbre2 vaut 12 = nbre2 / nbre1; //ici nbre3 vaut 3 = 5 % 2; //ici nbre1 vaut 1 car 5 = 2 * 2 + 1 = 99 % 8; //ici nbre2 vaut 3 car 99 = 8 * 12 + 3 = 6 % 3; //et l, nbre3 vaut 0 car la division n'a reste
31/669
Ici, nous voyons bien que nous pouvons affecter des oprations sur des nombres nos variables mais aussi affecter des oprations sur des variables de mme type !! Je me doute bien que le modulo est assez difficile assimiler. V oici une utilisation assez simple : Pour dterminer si un entier est pair, il suffit de voir si cet entier modulo 2 renvoie 0 .
Maintenant, quelque chose que les personnes qui n'ont jamais programm ont du mal assimiler. Je garde la mme dclaration de variable que ci-dessus. Code : Java int nbre1, nbre2, nbre3; nbre1 = nbre2 = nbre3 = 0; nbre1 nbre1 + 1 = nbre2 nbre2 nbre3 nbre3 nbre1 nbre1 = nbre1 + = nbre1 + 2!!! = nbre1; = nbre2 * = nbre2; = nbre3 / = nbre3; = nbre1 1; 1; 2; //dclaration des variables //initialisation
//nbre1 = lui mme donc 0 + 1 => nbre1 = 1 // nbre1 = 1 (cf ci-dessus) maintenant nbre1 = 1
//nbre2 = nbre1 = 2 //nbre2 = 2 => nbre2 = 2 * 2 = 4 //nbre3 = nbre2 = 4 nbre3; //nbre3 = 4 / 4 = 1 //nbre1 = nbre3 = 1 1;// nbre1 = 1 - 1 = 0
Et l aussi, il existe une syntaxe qui raccourcit l'criture de ce genre d'opration. Regardez bien : Code : Java nbre1 = nbre1 + 1; nbre1 += 1; nbre1++; ++nbre1;
Ces trois syntaxes correspondent exactement la mme opration. La troisime syntaxe sera certainement celle que vous utiliserez le plus... mais ne marche que pour augmenter la valeur de 1 ! Si vous devez augmenter la valeur d'une variable de 2, utilisez les deux syntaxes prcdentes. On appelle cette syntaxe l'incrmentation. La dernire fait la mme chose que la troisime, mais avec une subtilit en plus... Nous en reparlerons dans le chapitre sur les boucles. Sinon, la syntaxe est identique pour la soustraction : Code : Java nbre1 = nbre1 - 1; nbre1 -= 1; nbre1--; --nbre1;
Mme commentaire que pour l'addition sauf qu'ici, la troisime syntaxe s'appelle la dcrmentation.
www.siteduzero.com

Les raccourcis pour la multiplication marchent aussi ; regardez plutt : Code : Java nbre1 nbre1 nbre1 nbre1 = nbre1 * 2; *= 2; = nbre1 / 2; /= 2;
32/669
TRES IMPORTANT == On ne peut faire de traitement arithmtique que sur des variables de mme type, sous peine de perdre de la prcision lors du calcul. On ne s'amuse pas diviser un int par un float ! Ou pire, par un char !! Et ceci est valable pour tous les oprateurs arithmtiques et pour tous les types de variables numriques. Essayer de garder une certaine rigueur pour vos calculs arithmtiques.
V oici les raisons de ma mise en garde. Comme je vous l'ai dit plus haut, chaque type de variable a une contenance diffrente et, pour faire simple, nous allons comparer nos variables diffrents rcipients. Une variable de type : byte correspondrait un d coudre. On ne met pas beaucoup de chose dedans... int, un verre. C'est dj plus grand. double, un baril. Pfiou, on en met l-dedans... A partir de l, ce n'est plus que du bon sens. V ous devez facilement voir que vous pouvez mettre le contenu d'un d coudre dans un verre ou un baril. Mais par contre, si vous versez le contenu d'un baril dans un verre... Il y en a plein par terre ! Cela s'appelle : une perte de prcision ! Ainsi, si nous affectons le rsultat d' une opration sur deux variables de type double dans une variable de type int, le rsultat sera de type int et donc ne sera pas un rel mais un entier. Pour afficher le contenu d'une variable dans la console, il vous suffit d'appeler l'instruction : System.out.println(maVariable);, ou encore System.out.print(maDeuxiemeVariable);.
Je suppose que vous voudriez aussi mettre du texte en mme temps que vos variables... Eh bien sachez que l'oprateur + sert aussi comme oprateur de concatnation, c'est--dire qu'il permet de mixer du texte brut avec des variables. V oici un exemple d'affichage avec une perte de prcision : Code : Java double nbre1 = 10, nbre2 = 3; int resultat = (int)(nbre1 / nbre2); System.out.println("Le rsultat est = " + resultat);
Sachez aussi que vous pouvez tout fait mettre des calculs dans un affichage, comme ceci System.out.print("Rsultat = " + nbre1/nbre2); (le plus joue ici le rle d'oprateur de concatnation) ; ceci vous permet d'conomiser une variable et donc de la mmoire. Mais pour le bien de ce chapitre, nous n'allons pas utiliser cette mthode... V ous devez voir que le rsultat fait 3, au lieu de 3.33333333333333... Et je pense que vous tes intrigus par a : int resultat = (int)(nbre1 / nbre2); Avant de vous expliquer, remplacez la ligne cite ci-dessus par celle-ci : int resultat = nbre1 / nbre2; V ous devez voir qu'Eclipse n'aime pas du tout !
www.siteduzero.com

Pour savoir pourquoi, nous allons voir ce qu'on appelle les conversions ou "cast".
33/669
Les conversions, ou "cast"

Comme expliqu plus haut, les variables de type double contiennent plus d'informations que les variables de type int. Ici, il va falloir couter comme il faut... heu, pardon ! Lire comme il faut ! Nous allons voir un truc super important en Java. Ne vous en dplaise, vous serez amens convertir des variables... Conversion de type int vers un autre type numrique D'un type int en type float : Code : Java int i = 123; float j = (float)i;
D'un type int en double : Code : Java int i = 123; double j = (double)i;
Et inversement : Code : Java double i = 1.23; double j = 2.9999999; int k = (int)i; // k vaut 1 k = (int)j; // k vaut 2
Ce type de conversion s'appelle une conversion d'ajustement ou cast de variable. V ous l'avez vu : nous pouvons passer directement d'un type int un type double. Mais ceci ne fonctionnera pas dans le sens inverse sans une perte de prcision. En effet comme vous avez pu le constater, lorsque nous castons un double en int, la valeur de ce double est tronqu. Ce qui signifie que l'int en question prendra la valeur entire du double quelle que soit la valeur des dcimales . Pour en revenir notre ancien problme, il est aussi possible de caster le rsultat d'une opration mathmatique. En mettant celleci entre () et prcde du type de cast souhait. Donc : Code : Java double nbre1 = 10, nbre2 = 3; int resultat = (int)(nbre1 / nbre2); System.out.println("Le rsultat est = " + resultat);
Fonctionne parfaitement. Mais pour un rsultat optimal, vous devez mettre le rsultat de l'opration en type double. Et si on faisait l'inverse ? Si nous dclarons deux entiers et que nous mettons le rsultat dans un double ?
www.siteduzero.com

Comme ceci ? Code : Java int nbre1 = 3, nbre2 = 2; double resultat = nbre1 / nbre2; System.out.println("Le rsultat est = " + resultat);
34/669
V ous auriez 1 comme rsultat. Je ne cast pas ici, car un double peut contenir un int. Et comme a ?
Code : Java int nbre1 = 3, nbre2 = 2; double resultat = (double)(nbre1 / nbre2); System.out.println("Le rsultat est = " + resultat);
Idem... Comment doit-on faire, alors ?
Avant de vous donner la rponse, vous devez savoir qu'en Java, comme dans d'autres langages d'ailleurs, il y a la notion de priorit d'opration et l, nous en avons un trs bon exemple ! Sachez que l'affectation, le calcul, le cast, le test, l'incrmentation... toutes ces choses sont des oprations ! Et Java les fait dans un certain ordre, suivant une priorit. Dans le cas qui nous intresse, il y a trois oprations : un calcul, un cast de valeur de rsultat de calcul, une affectation dans la variable resultat. Eh bien Java excute cette ligne dans cet ordre ! Il fait le calcul (ici 3/2), il cast le rsultat en double, puis il l'affecte dans notre variable resultat. D'accord, mais pourquoi on n'a pas 1.5, alors ?
C'est simple : lors de la premire opration de Java, la JVM voit un cast effectuer mais sur un rsultat de calcul. La JVM fait ce calcul (division de deux int qui, ici, nous donne 1), puis le cast (toujours 1) et affecte la valeur la variable (encore et toujours 1). Donc, pour avoir un rsultat correct, il faudrait caster chaque nombre avant de faire l'opration, comme ceci : Code : Java int nbre1 = 3, nbre2 = 2; double resultat = (double)(nbre1) / (double)(nbre2); System.out.println("Le rsultat est = " + resultat); //affiche: Le rsultat est = 1.5
Message reu mais... peut-on changer un type numrique en autre chose ?
www.siteduzero.com
35/669
Bien sr, je ne dtaillerai pas trop ceci mais maintenant, vous allez transformer l'argument d'un type donn, int par exemple, en String. Voici la mthode appliquer Code : Java int i = 12; String j = new String(); j = j.valueOf(i);
j est donc une variable de type String contenant la chane de caractres 12 . Ceci fonctionne aussi avec les autres types numriques. V oyons maintenant comment faire marche arrire, en partant de ce que nous venons de faire. Code : Java int i = 12; String j = new String(); j = j.valueOf(i); int k = Integer.valueOf(j).intValue();
Maintenant, la variable k est de type int, et contient le nombre 12 . Il y a l'quivalent de intValue() pour les autres types numrique : floatValue(), doubleValue()...
Astuce d'Eclipse
Retapez le code qu'Eclipse n'aimait pas ; pour mmoire, c'tait celui-ci : Code : Java double nbre1 = 10, nbre2 = 3; int resultat = nbre1 / nbre2; System.out.println("Le rsultat est = " + resultat);
Eclipse vous souligne nbre1 / nbre2 et vous met une croix rouge sur la gauche de la zone d'dition, sur cette mme ligne.
Si vous cliquez sur cette croix rouge, vous aurez ceci :
www.siteduzero.com
36/669
Double-cliquez sur "Add cast to 'int'" et Eclipse vous met automatiquement le cast de l'opration ! Ensuite pour tester, vous pouvez cliquez sur "Run" ou appuyer sur Control + F11 . Si vous faites cette manipulation (Ctrl + F11), une fentre s'ouvre et vous demande quelle ressource sauver, puis lancer. Pour le moment, le choix est simple puisque vous n'avez qu'une classe. V ous n'avez plus qu' valider et votre programme se lance ! Au fil de ce tutoriel, vous verrez que cette manipulation va beaucoup vous aider pour des erreurs en tous genres !
Je suis bien conscient que ces deux chapitres taient riches en vocabulaire, en nouveauts (pour ceux qui n'auraient pas lu les cours de M@teo), mais bon, voil : votre calvaire... ne fait que commencer. Eh oui : tout ceci tait un amuse-bouche ! Maintenant, nous rentrons dans le vif du sujet. Dans tous les cas, si vous n' avez pas eu 20/20 ces deux questionnaires, relisez ces deux chapitres !! Allez on s' y jette : Lire les entres clavier ! TAAAAAAAAUUUUTTTT !
www.siteduzero.com
37/669
Lire les entres clavier

Dans ce chapitre, nous verrons comment lire les entres clavier. Nous survolerons ceci sans voir les diffrents cas d'erreurs que cela peut engendrer. Trve de bavardage, je suis sr que vous tes impatients...
Utilisation de l'objet Scanner

Je me doute qu'il vous tardait de pouvoir communiquer avec votre application... Le moment est enfin venu ! Mais je vous prviens, la mthode que je vais vous donner a des failles. Je vous fais confiance pour ne pas rentrer n'importe quoi n'importe quand... Pour les puristes qui me diront " ouais, mais si je rentre a, tu vas te prendre une belle exception dans ta face !", je le sais, mais je ne trouve pas opportun de vous parler des exceptions et de la manire de les capturer maintenant... Bon. Allons-y ! Je vous ai dit que vos variables de type String sont en fait des objets de type String . Pour que Java puisse lire ce que vous tapez au clavier, vous allez devoir utiliser un objet de type Scanner (merci Myhtrys). Je vous rappelle que pour instancier un objet, c'est--dire crer un nouvel objet afin de s'en servir, vous devez utiliser l'oprateur unaire new().
Cet objet peut prendre diffrents paramtres, mais ici, nous n'en utiliserons qu'un. Celui qui correspond justement l'entre standard en Java. Lorsque vous faites System.out.println();, je vous rappelle que vous appliquez la mthode println() sur la sortie standard ; or ici, nous allons utiliser l'entre standard System.in. Donc, avant de dire Java de lire ce que nous allons taper au clavier, nous devrons instancier un objet Scanner. Pour pouvoir utiliser un objet Scanner, nous devons dire Java o trouver cet objet !
Avant de vous expliquer ceci, crez une nouvelle classe et tapez cette ligne de code dans votre mthode main : Code : Java Scanner sc = new Scanner(System.in);
V ous devez avoir une zolie vague rouge sous le mot Scanner. Mais souvenez-vous de l'astuce que je vous avais donne pour le cast de variables. Cliquez sur la croix rouge sur la gauche et double-cliquez sur " Import 'Scanner' java.util ". Et l, l'erreur disparat !
Maintenant, regardez tout au dessus de votre classe, au dessus de la dclaration de celle-ci, vous devez avoir une ligne : Code : Java import java.util.Scanner;
www.siteduzero.com

V oil ce que nous avons fait. Je vous ai dit qu'il fallait dire Java o se trouve la classe Scanner. Pour faire ceci, nous devons importer la classe Scanner, grce l'instruction import. La classe que nous voulons se trouve dans le package java.util .
38/669
Tout d'abord, vous devez savoir que le langage Java n'est qu'une multitude de classes ordonnes en packages . Par dfaut, Java incorpore automatiquement un package contenant les fondements de Java : java.lang . C'est dans ce package qu'il y a les variables de bases, la classe System et beaucoup d'autres choses qui vous permettent de faire des programmes. Pour voir le contenu de ce package, vous pouvez allez voir ici . Je pense que vous avez compris qu'un package est en fait un ensemble de classes. En fait, c'est un ensemble de dossiers et de sous-dossiers contenant une ou plusieurs classes. Par exemple, nous avons import tout l'heure la classe Scanner qui se trouve dans le package java.util . Remplacez les . par des
/, l'arborescence des dossiers est donc java/util/ et dans ce dossier se trouve le fichier Scanner.class ! Vous verrez ceci plus en
dtail lorsque nous ferons nos propre packages. Les classes qui se trouvent dans les autres packages que java.lang sont importer la main dans vos classes Java pour pouvoir vous en servir. La faon dont nous avons import la classe java.util.Scanner dans Eclipse est trs pratique et trs simple. V ous pouvez aussi le faire manuellement en tapant : Code : Java //Ceci import //Ceci import importe la classe Scanner du package java.util java.util.Scanner; importe toutes les classes du package java.util java.util.*;
Si vous faites vos imports manuellement, n'oubliez surtout pas le ; la fin ! Maintenant que vous avez assimil ceci, nous pouvons retourner nos moutons !
Rcuprez ce que vous tapez

Retournons notre morceau de code, pour mmoire : Code : Java Scanner sc = new Scanner(System.in);
Afin de vous prparer saisir des informations, veuillez afficher un message l'cran ; nous avons donc : Code : Java Scanner sc = new Scanner(System.in); System.out.println("Veuillez saisir un mot :");
Maintenant, voici l'instruction pour permettre Java de rcuprer ce que vous avez saisi et ensuite de l'afficher : Code : Java Scanner sc = new Scanner(System.in); System.out.println("Veuillez saisir un mot :"); String str = sc.nextLine(); System.out.println("Vous avez saisi : " + str);
Une fois l'application lance, le message que vous avez crit auparavant s'affiche dans la console, en bas dans Eclipse (vous avez l'habitude, maintenant ).
www.siteduzero.com
39/669
Pensez cliquer dans la console, aprs votre message, afin que ce que vous saisissez soit crit dans la console, pour que Java puisse rcuprer ce que vous avez inscrit !
Alors ? Heureux ? V oil votre premire saisie clavier ! Comme vous avez pu le constater, l'instruction nextLine() renvoie une chane de caractres. Si vous avez essay de remplacer la variable de type String par une variable d'un autre type, vous avez d voir qu'Eclipse n'apprcie pas du tout... Et si vous avez cliqu sur la croix rouge pour corriger le problme, vous constatez que la seule solution qu'il vous propose est de changer le type de votre variable pour le type String. V ous aurez remarqu aussi qu'Eclipse vous simplifie la vie au maximum. Lorsque vous tapez " sc.", Eclipse vous propose une liste de mthodes appartenant cet objet. Si vous remplacez la ligne de code qui rcupre une chane de caractres comme suit : Code : Java Scanner sc = new Scanner(System.in); System.out.println("Veuillez saisir un nombre :"); int str = sc.nextInt(); System.out.println("Vous avez saisi le nombre : " + str);
vous devez voir que lorsque vous utilisez votre variable de type Scanner, et o vous tapez le point permettant d'appeler des mthodes de l'objet, Eclipse vous donne une liste de mthodes associes cet objet et, lorsque vous commencez taper le dbut de la mthode nextInt(), le choix se restreint jusqu' ne laisser que cette seule mthode. Excutez et testez ce programme et vous verrez qu'il fonctionne la perfection ! Sauf... si vous saisissez autre chose qu'un entier ! C'est ce que je vous disais au dpart de ce chapitre. L'objet essaie de rcuprer un entier, mais si vous lui donnez autre chose, une exception est leve ! Nous verrons ceci lorsque nous programmerons des objets... Pour les curieux, voici ce que donnerait l'erreur :
www.siteduzero.com
40/669
V ous savez maintenant que pour lire un int, vous devez utiliser nextInt(). De faon gnrale, dites-vous que pour rcuprer un type de variable, il vous suffit d'appeler next<Type de variable commenant par une majuscule> (rappelez-vous de la convention de nommage !). Bon. C'est mon jour de bont : Code : Java Scanner sc = new Scanner(System.in); int i = sc.nextInt(); double d = sc.nextDouble(); long l = sc.nextLong(); byte b = sc.nextByte(); //etc
Attention : il y a un type de variable primitive qui n'est pas pris en compte par la classe Scanner ; il s'agit des variables de type char.
V oici comment on pourrait rcuprer un caractre : Code : Java System.out.println("Saisissez une lettre :"); Scanner sc = new Scanner(System.in); String str = sc.nextLine(); char carac = str.charAt(0); System.out.println("Vous avez saisi le caractre : " + carac);
Qu'est-ce que nous avons fait ici ? Nous avons rcupr une chane de caractres, puis nous avons utilis une mthode de l'objet String (ici, charAt(0) ) afin de rcuprer le premier caractre saisi ! Mme si vous tapez une longue chane de caractres, l'instruction charAt(0) ne renverra que le premier caractre...
www.siteduzero.com
41/669
V ous devez vous demander pourquoi charAt(0) et non charAt(1) ? Ne vous inquitez pas, nous aborderons ce point lorsque nous verrons les tableaux...
Jusqu' ce qu'on aborde les exceptions, je vous demande d'tre rigoureux et de faire attention ce que vous attendez comme donne afin d'utiliser la bonne mthode. Une prcision toutefois. La mthode nextLine() rcupre le contenu de toute la ligne saisie et repositionne la " tte de lecture" au dbut d'une autre ligne. Par contre, si vous avez invoqu une mthode comme nextInt() , nextDouble() et si vous invoquez directement derrire la mthode nextLine() , celle-ci ne vous invitera pas saisir une chane de caractres mais elle videra la ligne commence prcdemment par les autres instructions car celles-ci ne repositionnent pas la tte de lecture, l'instruction nextLine() le fait donc leurs place. Pour faire simple, ceci : Code : Java import java.util.Scanner; public class Main { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("Saisissez un entier : "); int i = sc.nextInt(); System.out.println("Saisissez une chane : "); String str = sc.nextLine(); System.out.println("FIN ! "); } }
ne vous demandera pas saisir une chane et affichera directement "Fin". Pour pallier ce problme il suffit de vider la ligne aprs les instructions ne le faisant pas : Code : Java import java.util.Scanner; public class Main { public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("Saisissez un entier : "); int i = sc.nextInt(); System.out.println("Saisissez une chane : "); //On vide la ligne avant d'en lire une autre sc.nextLine(); String str = sc.nextLine(); System.out.println("FIN ! "); } }
V oil : je pense que vous tes fin prts pour un QCM, maintenant ! J'espre que cette partie vous a plu et que vous tes encore en forme... A partir de maintenant, nous allons aborder les diffrentes instructions du langage. Commenons par les conditions .
www.siteduzero.com
42/669
Les conditions
Nous abordons ici un des chapitres les plus importants et les plus utiliss. V ous allez voir que tous vos projets ne sont que des enchanements et des imbrications de conditions et de boucles (partie suivante). Dans une classe, la lecture et l'excution se font de faon squentielle. C'est--dire en suivant, ligne par ligne. Avec les conditions , nous allons pouvoir grer diffrents cas de figure, sans pour autant lire tout le code. Assez de belles paroles ! Rentrons tout de suite dans le vif du sujet.
Les oprateurs logiques

Ceux-ci sont surtout utiliss lors de conditions (SI****** alors fait ceci*****) pour tester des vrits ou des contrevrits ! Mais nous verrons plus en dtails leur utilit dans un autre chapitre ! Je vous les colle ici car ils sont faciles mmoriser ; et puis comme a, c'est fait, on n'en parlera plus.
== permet de tester l'galit. Prenons l'exemple compltement inutile suivant (en franais, pour le code Java, ce sera plus tard...).
SI bleu == bleu alors fait ceci.......
!= pas gal ou encore diffrent de. Je pense que c'est assez parlant, non ? < strictement infrieur. <= infrieur ou gal. Vous l'aviez dj trouv, je suis sr ! ! ! > strictement suprieur. >= eh oui, voici son grand frre, le majestueux suprieur ou gal ! && voici l'oprateur ET. Permet de prciser une condition. || est le cousin du ET, le OU. Mme combat que le prcdent. ? : L'oprateur ternaire, pour celui-ci vous comprendrez mieux avec un exemple... vers la fin de ce chapitre.
Comme je vous l'ai dit dans la partie prcdente, les oprations en Java sont soumises un ordre de priorit. Tous ces oprateurs sont soumis cette rgle, de la mme manire que les oprateurs arithmtiques...
Il n'y a pas grand-chose dire sur ces oprateurs sans un exemple concret, donc allons-y.
La structure if....else
Pour commencer, je vais vous expliquer quoi servent ces structures conditionnelles. Elles servent tout simplement pouvoir constituer un programme, en examinant les diffrents cas de figure que celui-ci propose. Je m'explique : imaginons un programme qui demande un utilisateur de rentrer un nombre rel (qui peut tre soit ngatif, soit nul, soit positif). Les structures conditionnelles vont nous permettre de grer ces trois cas de figure. La structure de ces conditions ressemble a : Code : Java if(//condition) { .....// excution des instructions si la condition est remplie ..... ..... } else { ....// excution des instructions si la condition n'est pas remplie .... .... }
www.siteduzero.com
43/669
Ceci peut se traduire par "SI... SINON...". Mettons notre petit exemple du dessus en pratique : Code : Java int i = 10; if (i < 0) System.out.println("Le nombre est ngatif"); else System.out.println("Le nombre est positif");
Testez ce petit code, et vous verrez comment il fonctionne (par exemple, avec la fonction de pas pas). Dans ce cas, notre classe affiche que " le nombre est positif ". Expliquons un peu ce qui se passe : dans un premier temps, la condition du if est teste... (qui dit SI i est strictement infrieur 0). Vu que celle-ci est fausse, le programme excute le else.
Attends un peu ! Lorsque tu nous a prsent la structure des conditions, tu as mis des accolades et l, tu n'en mets pas... Bien observ. En fait, les accolades sont la structure " normale" des conditions mais, lorsque le code l'intrieur d'une d'entre elles n'est compos que d'une seule ligne de code, les accolades deviennent facultatives .
Comme nous avons l'esprit perfectionniste, nous voulons que notre programme affiche " le nombre est nul ", lorsque i est gal 0 ; nous allons donc rajouter une condition. Comment faire... La condition du if est remplie si le nombre est strictement ngatif, ce qui n'est pas le cas ici puisque nous allons le mettre 0, le code contenu dans la clause else est donc excut si le nombre est gal 0 et strictement suprieur 0. Il nous suffit de rajouter une condition l'intrieur de la clause else. Comme ceci : Code : Java int i = 0; if (i < 0) System.out.println("Ce nombre est ngatif !"); else {
if(i == 0) System.out.println("Ce nombre est nul !!"); else System.out.println("Ce nombre est positif
!!"); }
Ici, la seule petite chose qui devrait vous interpeler, c'est l'imbrication d'une structure if... else dans un else. Et encore, parce que je suis tolrant... V ous voyez aussi que le code l'intrieur de la premire clause if ne contient qu'une seule ligne de code [=> accolades facultatives ] et que la clause else correspondante, elle, a plusieurs ligne en son sein [=> on entoure donc le code de cette
www.siteduzero.com

dernire avec des accolades]. Les clauses l'intrieur du premier else n'ont, elles aussi, qu'une seule ligne de code [=> accolades facultatives]. V ous verrez vite que vos programmes ne seront que des imbrications de conditions. Je vous fais voir une autre manire de le faire : Code : Java int i = 0; if (i <= 0) { if(i == 0) System.out.println("Ce nombre est nul !!"); else System.out.println("Ce nombre est ngatif !");
44/669
} else System.out.println("Ce nombre est positif !!");
Je pense que ce code parle de lui-mme... Ici, la clause du if est remplie si i est INFRIEUR OU GAL 0, i vaut 0 la condition est remplie. La suite, vous la connaissez.
Maintenant que vous avez tout compris, je vais vous montrer une autre faon de faire ce code, avec le mme rsultat (encore heureux ! ). En ajoutant juste un petit SINON SI . Regardez bien la magie.
Code : Java int i = 0; if (i < 0) System.out.println("Ce nombre est ngatif !"); else if(i > 0) System.out.println("Ce nombre est positif !!"); else System.out.println("Ce nombre est nul !!");
Alors ? Explicite, n'est-ce pas ? SI i est strictement ngatif => excution du code. SINON SI i est positif => excution du code. SINON i est forcment nul => excution du code.
Il faut absolument donner au else if une condition pour qu'il fonctionne. Sans cela, Eclipse vous mettra de zolies vagues rouges sous votre else if. V ous en avez srement dj vu de nombreuses reprises...
Par contre, je vais TRS FORTEMENT INSISTER sur un point : regardez l'affichage du code : remarquez le petit dcalage entre ma premire condition et ma deuxime. On appelle ceci l'indentation, et comme c'est crit en gros, en gras et en rouge, c'est que c'est hyper important ! En effet, pour vous reprer dans vos futurs programmes, cela sera trs utile. Imaginez deux secondes que vous avez un programme de 700 lignes avec 150 conditions, et que tout est crit le long du bord gauche. V ous allez vous amuser pour retrouver
www.siteduzero.com

o commence et o se termine une condition. Je vous le garantis ! V ous n'tes pas obligs de le faire, mais je vous assure que vous y viendrez.
45/669
titre d'information, n'essayez pas de faire des comparaisons de String ce stade. Je vous expliquerai la marche suivre lors du chapitre sur les fonctions.
Je vois que vous apprenez vite : nous pouvons donc passer la vitesse suprieure ! V oyons tout de suite les conditions multiples.
Les conditions multiples

Avant de commencer, vous devez savoir qu'on ne peut pas tester l'galit de chanes de caractres ! Du moins pas comme je vous l'ai montr ci-dessus... Nous aborderons ce point plus tard.
Derrire ce nom barbare, se trouve simplement une ou deux (ou X) conditions en plus dans un if, ou un else if. Nous allons maintenant utiliser les oprateurs logiques que nous avons vus au dbut. Pfiou ! C'est vieux ! Alors dans ce cas : SI c'est vieux et a va aller => alors on continue. SINON SI c'est vieux et je ne me rappelle plus => on va relire le dbut ! SINON , allons-y tout de suite !
V oil un bel exemple de conditions multiples ! Et je n'ai pas t la chercher loin, celle-l. Elle ressemble beaucoup la condition de notre programme (plus haut). Je sais par exprience qu'on comprend mieux avec un exemple ; donc, allons-y... Maintenant, nous allons vrifier si un nombre donn appartient un intervalle connu ; par exemple, savoir si un nombre est entre 50 et 100. Nous allons essayer de rsoudre ce problme avec les outils que nous avons. En gros, a donnerait quelque chose comme a : Code : Java int i = 58; if(i < 100) { if(i > 50) System.out.println("Le nombre est bien dans l'intervalle"); else System.out.println("Le nombre n'est pas dans l'intervalle");
else System.out.println("Le nombre n'est pas dans l'intervalle");
Rien de bien compliqu : notre objectif dans ce programme est de reprer si un nombre rpond deux conditions, il faut : qu'il soit infrieur 100 qu'il soit suprieur 50.
Eh bien les conditions multiples peuvent liminer deux lignes dans notre prcdent code. Regardez plutt : Code : Java int i = 58; if(i < 100 && i > 50) System.out.println("Le nombre est bien dans l'intervalle"); else
www.siteduzero.com

System.out.println("Le nombre n' est pas dans l'intervalle");
46/669
Nous avons utilis l'oprateur && qui signifie ET. Donc, la condition de notre if est devenu : si i est infrieur 100 ET suprieur 50, alors la condition est remplie. Avec l'oprateur &&, la clause est remplie si et seulement si les conditions formant la clause sont toutes remplies ; si l'une des conditions n'est pas vrifie, la clause sera considre comme fausse. Ici, nous avons deux conditions lies par l'oprateur && : les deux conditions doivent tre vraies pour que la clause soit remplie ! Cet oprateur vous initie la notion d'intersection d'ensembles. Ici, nous avons deux conditions qui dfinissent chacune un ensemble : i < 100 dfinit un ensemble des nombres infrieurs 100 (59 ou 45 ou 0 ou -1000000) i > 50 dfinit les nombres suprieurs 50 (58 ou 79 ou 101 ou 1000000). L'oprateur && permet de faire intersection de ces ensembles. La condition regroupe donc les nombres qui appartiennent ces deux ensembles, ici les nombres de 51 99 inclus. Rflchissez bien l'intervalle que vous voulez dfinir. Regardez ce code : Code : Java int i = 58; if(i < 100 && i > 100) System.out.println("Le nombre est bien dans l'intervalle"); else System.out.println("Le nombre n'est pas dans l'intervalle");
Ici, la condition ne sera JAMAIS remplie car, personnellement, je ne connais aucun nombre qui est la fois plus petit que 100 et plus grand ! Par contre, si on remplace les infrieur / suprieur stricts par des infrieur / suprieur ou gal, le seul nombre qui puisse valider la clause est 100, car c'est le seul qui appartienne aux deux ensembles.
Reprenez le code prcdent, celui-ci o la condition ne sera jamais remplie... Maintenant, remplacez l'oprateur && par || (pour mmoire, c'est un OU). l'excution du programme et aprs plusieurs tests de valeur pour i, vous pouvez vous apercevoir que tous les nombres remplissent cette condition, sauf 100. Nous vrifions ici si le nombre choisi appartient L'UN DES DEUX ensembles ou aux DEUX . On cherche un nombre strictement infrieur 100 OU un nombre strictement suprieur 100 : donc tous les nombres remplissent cette condition, SAUF 100 . Et l, si nous remplaons les ingalits strictes par des ingalits larges, tous les nombres remplissent la condition, car 100 fera partie des deux ensembles. Ici, un seul oprateur large suffit, car si 100 appartient l'un des deux ensembles, la condition sera remplie car le nombre doit appartenir l'un ou l'autre, ou aux deux intervalles !
La structure switch
Cette instruction est un peu particulire... par sa syntaxe, et son utilisation. Le switch est surtout utilis lorsque nous voulons des conditions " la carte". Le meilleur exemple se trouve sur le site du Zr0 : ce n'est pas tant la note, mais l'apprciation qui suit qui est dfinie avec un switch. Prenons l'exemple d'un questionnaire de 4 questions, sur 5 points chacune, qui nous donne 5 notes, et donc 5 apprciations possibles, comme ce qui suit : 0/20 : tu peux revoir ce chapitre, petit Zr0 ! 5/20 : concentre-toi un peu plus... Allez, persvre ! 10/20 : Je crois que tu as compris l'essentiel ! Viens relire ce chapitre l'occasion. 15/20 : BRAVO ! V oil une note encourageante pour moi qui essaie de vous apprendre des trucs ! 20/20 : IL EST VRAIMENT... IL EST VRAIMENT.... IL EST VRAIMENT
www.siteduzero.com

PHHHEEEEEENOOOOOMMEEEEEENAAAALLLL!
47/669
Dans ce genre de cas, on utilise un switch pour allger un peu le code, et surtout pour viter des else if rptition. J'en conviens : nous pouvons trs bien arriver au mme rsultat avec des if qu'avec un switch. Mais il faut le voir tout de mme.
Je vais vous expliquer comment se construit la syntaxe d'un switch ; puis nous allons le mettre en pratique tout de suite aprs. Syntaxe Code : Java switch (/*variable*/) { case /*argument*/: /*action*/; break; case /*argument*/: /*action*/; break; case /*argument*/: /*action*/; break; } default:/*action*/;
Cette expression s'excute comme suit : la classe value l'expression figurant aprs le switch (ici /* variable*/) la classe cherche ensuite s'il existe une languette (case /*valeur possible de la variable */:), dans le bloc d'instructions, correspondant la forme de /*variable*/ s'il existe une languette, la requte figurant dans celle-ci sera excute sinon, on passe la languette suivante ! Si aucun cas n'a t trouv, la classe va excuter ce qui se trouve dans l'instruction default:/*action*/;, voyez ceci comme une scurit. Notez bien la prsence de l'instruction break;. Celle-ci permet de sortir du switch si une languette a t trouve pour le cas concern. Pour mieux juger de l'utilit de cette instruction, enlevez tous les break;, et compilez votre programme. V ous verrez le rsultat...
V oil un exemple de switch que vous pouvez essayer : Code : Java int nbre = 5; switch (nbre) { case 1: System.out.println("Ce nombre est tout petit"); break; case 2: System.out.println("Ce nombre est tout petit"); break;
www.siteduzero.com

case 3: System.out.println("Ce nombre est un peu plus grand"); break; case 4: System.out.println("Ce nombre est un peu plus grand"); break; case 5: System.out.println("Ce nombre est la moyenne"); break; case 6: System.out.println("Ce nombre est tout de mme grand"); break; case 7: System.out.println("Ce nombre est grand"); break; default: System.out.println("Ce nombre est trs grand, puisqu'il est compris entre 8 et 10"); }
48/669
Ici, vous devriez commencer voir l'intrt de l'indentation ==> je crois que je l'aurai assez dit... Si vous avez essay ce programme en enlevant l'instruction break;, vous avez d vous rendre compte que le switch excute le code contenu dans le case 5: mais aussi dans tous ceux qui suivent ! L'instruction break; permet de sortir de l'opration en cours . Dans notre cas, on sort de l'instruction switch, mais vous verrez une autre utilisation au chapitre suivant. L'instruction switch ne prend que des entiers ou des caractres en paramtre... C'tait important de le dire.
Je pense que c'est assez clair ! V ous pouvez voir le mme rsultat lorsque vous faites des "scores" diffrents dans vos QCM. Surtout, pensez bien l'instruction break;, et aussi vos ;. Si tout le monde suit, voyons quoi ressemble les conditions ternaires !
La condition ternaire
Celle-ci est un peu particulire mais trs pratique. Avec elle, vous pourrez condenser certaines parties de code, mais attention ne pas en abuser sinon votre code sera indigeste. La particularit des conditions ternaires rside dans le fait que trois oprandes (variable ou constante) sont mises en jeu mais aussi que ces conditions sont employes pour affecter des donnes dans une variable. V oici quoi ressemble la structure de ce type de condition : Code : Java int x = 10, y = 20; int max = (x < y) ? y : x ; //Maintenant max vaut 20
Dcortiquons ce qu'il se passe : Nous cherchons affecter une valeur notre variable max , mais de l'autre ct de l'oprateur d'affectation se trouve une condition ternaire... Ce qui se trouve entre parenthses est valu : est-ce que x est plus petit que y, donc deux cas de figure se profilent l'horizon : Si la condition renvoie true (vrai), donc qu'elle est vrifie, la valeur qui se trouve aprs le ? sera affecte. Sinon, la valeur se trouvant aprs le symbole : sera affecte.
www.siteduzero.com

L'affectation est faite, vous pouvez utiliser votre variable max .
49/669
Attention : La condition que vous valuez doit retourner soit vrai soit faux !
Pour vous faire voir l'utilit de ce genre d'instruction, voil quoi pourrait ressembler un code qui fait exactement la mme chose que l'exemple que je vous ai fourni : Code : Java int x = 10, y = 20, max = 0; if(x < y) max = y; else max = x;
V ous pouvez aussi faire des calculs (ou autre chose) avant d'affecter les valeurs, donc ce code fonctionne : Code : Java int x = 10, y = 20; int max = (x < y) ? y * 2 : x * 2 ; //Ici max vaut 2 * 20 soit 40
J'espre que vous y voyez plus clair... Cependant, vous devez savoir autre chose, comme je vous l'ai dit lorsque vous avez lu le chapitre sur les oprateurs, vous pouvez utiliser le modulo pour savoir si un nombre est pair ou impair. Avec le code suivant, vous allez voir que la variable que nous souhaitons affecter n'a pas de lien avec la condition prsente dans l'instruction ternaire. Pour preuve nous allons affecter un String grce une condition sur deux int : Code : Java int x = 10; String type = (x % 2 == 0) ? "C' est pair" : "C' est impair" ; //Ici type vaut "C' est pair" x = 9; type = (x % 2 == 0) ? "C' est pair" : "C' est impair" ; //Ici type vaut "C' est impair"
Avant de vous laisser, vous ne devez pas oublier que la valeur que vous allez affecter votre variable DOIT ETRE DU MEME TYPE QUE VOTRE VARIABLE ! ! V ous devez aussi savoir que rien ne vous empche de mettre une condition ternaire dans une condition ternaire Code : Java int x = 10, y = 20; int max = (x < y) ? (y < 10) ? y % 10 : y * 2 : x ; // max vaut 40 //Pas trs facile lire... //Vous pouvez entourer votre deuxime instruction ternaire avec des parenthses pour mieux voir max = (x < y) ? ((y < 10) ? y % 10 : y * 2) : x ; // max vaut 40 :
www.siteduzero.com
50/669
Je vous propose maintenant un petit QCM de derrire les fagots... Je vous conseille d'utiliser ce que vous venez de voir avec ce que vous avez appris lors du chapitre prcdent ! V ous verrez tout de suite qu'il est assez pnible de lancer l'application chaque fois. Rappelez-vous de ce que je vous ai dit sur l'excution squentielle d'un programme. Une fois arriv la fin, le programme s'arrte... Si seulement on pouvait rpter des morceaux de codes... Ah ! Mais c'est ce que nous verrons dans le chapitre suivant... Je crois que vous tes d'attaque pour le prochain chapitre : les boucles ! GERONIMOOOOOO !
www.siteduzero.com
51/669
Les boucles
Autre chapitre important en Java : les boucles ! Oui, mais ...c'est quoi, ces fameuses boucles ?
Une boucle est une instruction qui permet de faire plusieurs fois la mme chose... Trs pratique lors de protocoles lourds en excution. Comme lorsque nous demandons si un utilisateur souhaite refaire quelque chose ou non. Ou encore, lorsque nous devons trier des donnes dans un tableau... Eh bien, dans ce genre de cas, on se sert d'une boucle ! En gros, en franais a donnerait : tant que nombre de lignes est infrieur 100, alors fais ceci, ou cela, mais n'oublie pas de faire a... Ne vous inquitez pas : ce chapitre est facile digrer. Bon apptit !
La boucle while
Dcortiquons prcisment ce qui se passe dans une boucle. Pour cela, nous allons voir comment elle se forme. Une boucle commence par une dclaration. Ici : while qui veut dire, peu de chose prs, TANT QUE. Ensuite, nous avons une condition. C'est elle qui permet la boucle de s'arrter. Une boucle n'est pratique que si nous pouvons la contrler, et donc lui faire rpter une instruction un certain nombre de fois. C'est a que servent les conditions. Puis nous avons l'instruction. C'est ce que va rpter notre boucle ! Dans une boucle, il peut y avoir une ou plusieurs instructions. Remarque : il peut mme y avoir des boucles, dans une boucle... ce stade, la boucle va tester la condition, et en fonction de celle-ci, va recommencer ou s'arrter. Un exemple concret est toujours le bienvenu... V oici comment une boucle de type while se fait en Java. D'abord, rflchissons au "comment notre boucle va travailler". Pour cela, il faut dterminer notre exemple. Nous allons afficher "bonjour", <un prnom> que vous allez taper l'cran, puis vous demanderez si vous voulez recommencer. Pour russir ceci, il nous faut une variable pour recevoir le prnom, donc de type String, et une variable pour rcuprer votre rponse et l, plusieurs choix s'offrent nous : soit un caractre, soit une chane de caractres, soit un entier. Ici, nous prendrons une variable de type char. Et c'est parti ! Code : Java //Une variable vide String prenom; // On initialise celle-ci O pour oui ! char reponse = 'O'; //Notre objet Scanner, n'oubliez pas l'import de java.util.Scanner Scanner sc = new Scanner(System.in); //Tant que la rponse donne est gale oui while (reponse == 'O') { //On affiche une instruction System.out.println("Donnez un prnom : "); //On rcupre le prnom saisi prenom = sc.nextLine(); // On affiche notre phrase avec le prnom System.out.println("Bonjour " +prenom+ " comment vas-tu ?"); //On demande si la personne veut faire un autre essai System.out.println("Voulez-vous ressayer ?(O/N)"); //On rcupre la rponse de l'utilisateur reponse = sc.nextLine().charAt(0); }
www.siteduzero.com

System.out.println("Au revoir..."); //Fin de la boucle
52/669
Avant tout, vous avez d cligner des yeux sur cette ligne " reponse = sc.nextLine().charAt(0);". Rappelez-vous comment on rcupre un char avec l'objet Scanner. Nous devons rcuprer un objet String et ensuite prendre le premier caractre de celui-ci ! Eh bien cette syntaxe est une contraction de ce que je vous avais fait voir auparavant . Cette faon de faire permet d'conomiser une variable et donc de la mmoire ! Ici sc.nextLine() renvoie un String sur lequel on applique tout de suite la mthode qui retourne le premier caractre de la chane (charAt(0)), nous pouvons donc, sans crainte, initialiser une variable de type char avec le rsultat obtenu.
Dtaillons un peu ce qui ce passe. Dans un premier temps, nous avons dclar et initialis nos variables. Ensuite, la boucle teste la condition qui nous dit : "Tant que la variable reponse contient OUI, on excute la boucle" . Celle-ci contient bien la chane OUI, donc nous entrons dans la boucle. Rappelez-vous qu'on teste l'galit des conditions avec un double gal ==. Puis c'est l'excution des instructions, dans l'ordre o elles apparaissent dans la boucle. Et la fin, c'est--dire l'accolade fermante de la boucle, le compilateur retourne au dbut de la boucle. Cette boucle n'est excute que lorsque la condition est remplie : ici, nous avons initialis la variable " reponse" 'O' pour que la boucle se fasse. Si nous ne l'avions pas fait, nous n'y serions jamais rentrs. Normal, puisque nous testons la condition avant de rentrer dans la boucle !
V oil. C'est pas mal, mais il y a un petit problme, dans ce programme... V ous ne voyez pas ? Oh ! Je suis sr qu'il y a des petits malins qui se sont amuss mettre autre chose que 'O' ou 'N' en " reponse". Ces petits filous-l ont d remarquer que nous sortons de la boucle si on tape autre chose que 'O'... Essayez de trouver comment pallier ce problme.... Il faudrait forcer les utilisateurs ne tapez que 'OUI' ou 'NON'... Mais non, pas en leur mettant un couteau sous la gorge, bande de barbares ! Avec une boucle ! Comment faire ? C'est trs simple, vous allez voir ! Il suffit, comme je l'ai dit plus haut, de forcer les utilisateurs rentrer soit 'NON'soit 'OUI' ! Avec un while ! Mais cela sous-entend de rinitialiser notre variable reponse ' ' (caractre vide). Nous allons utiliser ici la mthode. Occupons-nous de la condition de notre boucle, maintenant. Il faut rpter la phase "V oulezvous ressayer ?" tant que la " reponse" donne n'est pas 'OUI' et 'NON' : voil, tout y est. On appelle ce genre de condition des conditions multiples. V ous avez vu les oprateurs logiques au chapitre 2, normalement... (et == &&) Nous en reparlerons dans le prochain chapitre... V oici notre programme dans son intgralit : Code : Java //Une variable vide String prenom; // On initialise celle-ci O pour oui ! char reponse = 'O'; //Notre objet Scanner, n'oubliez pas l' import de java.util.Scanner Scanner sc = new Scanner(System.in); //Tant que la rponse donne est gale oui while (reponse == 'O') { //On affiche une instruction System.out.println("Donnez un prnom: "); //On rcupre le prnom saisi prenom = sc.nextLine(); // On affiche notre phrase avec le prnom System.out.println("Bonjour " +prenom+ " comment vas-tu ?"); //rinitialisation de la variable rponse. //Sans a, nous n' entrions pas dans la deuxime boucle
www.siteduzero.com

reponse = ' '; //tant que la rponse n'est pas O ou N, on repose la question while(reponse != 'O' && reponse != 'N') { //On demande si la personne veut faire un autre essai System.out.println("Voulez-vous ressayer ?(O/N)"); //On rcupre la rponse de l'utilisateur reponse = sc.nextLine().charAt(0); }
53/669
} //Fin de la boucle System.out.println("Au revoir...");
Je vous le rpte une dernire fois : PENSEZ A L'INDENTATION !
V ous pouvez tester ce code (c'est d'ailleurs vivement conseill) : vous verrez que si vous ne rentrez pas la bonne lettre, le programme vous demandera sans cesse votre rponse !
Attention bien crire vos conditions , et bien vrifier vos variables dans vos while, et dans toutes vos boucles en gnral. Sinon c'est le drame ! Essayez le programme prcdent sans la rinitialisation de la variable reponse, et vous verrez le rsultat... on ne rentre jamais dans la 2 boucle, car " reponse" = 'O' (initialis au dbut du programme). L, vous ne pourrez jamais changer sa valeur... donc le programme ne s'arrtera jamais ! On appelle a une boucle infinie.
V oil un autre exemple de boucle infinie, encore plus flagrante : Code : Java int a = 1, b = 15; while (a < b) { System.out.println("coucou " +a+ " fois !!");
www.siteduzero.com

}
54/669
Si vous lancez ce programme, vous allez voir une quantit astronomique de coucou 1 fois !!, car, dans cette condition, a sera toujours infrieur b. Si nous voulions faire en sorte que ce programme fonctionne comme il faut, nous aurions d rajouter une instruction dans le bloc d'instructions de notre while, pour changer la valeur de a chaque tour de boucle... Comme ceci : Code : Java int a = 1, b = 15; while (a < b) { System.out.println("coucou " +a+ " fois !!"); a++; }
Ce qui nous donnerait cela :
Notre a a bien augment de 1 chaque tour. Et si vous me dites que vous n'avez jamais vu a++; je vous renvoie illico au second chapitre ==> sous chapitre 3 ! Qu'en dites-vous ? Pas trop mal, non ? Je dirais mme bien ! Une petite astuce : lorsque vous n'avez qu'une instruction dans votre boucle, vous pouvez enlever les accolades { }, celles-ci deviennent superflues, tout comme les instructions if, else if ou else.
V ous auriez pu aussi utiliser cette syntaxe : Code : Java int a = 1, b = 15; while (a++ < b) System.out.println("coucou " +a+ " fois !!");
www.siteduzero.com
55/669
Ici, l'oprateur '++' n'agit qu'aprs avoir valu 'a'. Ce qui veut dire que l'effet de l'oprateur '++' (qui est une incrmentation) n'est peru qu'une instruction aprs. Par contre, testez ce code : Code : Java int a = 1, b = 15; while (++a < b) System.out.println("coucou " +a+ " fois !!");
V ous devez remarquer qu'il y a un tour de boucle en moins ! Eh bien, avec cette syntaxe, l'incrmentation est immdiate. C'est--dire que la boucle incrmente la variable a et, seulement aprs avoir fait cela, elle teste la condition ! V ous avez d remarquer aussi que notre instruction n'affiche plus " coucou 1 fois !!". Cela cause de l'incrment dans la condition. Au premier tour de boucle, on entre dans la condition et, quelque soit l'ordre d'incrmentation, la fin du premier test de condition, a vaut 2 . Donc
rflchissez bien vos
conditions de boucles !
Avant d'aller voir un autre type de boucle, j'insiste sur le fait que vous devez bien rflchir vos conditions, ainsi qu' vos variables, avant de lancer une boucle, sous peine de ne jamais y rentrer, ou comme on l'a vu, de faire une boucle infinie ! Bon, continuons avec la boucle do{...}while().
La boucle do....while
Vu que je viens de vous expliquer comment marche une boucle while, je ne vous expliquerai que trs brivement la boucle do... while. Euh... t'es sr de ton coup, l?
Bien entendu. En fait, ces deux boucles ne sont pas cousines, mais plutt frangines (soeurs, si vous prfrez...). Dans le fonctionnement, elles sont identiques, deux dtails prs. Soeurs, mais pas jumelles, quoi...
Premire diffrence
La boucle do... while s'excutera au moins une fois , contrairement sa soeur. C'est--dire que la phase de test de la condition se fait la fin. Car la condition se met aprs le while.
Deuxime diffrence
Diffrence de syntaxe. Et elle se situe aprs la condition du while. Exemple : Code : Java do{
blablablablablablablabla }while(a < b);
V ous voyez la diffrence ? Oui ? Non ? Il y a un ; aprs le while. C'est tout ! Par contre, ne l'oubliez pas, sinon le programme ne compilera pas.
Mis part ces deux lments, ces boucles fonctionnent exactement de la mme manire. D'ailleurs, nous allons refaire les deux programmes de la boucle while ci-dessus, avec une boucle do... while. C'est parti ! Code : Java
www.siteduzero.com

//une variable vide ! String prenom = new String(); //pas besoin d'initialiser la variable car on entre au moins une fois dans la boucle ! char reponse = ' '; //Notre objet Scanner, n'oubliez pas l'import de java.util.Scanner Scanner sc = new Scanner(System.in); do{ System.out.println("Donnez un prnom : "); prenom = sc.nextLine(); System.out.println("Bonjour " +prenom+ ", comment vas-tu ?
56/669
");
System.out.println("Voulez-vous ressayer ?(O/N)"); reponse = sc.nextLine().charAt(0); }while (reponse == 'O'); System.out.println("Au revoir...");
Et faites-moi confiance : a marche ! Mais toujours le mme problme de rponse... V oici donc le code complet : Code : Java //une variable vide ! String prenom = new String(); //pas besoin d'initialiser la variable car on entre au moins une fois dans la boucle ! char reponse = ' '; //Notre objet Scanner, n'oubliez pas l'import de java.util.Scanner Scanner sc = new Scanner(System.in); do{ System.out.println("Donnez un prnom : "); prenom = sc.nextLine(); System.out.println("Bonjour " +prenom+ ", comment vas-tu ? do{
");
System.out.println("Voulez-vous ressayer ? (O/N)"); reponse = sc.nextLine().charAt(0); }while(reponse != 'O' && reponse != 'N'); }while (reponse == 'O'); System.out.println("Au revoir...");
V ous voyez donc que ce code ressemble beaucoup celui utilis avec la boucle while, mais avec une petite subtilit. Avec celui-ci, plus besoin de rinitialiser la variable reponse, puisque, de toute manire, la boucle s'excutera au moins une fois ! Normalement, vous devriez avoir compris du premier coup ! On va pouvoir se lancer sur la dernire boucle : la boucle for.
La boucle for
Cette boucle est un peu particulire, puisque qu'elle prend tous ses attributs dans sa condition, et agit en consquence. Je m'explique : jusqu'ici, nous avions fait des boucles avec : dclaration d'une variable avant la boucle initialisation de cette variable incrmentation de celle-ci dans la boucle. Eh bien on met tout a dans la condition de la boucle for, et c'est tout. Mais je sais bien qu'un long discours ne vaut pas un
www.siteduzero.com

exemple, alors voil une boucle for sous vos yeux bahis : Code : Java for(int i = 1; i <= 10; i++) { System.out.println("Voici la ligne "+i); }
57/669
Et a nous donne :
V ous aurez srement remarqu la prsence des ';' dans la condition pour la sparation des champs. Et l, ne les oubliez surtout pas, sinon, le programme ne compilera pas. Je vous fais la mme remarque que pour la boucle while concernant les accolades... Nous pouvons aussi tourner la boucle dans le sens inverse. C'est--dire qu'au lieu de partir de zro pour aller 10, nous allons aller de 10 pour atteindre 0. Comme ceci : Code : Java for(int i = 10; i >= 0; i--) System.out.println("Il reste "+i+" ligne(s) crire");
Ce qui nous donne :
www.siteduzero.com
58/669
Bien entendu, ces structures servent essentiellement rpter des instructions rbarbatives ; mais elles servent aussi faire des recherches dans certains cas de figure, ce que nous aborderons dans un prochain chapitre.
Bon : vu que nous sommes de bons ZrOs et que nous n'aimons pas les fautes d'orthographe, nous voulons mettre " ligne" au pluriel lorsqu'il nous en reste plusieurs crire, et au singulier lorsqu'il nous en reste 1 ou moins ! Il va de soit que nous allons utiliser les conditions pour russir ce tour de force. Je vous laisse rflchir . Secret (cliquez pour afficher) Code : Java for(int i = 10; i >= 0; i--) { if(i > 1) System.out.println("Il reste "+i+" lignes crire"); else System.out.println("Il reste "+i+" ligne crire"); }
Et le rsultat de ce code :
Il existe une autre syntaxe de boucle for depuis le JDK 1.5, celle-ci se rapprocherait d'une boucle foreach prsente dans d'autres langages (PHP, C#...). Nous verrons celle-ci lorsque nous aborderons les tableaux.
Un petit dtail, tout de mme... Ici, nous avons utilis un entier bien dfini pour grer nos boucles, tel que 0 ou 10. Nous pouvons tout aussi bien faire les mmes boucles avec une variable en guise d'attribut. L, vous commencez apercevoir leur intrt. Ne vous inquitez pas : vous allez voir tout ceci plus tard. Et plus prcisment dans le chapitre sur les tableaux , qui arrive pas de loup ! Et voil : la boucle est boucle !! Normalement, vous n'aurez pas besoin de digestif pour ce chapitre ! Mais on ne sait jamais... Je crois qu'il est temps pour un petit TP !
www.siteduzero.com
59/669
TP n1 : un tableau de conversion Celsius Fahrenheit !

V oil un trs bon petit TP qui va mettre en oeuvre tout ce que vous avez vu jusqu'ici. Mais vraiment tout ! Accrochez-vous, car l je vais vous demander de penser des tonnes de choses, et vous serez tout seuls. Lchs dans la nature... non, je plaisante. Oui, je sais, je dconne beaucoup, tout de mme ! Mais je pense que nous apprendrons mieux dans la bonne humeur. Bon : trve de bavardage, au boulot.
laboration
Euh... Avant de foncer ttes baisses sur Eclipse, et commencer coder, nous allons d'abord essayer de structurer notre futur programme. En plus, je ne vous ai mme pas dit ce que j'attendais de vous...
Cahier des charges

Alors je veux : un code qui puisse se rpter autant de fois que nous le souhaitons que le code demande quelle temprature nous commenons la conversion la temprature de fin de conversion le pas de conversion => c'est--dire par degr, ou tous les 2 degrs, ou les x degrs qu'on vrifie les cas impossibles : comme un pas plus grand que l'intervalle de temprature , ou une temprature d'arrive plus petite que la temprature de dpart qu'on demande l'utilisateur s'il est prt, ou si son imprimante est prte... enfin ce que vous voulez, ici s'il est prt, que l'on affiche les conversions sous forme de tableau visuel qu'il n'y ait pas de dcalage pour les diffrentes valeurs => tout doit tre parfaitement align enfin, que l'on demande l'utilisateur s'il veut faire une nouvelle conversion, donc revenir au dbut, s'il le souhaite ! Je vous avais prvenus que je serais exigeant ! Mais croyez-moi, vous tes capables de le faire. Je sais que vous y arriverez !
laboration
Comme je vous l'ai dit, essayez de rflchir sur papier avant... Ce qu'il vous faut comme nombre de variables, les types de variables, comment va se drouler le programme, les conditions et les boucles utilises... Pour info, voici la formule de conversion pour passer des degrs Celsius en degrs Fahrenheit :
F = 9/5 * C + 32
Je vais vous aiguiller un peu : pour ce genre de calcul, utilisez des variables de type double faites attention la priorit des oprations de simples if... else suffisent ici : pas besoin d'un switch.
V oici un aperu de ce que je vous demande :
www.siteduzero.com
60/669
V ous voyez bien que tous mes chiffres sont aligns, malgr leur taille. Lors de l'affichage, il faudra donc utiliser une condition en fonction de la taille des chiffres (if Celsius < 100){.........} else{.........}). Je vais galement vous donner une fonction toute faite, qui vous permettra d'arrondir vos rsultats. Je vous expliquerai le fonctionnement des fonctions exactement 2 chapitres plus loin. Mais en attendant, c'est facultatif. V ous pouvez trs bien ne pas vous en servir. Pour ceux qui souhaitent tout de mme l'utiliser, la voici : Code : Java public static double arrondi(double A, int B) { return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B); }
Elle est placer entre les deux accolades fermantes de votre classe, comme ceci :
www.siteduzero.com
61/669
V ous pouvez l'utiliser de cette manire : imaginez que vous avez la variable fahren arrondir, et que le rsultat obtenu soit enregistr dans une variable arrondFahren, vous procderez comme suit : Code : Java arrondFahren = arrondi(fahren, 1); // pour un chiffre aprs la virgule arrondFahren = arrondi(fahren, 2);// pour 2 chiffres aprs la virgule... etc.
Bon : Je vous ai dj assez aids ! Place la conception.
Conception
Dernire recommandation
Essayez de bien INDENTER votre code ! Prenez votre temps. Essayez de penser tous les cas de figures... Maintenant vos papiers, crayons, neurones et claviers, ...et bon courage !
Correction
STOP !!! C'est fini ! Passons maintenant la correction de ce premier TP.
a va ? Pas trop mal la tte ? Je me doute qu'il a d y avoir quelques tubes d'aspirine d'utiliss... Mais vous allez voir qu'en dfinitive, ce TP n'tait pas si compliqu. Surtout, n'allez pas croire que ma correction est parole d'vangile... Il y avait diffrentes manires d'obtenir le mme rsultat. V oici tout de mme une des corrections possibles. Code : Java class Sdz1 { public static void main(String[] args) { //Notre objet Scanner Scanner sc = new Scanner(System.in); //initialisation des variables double c, f=0; int i,j=0; char reponse=' ';
www.siteduzero.com

System.out.println(" -----------------------------------------------------------------------"); System.out.println("| CONVERSION DEGRES CELSIUS ET DEGRES FAHRENHEIT |"); System.out.println(" -----------------------------------------------------------------------"); do{//tant que reponse = O//boucle principale do{//tant que l'imprimante n'est pas prte//boucle de test pour savoir si l'utilisateur est prt do {// tant que valeur impossible rentre //saisie des valeurs System.out.println("A partir de :");//affichage des directives et rcupration des donnes c = sc.nextDouble(); System.out.println("jusqu' :"); i = sc.nextInt(); System.out.println("Par pas de :"); j = sc.nextInt(); if (c > i || j > i || j == 0) System.out.println("Traitement impossible"); }while(c > i || j > i || j == 0); do {//tant que la reponse n'est pas O ou N prte"); tapez N"); System.out.println("Assurez-vous que l'imprimante est System.out.println("Si vous tes prt, tapez O, sinon //sc.reset(); reponse = sc.next().charAt(0);
62/669
}while (reponse != 'O' && reponse != 'N'); }while (reponse == 'N'); // Traitement des valeurs System.out.println("TABLE DE CONVERSION CELSIUS / FAHRENHEIT"); System.out.println("--------------------------------------------"); System.out.println(" Celsius | Fahrenheit "); System.out.println("--------------------------------------------"); do{//tant que l'affichage n'est pas fini, on boucle les donnes et les calculs f = ((9.0/5.0) * c) + 32.0; if (c < 10)//si le Celsius n'a qu'un chiffre, on affiche un certain nombre d'espaces System.out.println(" "+c+" | "+arrondi(f,1)); else {
if(c < 100)//S'il y a un chiffre en plus, on enlve un espace blanc... System.out.println(" "+c+" | "+arrondi(f,1)); else System.out.println(" "+c+" | "+arrondi(f,1)); } c = c + j;//On incrmente le degr Celsius avec le pas
www.siteduzero.com

}while (c <= i); do{ (O/N)"); System.out.println("Souhaitez-vous diter une autre table ? reponse = sc.next().charAt(0);
63/669
}while(reponse != 'O' && reponse != 'N'); }while(reponse == 'O'); System.out.println("Au revoir !"); //Fin de programme } public static double arrondi(double A, int B) { return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B); }
Expliquons un peu ce code
Tout programme commence par une phase de dclaration de variable. Nous affichons le titre de notre programme. Ensuite, vous voyez 3 do{ conscutifs, correspondant chacun une condition vrifier : le choix de l'utilisateur pour faire une nouvelle conversion, vrification si l'utilisateur est prt, vrification si les nombres sont cohrents. Nous affichons les renseignements l'cran, et nous rcuprons les saisies clavier dans une variable. Si les chiffres sont incohrents, on affiche une erreur, et on boucle sur le dbut. Une boucle pour s'assurer que l'utilisateur rentre bien O ou N. partir d'ici, les nombres sont cohrents, et l'utilisateur est prt. Donc on lance la conversion. On affiche le squelette du tableau. Une boucle pour afficher les diffrents rsultats . Calcul de la conversion. Selon la taille du chiffre Celsius, on enlve (ou non) un espace l'affichage. Cette boucle sera rpte tant que le degr de dpart est plus petit que le degr de fin que vous avez choisi . FIN DU PROGRAMME !
Ce programme n'est pas parfait, loin de l... La vocation de celui-ci tait de vous faire utiliser ce que vous avez appris et je pense qu'il remplit bien sa fonction. J'espre que vous avez apprci ce TP. Je sais qu'il n'tait pas facile, mais avouez-le : il vous a bien fait utiliser tout ce que vous avez vu jusqu'ici ! V oil : votre premier TP est fait, et bien fait !! Je vous conseille de vous reposer un peu, parce que a a d fumer dans votre boite crnienne... Je viens de vous faire afficher un tableau (rudimentaire l'affichage), mais maintenant nous allons travailler avec des tableaux en Java ! C'est parti...
www.siteduzero.com
64/669
Les tableaux
Comme dans tout langage de programmation qui se respecte, Java travaille aussi avec des tableaux. V ous verrez que ceux-ci s'avrent bien pratiques... Mais un tableau... Qu'est-ce que c'est, au juste ?
Trs bonne question. V ous vous doutez bien (je suppose) que les tableaux dont nous parlons n'ont pas grand-chose voir avec ceux que vous connaissez ! En programmation, un tableau n'est rien d'autre qu'une variable un peu particulire ... nous allons pouvoir lui affecter plusieurs valeurs, ranges de faon squentielle, que nous pourrons appeler grce un indice, ou un compteur, si vous prfrez. Il nous suffira de donner l'emplacement du contenu dans notre variable tableau pour la sortir, travailler avec ou encore l'afficher. Assez bavard : mettons-nous joyeusement au travail !
Dclarer et initialiser un tableau

Je viens de vous expliquer, grosso-modo, ce qu'est un tableau en programmation. Si maintenant, je vous disais qu'il y a autant de types de tableaux que de types de variables ? Je crois voir quelques gouttes de sueur perler sur vos fronts... Pas de panique ! Je dirais mme que c'est trs logique. Comme nous l'avons vu lors du 3 chapitre, une variable d'un type donn ne peut contenir que des lments de ce type. Exemple : une variable de type int ne peut pas recevoir une chane de caractres. Il en est de mme pour les tableaux... un tableau d'entiers ne pourra pas recevoir des chanes de caractres, et vice versa. V oyons tout de suite comment se dclare un tableau : <type du tableau> <nom du tableau> [] = { <contenu du tableau>}; La dclaration ressemble beaucoup celle d'un argument de classe quelconque, si ce n'est la prsence des crochets [] aprs le nom de notre tableau, et les accolades {} encadrant l'initialisation de celui-ci. Dans la pratique, a nous donnerait quelque chose comme ceci :
Pour un tableau d'entiers

Code : Java int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
Pour un tableau de double

Code : Java double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
Pour un tableau de caractres

Code : Java char tableauCaractere[] = {'a','b','c','d','e','f','g'};
Pour un tableau de chanes de caractres

Code : Java String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};
www.siteduzero.com
65/669
V ous remarquez bien que la dclaration et l'initialisation d'un tableau se font comme pour une variable normale (si on peut dire qu'une variable est normale...). Nous utilisons des ' ' pour initialiser un tableau de caractres, des " " pour initialiser un tableau de String, etc. V ous pouvez aussi dclarer un tableau vide !
Attention, votre tableau sera vide mais, il
doit avoir un nombre de cases dfini !
Par exemple, si vous voulez un tableau vide de six entiers : Code : Java int tableauEntier[] = new int[6]; //ou encore int[] tableauEntier2 = new int[6];
Cette opration est trs simple, car vraiment ressemblante ce que vous faisiez avec vos variables ; je vous propose donc tout de suite de voir une belle variante de ceci : les tableaux multi-dimensionnels .
Les tableaux multi-dimensionnels

Ici, les choses se compliquent un peu. Car un tableau multi-dimensionnel n'est rien d'autre qu'un tableau ayant comme contenu au minimum 2 tableaux... Je me doute bien que cette notion doit en effrayer plus d'un, mais en ralit, elle n'est pas si difficile que a. Comme tout ce que je vous apprends en gnral ! Ben oui... Si j'y arrive, vous aussi vous pouvez y arriver ! Alors, on se lance ? GO ! Je ne vais pas vous faire de grand laus sur ce type de tableau, puisque je pense sincrement qu'un exemple vous fera beaucoup mieux comprendre le concept. Imaginez un tableau avec deux lignes : la premire contiendra les premiers nombres pairs, et le deuxime contiendra les premiers nombres impairs. Ce tableau s'appellera premiersNombres. V oil ce que cela donnerait : Code : Java int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }; Nous voyons bien ici les deux lignes de notre tableau symbolises par les doubles crochets [][]. Et comme je l'ai dit plus haut, ce genre de tableau n'est rien d'autre que plusieurs tableaux en un. Ainsi, pour passer d'une ligne l'autre, nous jouerons avec la valeur du premier crochet. Exemple : premiersNombres[0][0] correspondra au premier lment de la colonne paire. Et premiersNombres[1][0] correspondra au premier lment de la colonne impaire. Allez ! Un petit schma en guise de synthse :
www.siteduzero.com
66/669
Surtout, n'oubliez pas de sparer vos diffrents tableaux par une ', ' et de bien mettre le tout entre accolades. Sinon, c'est le plantage assur, et de toutes faons, Eclipse n'en voudra pas.
Je pense que vous savez tout ce qu'il y a savoir sur les tableaux. Maintenant, je vous propose de faire un peu mumuse avec...
Utiliser et rechercher dans un tableau !

Un tableau simple Avant d'attaquer, je dois vous dire un truc primordial (vous avez remarqu, c'est crit en gros et en rouge).
Un tableau, comme ceux que nous avons fait ci-dessus, dbute toujours l'indice 0 !
Je m'explique : prenons l'exemple du tableau de caractres. Si vous voulez afficher la lettre 'a' l'cran, vous devrez taper cette ligne de code : Code : Java System.out.println(tableauCaractere[0]);
Ce qui signifie tout btement qu'un tableau, ayant 4 lments dans son contenu, aura comme entres possibles 0, 1, 2 ou 3 . Le 0 correspond au premier lment, le 1 correspond au 2 lment, le 2 correspond au 3 lment, et le 3 correspond au 4 lment. Une trs grande partie des erreurs sur les tableaux sont souvent dues un mauvais indice dans celui-ci. Donc : prenez garde...
Ce que je vous propose, c'est tout bonnement d'afficher un des tableaux ci-dessus dans son intgralit. Et le premier qui me met ce code-l : Code : Java char tableauCaractere[] = {'a','b','c','d','e','f','g'}; System.out.println(tableauCaractere[0]); System.out.println(tableauCaractere[1]); System.out.println(tableauCaractere[2]); System.out.println(tableauCaractere[3]);
... je l'ASSASSINE ! Peut-tre pas, quand mme... Il y a une manire beaucoup plus classe, ou distingue, mais surtout beaucoup plus pratique d'afficher le contenu d'un tableau.
Voici un parcours de tableau avec une boucle while

Code : Java char tableauCaractere[] = {'a','b','c','d','e','f','g'}; int i = 0; while (i < 4) { System.out.println("A l'emplacement " + i +" du tableau nous avons = " +tableauCaractere[i]); i++; }
Mme rsultat que prcdemment, mais avec une boucle for ( utiliser de prfrence)
Code : Java
www.siteduzero.com

char tableauCaractere[] = {'a','b','c','d','e','f','g'}; for(int i = 0; i < 4; i++) { System.out.println("A l'emplacement " + i +" du tableau nous avons = " +tableauCaractere[i]); }
67/669
Euh... Comment fait-on si on ne connat pas la taille de notre tableau l'avance ?
Dcidment, vous lisez dans mes penses... J'allais y venir ! En fait, il existe une instruction qui retourne la taille d'un tableau. Il s'agit de l'instruction <mon tableau>.length. Notre boucle for pourrait donc ressembler ceci : Code : Java char tableauCaractere[] = {'a','b','c','d','e','f','g'}; for(int i = 0; i < tableauCaractere.length; i++) { System.out.println("A l'emplacement " + i +" du tableau nous avons = " +tableauCaractere[i]); }
Alors ? Ce n'est pas mieux comme a ? D'accord, je reformule ma phrase pour ceux qui ont le sens de la contradiction. C'est mieux comme a ! Je vais vous donner une preuve que vous ne pourrez pas nier. Essayez de faire une recherche dans un des tableaux ci-dessus (pas celui contenant des String, nous verrons ce cas dans le prochain chapitre). En gros : faites une saisie clavier, et regardez si celle-ci existe dans votre tableau... Dur, dur, sans boucle... COMMENT A, C'EST DUR, MME AVEC UNE BOUCLE ? Dans ce cas, je vais vous aider. Gardez la mme structure de code permettant de faire plusieurs fois la mme action, et ensuite faites une boucle de recherche incluant la saisie clavier, un message si la saisie est trouve dans le tableau, et un autre message si celle-ci n'est pas trouve. Ce qui nous donne : Code : Java char tableauCaractere[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}; int i = 0, emplacement = 0; char reponse = ' ',carac = ' '; Scanner sc = new Scanner(System.in); do {//boucle principale do {//on rpte cette boucle tant que l'utilisateur n'a pas rentr une lettre figurant dans le tableau i = 0; System.out.println("Rentrez une lettre en minuscule, SVP "); carac = sc.nextLine().charAt(0); while(i < tableauCaractere.length && carac != tableauCaractere[i])//boucle de recherche dans le tableau i++; if (i < tableauCaractere.length)//Si i < 7 c'est que la boucle n'a pas dpass le nombre de cas du tableau ==> il a trouv System.out.println(" La lettre " +carac+ " se trouve bien dans le tableau !");
www.siteduzero.com

else//sinon System.out.println(" La lettre " +carac+ " ne se trouve pas dans le tableau !"); }while(i >= tableauCaractere.length);//tant que la lettre de l'utilisateur ne correspond pas une lettre du tableau do{ System.out.println("Voulez-vous essayer de nouveau ? reponse = sc.nextLine().charAt(0); }while(reponse != 'N' && reponse != 'O'); }while (reponse == 'O'); System.out.println("Au revoir !..");
68/669
(O/N)");
Ce qui nous donne :
Explicitons un peu ce code, et plus particulirement la recherche

Dans notre while, il y a deux conditions : ==> la premire correspond au compteur. Tant que ce compteur est infrieur ou gal au nombre d'lments du tableau, on incrmente notre compteur pour regarder la valeur suivante. Nous passons ainsi en revue tout ce qui se trouve dans notre tableau. MAIS si nous n'avions mis que cette condition, la boucle n'aurait fait que parcourir le tableau, sans voir si le caractre saisi correspond bien un caractre de notre tableau, d'o la deuxime condition. ==> la deuxime correspond la comparaison entre le caractre saisi et la recherche dans le tableau. Grce ceci, si le caractre saisi se trouve dans le tableau, la boucle prend fin, et donc i a une valeur infrieure 7. ce stade, notre recherche est termine. Ensuite, les conditions coulent de source ! Si nous avons trouv une correspondance entre le caractre saisi et notre tableau, i aura une valeur infrieure 7 (je vous rappelle qu'il n'y a que 6 entres dans notre tableau, puisque nous avons 7 lettres dans celui-ci, et la premire entre a comme indice 0). Dans ce cas, nous affichons un message positif. Et dans le cas contraire, c'est l'instruction du else qui s'excutera.
www.siteduzero.com
69/669
V ous avez d remarquer la prsence d'un i = 0; dans une boucle. Ceci est PRIMORDIAL, car sinon, lorsque vous reviendrez au dbut de celle-ci, i ne vaudra plus 0, mais la dernire valeur qu'il aura eue, aprs les diffrentes incrmentations. Si vous faites une nouvelle recherche, vous commencerez par l'indice contenu dans i ; ce que vous ne voulez pas, puisque vous voulez regarder depuis le dbut du tableau, donc 0.
Pour bien vous rendre compte de cela, essayez le programme ci-dessus sans cette instruction : vous verrez qu'il n'y a plus de recherche possible, ou mme un gros plantage d'Eclipse... En travaillant avec les tableaux, vous serez confronts, un jour ou l'autre, au message suivant : java.lang.ArrayIndexOutOfBoundsException. Ceci signifie qu'une exception a t leve car vous avez essay de lire (ou d'crire dans) une case qui n'a pas t dfinie dans votre tableau ! Nous verrons les exceptions lorsque nous aborderons la programmation orient objet.
Exemple
Code : Java String[] str = new String[10]; //L'instruction suivante va dclencher une exception //car vous essayez d'crire la case 11 de votre tableau alors que celui-ci n'en contient que 10 str[11] = "Une exception"; //De mme, le code ci-dessous dclenchera la mme exception car vous essayez de lire //une case non dfinie ! String string = str[24];
Faites donc bien attention cela, car il s'agit de l'une des erreurs commises les plus frquentes.
Un tableau multi-dimensionnel
Nous allons travailler sur le tableau bi-dimensionnel vu plus haut. Le principe est vraiment le mme que pour un tableau simple. Mais ici, il n'y a que deux compteurs. V oici un code possible pour afficher les donnes par ligne, c'est--dire l'intgralit du sous-tableau nombres pairs, puis le sous-tableau nombres impairs :
Avec une boucle while

Code : Java int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }, i = 0, j = 0; while (i < 2) { j = 0; while(j < 5) { System.out.print(premiersNombres[i][j]); j++; } System.out.println(""); i++; }
www.siteduzero.com
70/669
Et voil le rsultat :
Je suppose que vous avez remarqu la drle de dclaration de variable... V ous avez le droit de faire ainsi. Mais seules les variables ayant les crochets [] aprs leur nom seront considres comme des tableaux, les autres resteront des variables toutes simples.
Dtaillons un peu ce code

Dans un premier temps, on initialise les variables. On entre ensuite dans la premire boucle (qui se fera deux fois, donc i vaut 0 la premire fois, et vaudra 1 pendant la deuxime), et on initialise j 0. On entre ensuite dans la deuxime boucle, o j vaudra successivement 0, 1, 2, 3 et 4 pour afficher le contenu du tableau d'indice 0 (notre premier i). On sort de cette boucle ; notre i est ensuite incrment, et passe 1. On reprend le dbut de la premire boucle => initialisation de j 0. On rentre dans la deuxime boucle, o le processus est le mme que prcdemment (mais l, i vaut 1). Enfin, nous sortons des boucles pour finir le programme.
Ce code affiche donc le contenu des deux tableaux... Encore heureux ! Notez bien que vous devez rinitialiser votre compteur j avant la boucle o il est utilis comme argument, sinon celle-ci ne fonctionnera pas. Et cela, pour la mme raison que pour un tableau normal.
Le mme rsultat avec une boucle for

Code : Java int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }; for(int i = 0; i < 2; i++) { for(int j = 0; j < 5; j++) { System.out.print(premiersNombres[i][j]); } System.out.println("");
En bonus, voici un petit code qui va vous afficher la suite des nombres dans l'ordre, en piochant tantt dans le tableau pair, tantt dans le tableau impair : Code : Java
www.siteduzero.com
71/669
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }; for(int i = 0; i < 5; i++) { for(int j = 0; j < 2; j++) { System.out.print(premiersNombres[j][i]); } }
Et voil :
V ous avez remarqu que la diffrence entre ces deux codes tait seulement l'ordre des conditions dans nos boucles... Tu ne nous avais pas parl d'une faon de faire une boucle for ?
Tout fait, d'ailleurs la voici : Code : Java String tab[] = {"toto", "titi", "tutu", "tete", "tata"}; for(String str : tab) System.out.println(str);
V oici le rsultat :
Faites bien attention ne pas confondre les deux syntaxes ! La boucle for, ancienne gnration, prend des instructions, alors que la nouvelle version prend un .
; dans ses
Comme je vous l'avais dit lorsque vous avez vu " Les boucles", cette syntaxe se rapproche de la boucle foreach prsente dans d'autre langages. Cette syntaxe signifie qu' chaque tour de boucle, la valeur courante du tableau est mise dans la variable str.
www.siteduzero.com
72/669
Il faut IMPRATIVEMENT que la variable passe en premier paramtre de la boucle for soit de mme type que la valeur de retour du tableau (une variable de type String pour un tableau de String, un int pour un tableau d'int...) Pour vrifier que les valeurs retournes par la boucle correspondent bien leurs indices, vous pouvez dclarer un entier (i, par exemple) initialis 0 et incrment la fin de la boucle. Allez, c'est mon jour de bont : Code : Java String tab[] = {"toto", "titi", "tutu", "tete", "tata"}; int i = 0; for(String str : tab) { System.out.println("La valeur de la nouvelle boucle est : " + str); System.out.println("La valeur du tableau l'indice " + i +" est : " + tab[i] + "\n"); i++; }
Ce qui nous donne :
Alors ? Convaincus ? V ous pouvez voir que cette forme de boucle for est particulirement adapte au parcours de tableau ! D'accord, a a l'air bien comme mthode, mais pour les tableaux deux dimensions ?
Mme si vous devriez trouver la rponse tout seuls, je vais tout de mme vous la donner ! Je vous ai dit que la variable en premier paramtre devait tre du mme type que la valeur de retour du tableau. Dans le cas qui nous intresse, que va retourner l'instruction de la boucle for si on utilise un tableau deux dimensions ? Un tableau. Nous devrons donc mettre un tableau, du mme type que notre tableau dimensions, en premire instruction de la boucle, et donc faire une deuxime boucle afin de parcourir le rsultat obtenu ! V oici un code qui permet d'afficher un tableau deux dimensions de faon conventionnelle et selon la nouvelle version du JDK 1.5 :
www.siteduzero.com

Code : Java String tab[][] = {{"toto", "titi", "tutu", "tete", "tata"}, {"1", "2", "3", "4"}}; int i = 0, j = 0; for(String sousTab[] : tab) { i = 0; for(String str : sousTab) { System.out.println("La valeur de la nouvelle boucle est : " + str); System.out.println("La valeur du tableau l'indice [" + j + "][" +i +"] est : " + tab[j][i] + "\n"); i++; } j++; }
73/669
Ce qui nous donne :
V ous pouvez donc voir que nous rcuprons un tableau au parcours de la premire boucle et que nous parcourons ce mme tableau afin de rcuprer les valeurs de celui-ci dans la deuxime. Simple, non ? En tout cas, je prfre nettement cette syntaxe ! Aprs, c'est vous de voir...
www.siteduzero.com

V ous tes maintenant pars pour utiliser les tableaux quels qu'ils soient ! Donc, sans plus attendre, je vous propose un petit QCM de derrire les fagots ! Encore un chapitre bien dodu, mais je vois que vous vous en sortez comme des pros !
74/669
Le chapitre suivant sera l'un des plus fournis en informations ; donc, si vous sentez un peu de fatigue, reposez-vous un peu avant d'attaquer les mthodes de classe.
www.siteduzero.com
75/669
Les mthodes de classe

Ce chapitre aura pour but de vous faire dcouvrir ce qu'on appelle, en Java, des mthodes de classe (fonctions en C/C++), de base et trs utiles. Java est un langage 100 % objet. Ceci signifie que tout ce qui fait partie du langage est objet ! Nous approfondirons cette notion lorsque nous ferons de la POO (Programmation Orient Objet). Pour le moment, retenez juste que, dans chaque objet, il y a des mthodes qui font des traitements spcifiques. Il s'agit tout bonnement d'une portion de code rutilisable ! C'est ce que nous allons aborder ici. Mais ce chapitre ne serait pas drle si nous ne nous amusions pas en crer une ou deux pour le plaisir... Et l, vous aurez beaucoup de choses retenir...
Quelques mthodes bien utiles !

V oici le moment de vous prsenter quelques mthodes dont, j'en suis convaincu, vous ne pourrez plus vous passer... toLowerCase() Cette mthode permet de transformer toute saisie clavier de type caractre en minuscules. Elle n'a aucun effet sur les nombres, puisqu'ils ne sont pas assujettis cette contrainte. V ous pouvez donc utiliser cette fonction sur une chane de caractres comportant des nombres. Elle s'utilise comme ceci : Code : Java String chaine = new String("COUCOU TOUT LE MONDE !"), chaine2 = new String(); chaine2 = chaine.toLowerCase();//donne "coucou tout le monde !"
toUpperCase() Celle-l est facile, puisqu'il s'agit de l'oppose de la prcdente. Elle transforme donc une chane de caractres en majuscules. Et s'utilise comme suit : Code : Java String chaine = new String("coucou coucou"), chaine2 = new String(); chaine2 = chaine.toUpperCase();//donne "COUCOU COUCOU"
concat() Trs explicite, celle-l permet de concatner deux chanes de caractres. Code : Java String str1 = new String("Coucou "), str2 = new String("toi !"), str3 = new String(); str3 = str1.concat(str2);//donne "Coucou toi !"
length() Celle-l permet de donner la longueur d'une chane de caractres (en comptant les espaces blancs). Code : Java
www.siteduzero.com

String chaine = new String("coucou ! "); int longueur = 0; longueur = chaine.length();//donne 9
76/669
equals() Permet de voir si deux chanes de caractres sont identiques. Donc, de faire des tests. C'est avec cette fonction que vous ferez vos tests de conditions, lorsqu'il y aura des String. Exemple concret : Code : Java String str1 = new String("coucou"), str2 = new String("toutou"); if (str1.equals(str2))//Si les deux chanes sont identiques System.out.println("Les deux chaines sont identiques !"); else System.out.println("Les deux chanes sont diffrentes !");
V ous pouvez aussi demander la non vrification de l'galit... Grce l'oprateur de ngation... vous vous en souvenez ? Il s'agit de '!' Ce qui nous donne : Code : Java String str1 = new String("coucou"), str2 = new String("toutou"); if (!str1.equals(str2))//Si les deux chanes sont diffrentes System.out.println("Les deux chaines sont diffrentes !"); else System.out.println("Les deux chanes sont identiques !");
Le principe de ce genre de condition fonctionne de la mme faon pour les boucles. Et dans l'absolu, cette fonction retourne un boolen. C'est pourquoi nous pouvons utiliser cette fonction dans les tests de condition. Code : Java String str1 = new String("coucou"), str2 = new String("toutou"); boolean Bok = str1.equals(str2);//ici Bok prendra la valeur false
charAt() Le rsultat de cette mthode sera un caractre, car il s'agit d'une mthode d'extraction de caractres, je dirais mme d'UN caractre. Elle ne peut s'oprer que sur des String! Elle possde la mme particularit que les tableaux, c'est--dire que, pour cette mthode, le premier caractre sera le numro 0. Cette mthode prend un entier comme argument. Code : Java String nbre = new String("1234567"); char carac = ' '; carac = nbre.charAt(4);//renverra ici le caractre 5
www.siteduzero.com
77/669
substring() Comme son nom l'indique, elle permet d'extraire une sous-chane de caractres d'une chane de caractres. Cette mthode prend 2 entiers comme arguments. Le premier dfinit le dbut de la sous-chane extraire inclus , le deuxime correspond au dernier caractre extraire exclus . Et le premier caractre est aussi le numro 0. Code : Java String chaine = new String("la paix niche"), chaine2 = new String(); chaine2 = chaine.substring(3,13);//permet d'extraire "paix niche"
indexOf()/lastIndexOf() indexOf() permet d'explorer une chane de caractres depuis son dbut. lastIndexOf() depuis sa fin, mais renvoie l'index depuis le dbut de la chaine. Elle prend un caractre, ou une chane de caractres comme argument, et renvoie un int. Tout comme charAt() et substring(), le premier caractre est la place 0. Je crois qu'ici un exemple s'impose, plus encore que pour les autres fonctions : Code : Java String mot = new String("anticonstitutionnellement"); int n = 0; n n n n n = = = = = mot.indexOf('t'); // n vaut 2 mot.lastIndexOf('t'); // n vaut 24 mot.indexOf("ti"); // n vaut 2 mot.lastIndexOf("ti"); // n vaut 12 mot.indexOf('x'); // n vaut -1
Des mthodes concernant les mathmatiques

Ces mthodes utilisent la classe Math, prsente dans java.lang. Cette classe fait donc partie des fondements du langage et, par consquent, aucun import particulier n'est ncessaire pour utiliser la classe Math.
random()
Cette mthode permet de gnrer un nombre alatoire, entre 0 et 1 (elle renvoie donc un double). V ous ne voyez pas l'utilit ? Eh bien... V ous vous en rendrez compte lors de notre prochain TP... Code : Java double X = 0.0; X = Math.random();//donne un nombre comme 0.0001385746329371058
Sinus, cosinus, tangente

Code : Java double sin = Math.sin(120); double cos = Math.cos(120); double tan = Math.tan(120);
www.siteduzero.com
78/669
Ces mthodes retournent un nombre de type double.
Valeur absolue
Code : Java double abs = Math.abs(-120.25);
Exposant
Code : Java double d = 2; double exp = Math.pow(d, 2); //Ici on initialise la variable exp avec la valeur de d leve au carr //La mthode pow() prend donc une valeur en premier paramtre //et un exposant en second
Je ne vais pas vous faire un rcapitulatif de toutes les mthodes prsentes dans Java, sinon, dans 1000 ans, je serais encore derrire mon clavier... Toutes ces mthodes sont trs utiles, croyez-moi. Mais les plus utiles sont encore celles que nous faisons ! C'est tellement mieux quand a vient de nous...
Crer et utiliser sa propre mthode !

Reprenons la mthode que je vous avais donne lors du premier TP. Pour mmoire : Code : Java public static double arrondi(double A, int B) { return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B); }
Dcortiquons un peu ceci

Tout d' abord, il y a le mot cl public. C'est ce qui dfinit la porte de la mthode. Nous y reviendrons lorsque nous programmerons des objets. Ensuite il y a static. Nous y reviendrons aussi. Juste aprs, nous voyons double. Il s'agit du type de retour de la mthode. Pour faire simple, ici, notre mthode va renvoyer un double ! Il y a ensuite le nom de la mthode. C'est avec ce nom que nous l'appellerons. Puis, il y a les arguments que la mthode prend. C'est en fait les paramtres dont la mthode a besoin pour travailler. Ici, nous demandons d'arrondir le double A avec B chiffres derrire la virgule ! Et vous pouvez voir, l'intrieur de la mthode, une instruction return. C'est cette instruction qui effectue le renvoi de la valeur, ici, un double.
Dans ce chapitre, nous allons voir les diffrents types de renvois ainsi que les paramtres qu'une mthode peut prendre. V ous devez savoir deux choses concernant les mthodes :
www.siteduzero.com
79/669
elles ne sont pas limites en nombre de paramtres il y a trois grands types de mthodes : les mthodes qui ne renvoient rien. Elles sont de type void. Ces types de mthodes n'ont pas d'instruction return ! les mthodes qui retournent des types primitifs (double, int...). Elles sont de type double, int, char... Celles-ci ont une instruction return. des mthodes qui retournent des objets. Par exemple, une mthode qui retourne un objet de type String . Celles-ci aussi ont une instruction return.
Pour le moment, nous ne faisions que des programmes comportant une classe. Celle-ci ne comportant qu'une mthode : la mthode main. Le moment est donc venu de crer vos propres mthodes. Que vous ayez utilis la mthode arrondi dans votre TP ou non, vous avez du voir que celle-ci se place l'extrieur de la mthode main, mais dans votre classe ! Pour rappel, voici le screen qu'il y avait dans le TP 1 :
Si vous placez une de vos mthodes l'intrieur de la mthode main ou l'extrieur de votre classe : LE PROGRAMME NE COMPILERA PAS ! !
Bon, d'accord ! C'est enregistr. Mais concrtement... quoi vont nous servir ces mthodes ?
Dites-vous bien qu'un dveloppeur est de nature assez feignante... Sans dconner. Il s'est vite aperu qu'il y avait du code redondant dans ses programmes... Des morceaux de code qui faisaient toujours la mme chose et qui n'avaient, comme seule diffrence, la (ou les) variable(s) qu'ils traitaient. Vu que nous venons de voir les tableaux, nous allons donc faire des mthodes concernant ces derniers ! V ous devez certainement vous rappeler de la faon de parcourir un tableau... Et si nous faisions une mthode qui permette d'afficher le contenu d'un tableau sans que nous soyons obligs de retaper la portion de code contenant la boucle ? Je me doute que vous n'en voyez pas l'intrt maintenant car, mis part les plus courageux d'entre vous, vous n'avez fait qu'un ou deux tableaux de votre main lors de la partie prcdente. Et si je vous demande de dclarer 22 tableaux, si je vous dis : "Allez, bande de ZrOs ! Parcourez-moi tout a !" V ous n'allez tout de mme pas faire 22 boucles for ! De toute faon, je vous l'interdis ! Nous allons faire une mthode. Celle-ci va :
www.siteduzero.com

prendre notre tableau en paramtre (ben oui... c'est lui que nous voulons parcourir), parcourir notre tableau notre place, faire tous les System.out.println(), ne rien renvoyer.
80/669
Avec ce que nous avons dfini, nous savons donc que notre mthode sera de type void, qu'elle prendra un tableau en paramtre (pour le moment, on travaillera avec des tableaux de String ) et le contenu vous vous doutez de ce que a va tre... Une boucle. Cette fameuse boucle que nous ne serons plus obligs de rpter autant de fois que de tableaux de String ! Ce qui va nous donner : Code : Java static void parcourirTableau(String[] tab) { for(String str : tab) System.out.println(str); }
Et voici un exemple de code entier : Code : Java public class Sdz1 { public static void main(String[] args) { String[] tab = {"toto", "tata", "titi", "tete"}; parcourirTableau(tab); } static void parcourirTableau(String[] tabBis) { for(String str : tabBis) System.out.println(str); }
Je sais que a vous trouble encore, mais sachez que les mthodes ajoutes dans la classe main doivent tre dclares static ! Fin du mystre lors de la programmation oriente objet !
Bon. V ous voyez que la mthode parcourt le tableau pass en paramtre. Si vous crez plusieurs tableaux et appelez la mthode avec ces derniers, vous vous apercevrez que la mthode affiche le contenu de chaque tableau ! V oici une mthode au mme effet que la mthode parcourirTableau, la diffrence que celle-ci retourne une valeur. Ici, une chane de caractres ! Code : Java static String toString(String[] tab) { System.out.println("Mthode toString() ! ! !\n--------------------------"); String retour = ""; for(String str : tab) retour += str + "\n";
www.siteduzero.com

return retour;
81/669
Et voici un code complet : Code : Java public class Sdz1 { public static void main(String[] args) { String[] tab = {"toto", "tata", "titi", "tete"}; parcourirTableau(tab); System.out.println(toString(tab)); } static void parcourirTableau(String[] tab) { for(String str : tab) System.out.println(str); } static String toString(String[] tab) { System.out.println("Mthode toString() ! ! !\n--------------------------"); String retour = ""; for(String str : tab) retour += str + "\n"; } } return retour;
V ous voyez que la deuxime mthode retourne une chane de caractres que nous devons afficher l'aide de l'instruction System.out.println(). Nous affichons la valeur renvoye par la mthode toString(). Alors que la mthode parcourirTableau, elle, crit au fur et mesure le contenu du tableau dans la console ! Notez que j'ai ajout une ligne d'criture dans la console dans la mthode toString() afin de vous montrer o tait appele cette dernire. L'instruction System.out.println() est trs pratique pour dboguer vos programmes ! Dans une mthode, l'utilisation de cette instruction peut faire ressortir des erreurs de conception ou de dveloppement !
Il nous reste un point important aborder. Imaginez un instant que vous ayez plusieurs types d'lments parcourir ! Des tableaux une dimension, mais aussi d'autres deux dimensions, et mme des objets comme des ArrayList (nous les verrons, ne vous inquitez pas...). Sans aller si loin. V ous n'allez pas donner un nom diffrent la mthode parcourirTableau chaque type primitif ! V ous avez d remarquer que la mthode que nous avons cre ne prend qu'un tableau de String en paramtre ! Pas de tableau d'int ni de long . Si seulement nous pouvions utiliser la mme mthode pour diffrents types de tableaux ! C'est l qu'entre en jeu ce qu'on appelle : la surcharge.
La surcharge de mthode
www.siteduzero.com

Grce ceci, vous n'aurez plus retenir 10 000 noms de mthodes qui font la mme chose !
82/669
Le principe
La surcharge de mthode consiste garder un nom de mthode (donc un type de traitement faire, pour nous, lister un tableau) et de changer la liste ou le type de ses paramtres. Dans le cas qui nous intresse, nous voulons que notre mthode parcourirTableau puisse parcourir n'importe quel type de tableau. Comment faire ?
Nous allons surcharger notre mthode afin qu'elle puisse travailler avec des int par exemple : Code : Java static void parcourirTableau(String[] tab) { for(String str : tab) System.out.println(str); } static void parcourirTableau(int[] tab) { for(int str : tab) System.out.println(str); }
Avec ces mthodes, vous pourrez parcourir de la mme manire : les tableaux d'entiers les tableaux de chanes de caractres.
Mais vous pouvez aussi faire de mme avec les tableaux 2 dimensions. V oici quoi pourrait ressembler son code (je ne rappelle pas le code des deux mthodes ci-dessus) : Code : Java static void parcourirTableau(String[][] tab) { for(String tab2[] : tab) { for(String str : tab2) System.out.println(str); } }
La surcharge de mthode fonctionne aussi en ajoutant des paramtres la mthode. Cette mthode est donc valide : Code : Java static void parcourirTableau(String[][] tab, int i) { for(String tab2[] : tab) { for(String str : tab2)
www.siteduzero.com

} System.out.println(str);
83/669
Bon d'accord, nous ne nous servons pas de la variable i, mais c'tait un exemple. Comme a, vous avez vu les cas de surcharge de mthode !
Ce qu'il faut retenir de ce chapitre

Les mthodes se dfinissent dans une classe. Les mthodes ne peuvent pas tre imbriques . Elles sont dclares les unes aprs les autres . Les mthodes peuvent tre surcharges, en changeant le type de paramtres que celle-ci attend, le nombre de ses paramtres ou les deux ! Pour Java, le fait de surcharger une mthode lui indique qu'il s'agit de 2, 3 ou X mthodes diffrentes, car les paramtres d'appel sont diffrents . Par consquent, Java ne se trompe jamais d'appel de mthode, puisqu'il se base sur les paramtres passs .
Je crois que vous tes prts pour un petit QCM des familles ! J'espre que vous aurez appris beaucoup de choses dans ce chapitre. En tout cas, je sais que vous en aurez besoin, et pas plus tard que pour la partie suivante ! Prts pour la programmation oriente objet ? Here we go ! J'ose esprer que vous avez apprci ce tuto sur les bases du langage Java ! En tout cas, je me suis bien amus en le faisant. Maintenant, nous allons rentrer dans les mandres de la programmation oriente objet ! Alors ?... Toujours prts ?
www.siteduzero.com
Partie 2 : Java Orient Objet
84/669

Dans cette partie, nous allons aborder la programmation oriente objet. Concept de programmation extrmement puissant et pratique. En effet, vous verrez qu'avec ce type de programmation, vous pourrez crer, utiliser, recrer divers objets et les utiliser dans un but que vous seuls aurez dcid. J'aborderai ce que j'ai pu voir durant ma formation, et uniquement cela... Mais je vous rassure : il y a dj du travail...
Cette partie sera extrmement riche en concepts, vocabulaire et mthodologie. Entre autres, vous saurez programmer en orient objet, vous pourrez enregistrer vos objets dans des fichiers... J'ajouterai aussi quelques notions de modlisation. Ceci dans le but de vous familiariser avec la faon de schmatiser des objets et leurs interactions entre eux. Nous y reviendrons, mais il s'agira de diagrammes de classes utiliss avec le langage UML (Unified Modeling Language). Une longue introduction ne servirait rien... passons donc tout de suite la premire partie.
Les premiers pas en "Orient Objet"

Dans la premire partie de ce tuto sur la programmation en Java, nous avons travaill avec une seule classe. V ous allez voir et apprendre qu'en programmation oriente objet, nous travaillerons avec plusieurs classes : en fait, autant de classes que d'objets. Rappelez-vous de la premire partie : vous avez dj utilis des objets... Oui ! Lorsque vous faisiez ceci : Code : Java String str = new String("tiens... un objet String");
Ici str est un objet String . V ous avez cr un objet de la classe String : on dit que vous avez cr une instance de la classe String(). Nous savons cela grce l'oprateur new, qui s'utilise pour instancier une classe. L'objet String, instanci ci-dessus, a bien ses propres donnes : la chane de caractres "tiens... un objet String" . V ous devez savoir aussi que les variables de type String() (mais nous prfrerons parler d'objet partir de maintenant) ont des mthodes associes, comme subString(). Je vous sens quelque peu perplexes... mais nanmoins rassurs... Attaquons sans plus attendre !
Les classes
Une classe peut tre compare un moule, qui, lorsque nous le remplissons, nous donne un objet ayant la forme du moule, et toutes ses caractristiques. Comme quand vous tiez enfants, quand vous vous amusiez avec de la pte modeler. Si vous avez bien suivi la premire partie de ce tuto, vous devriez savoir que notre classe contenant la mthode main ressemble ceci : Code : Java class ClasseMain{ public static void main(String[] args){ //Vos donnes, variables, diffrents traitements.... }// fin de la mthodes main }//fin de votre classe
Crez cette classe et cette mthode main (vous savez faire, maintenant).
www.siteduzero.com
85/669
Puisque nous allons travailler en POO, nous allons devoir crer une seconde classe dans ce fameux projet ! Nous allons donc tout de suite crer une classe Ville. Dans un but de simplicit, j'ai pens que crer des objets Ville vous permettrait d'assimiler plus facilement le concept objet. Nous allons donc crer des objets Ville avant la fin de ce chapitre... Allez dans File / New / Class ou utilisez le raccourci dans la barre d'outils, comme ceci :
Nommez votre classe : Ville (convention de nommage ! !
). Mais cette fois vous ne devez pas crer la mthode main.
Il ne peut y avoir qu'une seule mthode main par projet ! Souvenez-vous que celle-ci est le point de dpart de votre programme ! Et un programme ne commence qu' un seul endroit ! Pour tre tout fait prcis, il peut exister plusieurs mthode main dans votre projet (oui, mme une par classe...) MAIS une seule sera considre comme le point de dpart de votre programme ! Au final, vous devriez avoir ceci :
V oil ! Maintenant vous avez votre classe, avec la mthode main, et votre classe Ville encore vide mais qui va bientt pouvoir crer des objets Ville. Un dernier mot cependant. Ici, notre classe ville est prcde du mot cl " public". V ous devez savoir que lorsque nous crons une classe comme nous l'avons fait, Eclipse nous facilite la tache en mettant ce mot cl. Nous verrons plus tard qu'il existe d'autres mots cl pour dfinir la porte d'une classe (nous y viendrons). Si nous enlevons ce mot cl, l'interprteur Java considrera, tacitement, votre classe comme public. Retenez que, par dfaut et sans instructions contraires, toutes les classes sont public ! C'est--dire ?
Nous verrons cela la fin du chapitre... Ds que nous aurons cr des objets ! Retenez que : Code : Java public class UneClasse{ }//fin de votre classe
www.siteduzero.com
86/669
et Code : Java class UneClasse{ }//fin de votre classe
Sont deux codes quivalents ! Ce mot-cl, public, vous l'avez dj rencontr lors du chapitre sur les mthodes. Mais lorsque public prcde une mthode, il s'agit d'un droit d'accs une mthode membre d'une classe... c'est--dire qu'avec le mot-cl public devant une mthode, celle-ci sera accessible par toutes les classes utilisant cette dernire. Bien entendu, nous aurons besoin de ce genre de mthode, mais nous aurons aussi besoin d'autres mthodes dont nous ne nous servirons que dans la classe o celle-ci sera cre... Dans ce cas de figure, nous utiliserons le mot cl private. Ce qui signifie que notre mthode ne pourra tre appele que dans la classe o elle a vu le jour ! Il en va de mme pour les variables. Nous allons voir, dans la deuxime sous-partie, que nous pouvons protger des variables grce au mot-cl private. Le principe sera le mme que pour les mthodes... Ces variables ne seront accessibles que dans la classe o elles seront nes...
Bon !... Toutes les conditions sont runies pour pouvoir commencer activement la programmation oriente objet ! Et si nous allions crer notre premire ville ?
Les constructeurs
Derrire ce mot un peu barbare, se cache une notion toute bte. Vu que notre objectif dans ce chapitre est de construire un objet Ville, il va falloir dfinir les donnes qu'on va lui attribuer. Nous dirons qu'un objet Ville a : un nom sous forme de chane de caractres, un nombre d'habitants sous la forme d'un entier, un pays apparent sous la forme d'une chane de caractres. Je suis bien d'accord ! Mais comment fait-on pour dire notre programme que notre objet a tout a ?
Tout simplement en mettant des variables (dites d'instances) dans notre classe. Celle-ci va contenir une variable dont le rle sera de stocker le nom, une autre stockera le nombre d'habitants et la dernire se chargera du pays ! V oil quoi ressemble notre classe Ville prsent : Code : Java public class Ville{ String nomVille; String nomPays; int nbreHabitant; }
Rappelez-vous que, par dfaut, les variables d'instances prsentes dans une classe sont public.
www.siteduzero.com

Pourquoi tu dis variables d'instances ?
87/669
Tout simplement parce que dans nos futures classes Java, qui dfiniront des objets, il y aura plusieurs types de variables dans celles-ci (nous approfondirons ceci dans ce chapitre). Pour le moment, sachez qu'il y a trois grands types de variables dans une classe objet : les variables d'instances : ce sont elles qui dfiniront les caractristiques de notre objet ; les variables de classes : celles-ci sont communes toutes les instances de votre classe ; les variables locales : ce sont des variables que nous utiliserons pour travailler dans notre objet.
Dans l'immdiat, nous allons travailler avec des variables d'instances afin de crer des objets diffrents. Il nous reste plus qu' crer notre premier objet mais pour ce faire, nous allons devoir crer ce qu'on appelle des constructeurs . Un constructeur est une mthode (ou mthode d'instance, vu qu'elle interagit avec une instance de votre classe) qui va se charger de crer un objet et, le cas chant, d'initialiser ses variables de classe ! Cette mthode a pour rle de dire la JVM de rserver de l'allocation mmoire pour notre futur objet et donc, par extension, d'en rserver pour toutes les variables d'instances et variables de classes de cette dernire ! Notre premier constructeur sera ce qu'on appelle communment un constructeur par dfaut. C'est--dire qu'il ne prendra aucun paramtre mais permettra tout de mme d'instancier un objet et vu que nous sommes perfectionnistes, nous allons initialiser nos variables d'instances. V oici votre premier constructeur : Code : Java public class Ville{ /** * Stocke le nom de notre ville */ String nomVille; /** * Stocke le nom du pays de notre ville */ String nomPays; /** * Stocke le nombre d'habitants de notre ville */ int nbreHabitant; /** * Constructeur par dfaut */ public Ville(){ System.out.println("Cration d'une ville !"); nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; } }
V ous avez remarqu que le constructeur est en fait une mthode qui n'a aucun type de retour (void, double...) et qui porte le mme nom que notre classe !
Ceci est une rgle immuable : le (les) constructeur(s) d'une classe doit (doivent) porter le mme nom que la classe !
Une classe peut avoir plusieurs constructeurs ?
www.siteduzero.com
88/669
Bien sr ! Il s'agit de la mme mthode, mais surcharge ! Dans notre premier constructeur nous n'avons pass aucun paramtre, mais nous allons bientt en mettre . V ous pouvez d'ores et dj crer une instance de ville. Mais tout d'abord, rappelez-vous qu'une instance d'objet se fait grce au mot-cl new. Comme lorsque vous crez une variable de type String. V ous avez srement dj d faire ce genre de dclaration : Code : Java String mot = new String();
Maintenant, vu que nous allons crer des objets Ville, nous allons procder comme pour les String. Vrifions que l'instanciation se fait bien. Allez dans votre classe contenant la mthode main et instancions un objet Ville. Je suppose que vous avez devin que le type de notre objet ne sera pas double, int ou long mais bien Ville ! Code : Java public class Sdz1{ public static void main(String[] args){ Ville ville = new Ville(); } }
Excutez ce code, et voil !
www.siteduzero.com
89/669
Flicitations ! V ous avez cr votre premier objet ! !
Je sais bien que, pour le moment, il ne sert rien... Mais vous devez passer par l afin de comprendre le principe de la POO. Maintenant, nous devons mettre des donnes dans notre objet, ceci afin de pouvoir commencer travailler... Le but final serait d'avoir une dclaration d'objet se faisant comme ceci : Code : Java Ville ville1 = new Ville("Marseille", 123456789, "France");
V ous avez remarqu qu'ici les paramtres sont renseigns : eh bien il suffit de faire une mthode qui rcupre ces paramtres, et initialise les variables de notre objet. Notre constructeur d'initialisation sera cr. V oici le constructeur de notre objet ville, celui qui permet d'avoir des objets avec des paramtres diffrents. Comme je suis sympa, voici toute la classe telle qu'elle est maintenant : Code : Java public class Ville { /** * Stocke le nom de notre ville */ String nomVille; /** * Stocke le nom du pays de notre ville */ String nomPays; /** * Stocke le nombre d'habitants de notre ville */ int nbreHabitant; /** * Constructeur par dfaut */ public Ville(){ System.out.println("Cration d'une ville !"); nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; } /** * Constructeur d'initialisation * @param pNom * Nom de la Ville * @param pNbre * Nombre d'habitants * @param pPays * Nom du pays */ public Ville(String pNom, int pNbre, String pPays) { System.out.println("Cration d'une ville avec des paramtres !");
www.siteduzero.com

paramtres !"); nomVille = pNom; nomPays = pPays; nbreHabitant = pNbre; } }
90/669
Dans ce cas, l'exemple de dclaration et d'initialisation d'un objet ville que je vous ai montr un peu plus haut fonctionne sans aucun souci ! MAIS il vous faudra respecter scrupuleusement l'ordre des paramtres passs lors de l'initialisation de votre objet, sinon, c'est l'erreur de compilation coup sr ! Ainsi : Code : Java Ville ville1 = new Ville("marseille", 123456789, "France");//l'ordre est respect => aucun souci Ville ville2 = new Ville(12456, "France", "Lille");//Erreur dans l'ordre des paramtres => erreur de compilation au final
Testez ce code dans votre mthode main : Code : Java Ville ville = new Ville(); Ville ville2 = new Ville("Marseille", 123456789, "France");
V oici le rsultat :
V ous venez de surcharger le constructeur !
Par contre, notre objet un gros dfaut... Les variables d'instances qui le caractrisent sont accessibles dans votre classe contenant votre main !
Ceci veut dire que vous pouvez modifier les attributs d'une classe directement. Testez ce code et vous verrez :
www.siteduzero.com

Code : Java public class Sdz1 { public static void main(String[] args) { Ville ville = new Ville(); System.out.println(ville.nomVille); ville.nomVille = "la tte toto ! ! ! !"; System.out.println(ville.nomVille); "France"); } } Ville ville2 = new Ville("Marseille", 123456789, ville2.nomPays = "La tte tutu ! ! ! ! "; System.out.println(ville2.nomPays);
91/669
Et le rsultat :
V ous voyez que nous pouvons accder aux variables d'instances en utilisant le " . ". Comme lorsque vous appelez la mthode subString() de l'objet String. C'est trs risqu et la plupart des programmeurs Java vous le diront. Pour la plupart des cas, nous allons contrler les modifications des variables de classe de manire ce qu'un code ne fasse pas n'importe quoi avec nos objets ! C'est pour cela que nous protgeons nos variables d'instances en les dclarant private. Comme ceci : Code : Java
www.siteduzero.com

public class Ville { /** * Stocke le nom de notre ville */ private String nomVille; /** * Stocke le nom du pays de notre ville */ private String nomPays; /** * Stocke le nombre d'habitants de notre ville */ private int nbreHabitant; /** * Constructeur par dfaut */ public Ville(){ System.out.println("Cration d'une ville !"); nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; } /** * Constructeur d'initialisation * @param pNom * Nom de la Ville * @param pNbre * Nombre d'habitants * @param pPays * Nom du pays */ public Ville(String pNom, int pNbre, String pPays) { System.out.println("Cration d'une ville avec des paramtres !"); nomVille = pNom; nomPays = pPays; nbreHabitant = pNbre; } }
92/669
Et, si vous n'avez pas effac les lignes de code o nous avons modifi les attributs de nos objets Ville, vous devez voir qu'Eclipse n'apprcie pas du tout que vous tentiez d'accder des variables de classe priv ! Ces attributs ne sont plus accessibles en dehors de la classe o ils sont dclars !
partir de maintenant, ce ne sera plus le programme instanciant une classe qui ira voir ou modifier les attributs de notre objet, mais notre objet qui renverra les informations (ou les modifiera) lorsque le programme lui demandera ! Bon... V ous avez fait le plus dur ! Si, si, je vous assure ! Maintenant, il va falloir se servir de ces objets... Eh oui ! Le but est tout de mme d'utiliser nos objets dans des programmes. Pour pouvoir accder aux donnes de nos objets, nous allons utiliser ce que l'on appelle des ACCESSEURS et pour modifier les donnes, on appelle a des MUTATEURS . Donc que dire, si ce n'est : " l'abordage, moussaillons ! "
Votre objet sait parler : accesseurs et mutateurs

Un accesseur est une mthode qui va nous permettre d'accder aux variables de nos objets en lecture et un mutateur, en criture !
www.siteduzero.com
93/669
Reprenons l o nous nous tions arrts. V ous avez une classe Ville qui cre vos objets. V ous avez une classe avec une mthode main, prte accueillir vos objets, et tout ce que vous voudrez en faire ! Mais voil... pas moyen de faire quelque chose de ces satans objets ! Eh bien... le calvaire est presque termin ! Grce aux accesseurs, vous pourrez afficher les variables de vos objets, et grce aux mutateurs, les modifier. V oil quoi ressemblent les accesseurs et les mutateurs : Code : Java public class Ville { /** * Stocke le nom de notre ville */ private String nomVille; /** * Stocke le nom du pays de notre ville */ private String nomPays; /** * Stocke le nombre d'habitants de notre ville */ private int nbreHabitant; /** * Constructeur par dfaut */ public Ville(){ System.out.println("Cration d'une ville !"); nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; } /** * Constructeur d'initialisation * @param pNom * Nom de la Ville * @param pNbre * Nombre d'habitants * @param pPays * Nom du pays */ public Ville(String pNom, int pNbre, String pPays) { System.out.println("Cration d'une ville avec des paramtres !"); nomVille = pNom; nomPays = pPays; nbreHabitant = pNbre; }
//*********************************************************************************** // ACCESSEURS
//*********************************************************************************** /** * Retourne le nom de la ville * @return le nom de la ville */ public String getNom()
www.siteduzero.com

{ } return nomVille;
94/669
/** * Retourne le nom du pays * @return le nom du pays */ public String getNomPays() { return nomPays; } /** * Retourne le nombre d'habitants * @return nombre d'habitants */ public int getNombreHabitant() { return nbreHabitant; }
* *
//**********************************************************************************
// MUTATEURS //**********************************************************************************
/** * Dfinit le nom de la ville * @param pNom * nom de la ville */ public void setNom(String pNom) { nomVille = pNom; } /** * Dfinit le nom du pays * @param pPays * nom du pays */ public void setNomPays(String pPays) { nomPays = pPays; } /** * Dfinit le nombre d'habitants * @param nbre * nombre d'habitants */ public void setNombreHabitant(int nbre) { nbreHabitant = nbre; } }
Nos accesseurs sont bien des mthodes, et elles sont public pour que vous puissiez y accder dans une autre classe que celle-ci (la classe main, par exemple.. ). Les accesseurs sont du mme type que la variable qu'ils doivent retourner. a semble logique, non ?
www.siteduzero.com
95/669
Les mutateurs sont, par contre, de type void. Ce mot cl signifie "rien" ; en effet, ces mthodes ne retournent aucune valeur, elles se contentent de les mettre jour. Je vous ai fait faire la diffrence entre accesseurs et mutateurs mais, gnralement, lorsqu'on parle d'accesseurs, ce terme englobe aussi les mutateurs. Autre chose : il s'agit ici d'une question de convention de nommage. Les accesseurs commencent par get et les mutateurs par set, comme vous pouvez le voir ici. On parle d'ailleurs de Getters et de Setters .
Essayez ce code dans votre mthode main : Code : Java Ville v = new Ville(); Ville v1 = new Ville("marseille", 123456, "france"); Ville v2 = new Ville("rio", 321654, "brsil"); System.out.println("\n v = "+v.getNom()+" ville de "+v.getNombreHabitant()+ " habitants se situant en "+v.getNomPays()); System.out.println(" v1 = "+v1.getNom()+" ville de "+v1.getNombreHabitant()+ " habitants se situant en "+v1.getNomPays()); System.out.println(" v2 = "+v2.getNom()+" ville de "+v2.getNombreHabitant()+ " habitants se situant en "+v2.getNomPays()+"\n\n"); /*Nous allons interchanger les Villes v1 et v2 tout a par l'intermdiaire d'un autre objet Ville */ Ville temp = new Ville(); temp = v1; v1 = v2; v2 = temp; System.out.println(" "+v1.getNombreHabitant()+ " "+v1.getNomPays()); System.out.println(" "+v2.getNombreHabitant()+ " "+v2.getNomPays()+"\n\n"); v1 = "+v1.getNom()+" ville de habitants se situant en v2 = "+v2.getNom()+" ville de habitants se situant en
/*nous allons maintenant interchanger leurs noms cette fois par le biais de leur accesseurs */ v1.setNom("Hong Kong"); v2.setNom("Djibouti"); System.out.println(" v1 = "+v1.getNom()+" ville de "+v1.getNombreHabitant()+ " habitants se situant en "+v1.getNomPays()); System.out.println(" v2 = "+v2.getNom()+" ville de "+v2.getNombreHabitant()+ " habitants se situant en "+v2.getNomPays()+"\n\n");
la compilation, vous devriez obtenir ceci :
www.siteduzero.com
96/669
V ous voyez bien que les constructeurs ont fonctionn, que les accesseurs tournent merveille, et que vous pouvez commencer travailler avec vos objets Ville. Mais la gymnastique des doigts effectuer pour afficher les caractristiques de nos objets... pfiou !... T'aurais pu faire plus simple ! Si seulement notre objet pouvait faire a tout seul... Il peut le faire ! Qu'est-ce qu'on attend ? Ben rien... on y va !
Travaillez avec votre objet : les mthodes

Bon, alors l... c'est une formalit ! V ous savez quasiment tout. Mais attends... tu vas nous reparler des mthodes, alors que tu ne fais que a depuis le dbut de ce chapitre ?
Eh bien oui ! Ceci fait partie de la mthodologie que l'on m'a enseigne en formation, mme si tout ce que nous avons fait depuis le dbut se rapporte aux mthodes, il faut diffrencier : les constructeurs => mthodes servant crer des objets les accesseurs => mthodes servant accder aux donnes de nos objets et les mthodes de classe => mthodes servant la gestion de nos objets. Les mthodes de classe vont vous permettre de grer, diter, afficher... faire tout ce que vous voudrez avec vos objets. Il ne vous reste plus qu' trouver des mthodes qui fassent quelque chose pour vos objets... Avec nos objets ville, nous sommes un peu limits en choix de mthodes... Mais nous pouvons tout de mme en faire une ou deux pour l'exemple : faire un systme de catgories de villes par rapport leur nombre d'habitants ( <1000 => A, <10 000 => B...). Ceci dtermin la construction ou la redfinition du nombre d'habitants, donc ajouter une variable d'instance de type char notre classe, appelons-la categorie. Penser ajouter le traitement aux bons endroits. faire une mthode de description de notre objet Ville une mthode pour comparer deux objets par rapport leur nombre d'habitants.
Nous voulons que la classe Ville gre la faon de dterminer la catgorie elle-mme et non que cette action puisse tre opre de l'extrieur. La mthode qui fera ceci sera donc dclare private.
Par contre, un problme va se poser ! V ous savez dj qu'en Java on appelle des mthodes grce notre variable qui nous sert de
www.siteduzero.com

rfrence, celle-ci suivie de l'oprateur " ", puis du nom de la dite mthode. Par exemple : Code : Java String str = new String("opizrgpinbzegip"); str = str.subString(0,4);
97/669
Comment fait-on rfrence aux donnes de notre objet dans notre classe ?
En fait, c'est tout simple ! Encore un mot cl retenir... Cette fois, il s'agit du mot-cl this. V oici tout d'abord le code de notre class Ville en entier, c'est--dire avec nos mthodes associes : Code : Java public class Ville { /** * Stocke le nom de notre ville */ private String nomVille; /** * Stocke le nom du pays de notre ville */ private String nomPays; /** * Stocke le nombre d'habitants de notre ville */ private int nbreHabitant; /** * Stocke le type de notre ville */ private char categorie; /** * Constructeur par dfaut */ public Ville(){ nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; this.setCategorie(); } /** * Constructeur d'initialisation * @param pNom * Nom de la Ville * @param pNbre * Nombre d'habitants * @param pPays * Nom du pays */ public Ville(String pNom, int pNbre, String pPays) { nomVille = pNom; nomPays = pPays; nbreHabitant = pNbre; this.setCategorie(); }
www.siteduzero.com
98/669
//*********************************************************************************** // ACCESSEURS
//*********************************************************************************** /** * Retourne le nom de la ville * @return le nom de la ville */ public String getNom() { return nomVille; } /** * Retourne le nom du pays * @return le nom du pays */ public String getNomPays() { return nomPays; } /** * Retourne le nombre d'habitants * @return nombre d'habitants */ public int getNombreHabitant() { return nbreHabitant; } /** * Retourne la catgorie de la ville * @return catgorie de la ville */ public char getCategorie() { return categorie; } * *
//**********************************************************************************
// MUTATEURS //**********************************************************************************
/** * Dfinit le nom de la ville * @param pNom * nom de la ville */ public void setNom(String pNom) { nomVille = pNom; } /** * Dfinit le nom du pays * @param pPays * nom du pays */ public void setNomPays(String pPays) { nomPays = pPays; } /** * Dfinit le nombre d'habitants * @param nbre
www.siteduzero.com

* nombre d'habitants */ public void setNombreHabitant(int nbre) { nbreHabitant = nbre; this.setCategorie(); }
99/669
//*********************************************************************************** // METHODES DE CLASSE //***********************************************************************************
/** * Dfinit la catgorie de la ville */ private void setCategorie() { int bornesSuperieures[] = {0, 1000, 10000, 100000, 500000, 1000000, 5000000 10000000}; char categories[] = {'?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
int i = 0; while (i < bornesSuperieures.length && this.nbreHabitant >= bornesSuperieures i++; this.categorie = categories[i]; } /** * Retourne la description de la ville * @return description ville */ public String decrisToi(){ return "\t"+this.nomVille+" est une ville de "+this.nomPays+", elle comporte : "+this.nbreHabitant+ " => elle est donc de catgorie : "+this.categorie; } /** * Retourne une chane de caractres selon le rsultat de la comparaison * @param v1 * objet Ville * @return comparaison de deux ville */ public String comparer(Ville v1){ String str = new String(); if (v1.getNombreHabitant() > this.nbreHabitant) str = v1.getNom()+" est une ville plus peuple que "+this.nomVille; else str = this.nomVille+" est une ville plus peuple que "+v1.getNom();
return str; } }
Pour simplifier, this fait rfrence l'objet courant !
www.siteduzero.com
100/669
Pour expliciter le fonctionnement du mot cl this, prenons l'exemple de la mthode comparer(Ville V1). La mthode va s'appeler comme suit : Code : Java Ville V = new Ville("lyon", 654, "france"); Ville V2 = new Ville("lille", 123, "france"); V.comparer(V2);
Dans cette mthode, nous voulons comparer les nombres d'habitants des deux objets ville. Pour accder la variable nbreHabitant de l'objet V2, il suffit d'utiliser la syntaxe V2.getNombreHabitant() ; nous ferons donc rfrence la proprit nbreHabitant de l'objet V2 . Mais l'objet V, lui, est l'objet appelant de cette mthode. Pour se servir de ses variables, on utilise alors this.nbreHabitant, ce qui a pour effet de faire appel la variable nbreHabitant de l'objet appelant la mthode comparer(Ville V). Explicitons un peu ces trois mthodes.
La mthode
setCategorie() Elle ne prend aucun paramtre, et ne renvoie rien : elle se contente de mettre jour la variable de classe categorie. Elle regarde, par rapport au nombre d'habitants de l'objet appelant, utilis grce au mot cl this, dans quelle tranche se trouve la ville en question. Selon le nombre d'habitants, le caractre renvoy changera. Nous l'appelons lorsque nous construisons un objet Ville avec ou sans paramtre, mais aussi lorsque nous redfinissons le nombre d'habitants : de cette manire, la catgorie est mise jour automatiquement, sans faire appel la mthode. V ous constaterez aussi que nous n'avons pas cr de mutateur pour la variable d'instance categorie : nous avons en effet dcid que c'est l'objet de grer cette variable !
La mthode
decrisToi() Celle-ci nous renvoie un objet de type String . Elle fait rfrence aux variables qui composent l'objet appelant la mthode, toujours grce this, et nous renvoie donc une chane de caractres qui nous dcrit l'objet, en numrant ses composants.
La mthode
comparer(Ville V1) Elle prend une ville en paramtre, pour pouvoir comparer les variables nbreHabitant de l'objet appelant la mthode, et de celui pass en paramtre pour nous dire laquelle est la plus peuple ! Bien entendu, vous pouvez crer vos propres mthodes, avec leurs paramtres, leurs types, etc. Je ne vous oblige en rien faire exactement les mmes que moi...
Les choses doivent vous sembler plus claires... Si nous faisions un petit test... Essayez le code suivant dans votre mthode main : Code : Java Ville v = new Ville(); Ville v1 = new Ville("marseille", 1236, "france"); Ville v2 = new Ville("rio", 321654, "brsil"); System.out.println("\n\n"+v1.decrisToi()); System.out.println(v.decrisToi()); System.out.println(v2.decrisToi()+"\n\n"); System.out.println(v1.comparer(v2));
Ce qui devrait vous donner :
www.siteduzero.com
101/669
Je viens d'avoir une ide ! Et si nous essayons de savoir combien de villes nous avons cr ? Comment faire ? Avec une variable de classe !
Les variables de classes

Comme je vous le disais au dbut de ce chapitre, il y a plusieurs types de variables dans une classe. Nous avons vu les variables d'instances qui forment la carte d'identit d'un objet et maintenant, voici les variables de classes. Celles-ci peuvent tre trs pratiques. Dans notre exemple, nous allons pouvoir compter le nombre d'instances de notre classe Ville, mais vous pouvez en utiliser pour d'autres choses (un taux de TV A dans une classe qui calcule le prix TTC, par exemple). La particularit de ce type de variable, c'est qu'elles seront communes toutes les instances de la classe ! Crons sans plus attendre notre compteur d'instance. Il s'agira d'une variable de type int que nous appellerons nbreInstance ; celle-ci sera public et nous ferons aussi son homologue en private : appellons-la nbreInstanceBis (un accesseur sera ncessaire pour accder cette dernire). Pour qu'une variable soit une variable de classe, elle doit tre prcde du mot cl static. Ce qui nous donnerait dans notre classe Ville : Code : Java public class Ville { /** * Variables publiques qui comptent les instances */ public static int nbreInstance = 0; /** * Variable prive qui comptera aussi les instances */ private static int nbreInstanceBis = 0; /** * Stocke le nom de notre ville */ private String nomVille; /** * Stocke le nom du pays de notre ville */ private String nomPays; /** * Stocke le nombre d'habitants de notre ville */ private int nbreHabitant; /** * Stocke le type de notre ville */ private char categorie; /** * Constructeur par dfaut */ public Ville(){ //On incrmente nos variables chaque appel aux constructeurs nbreInstance++;
www.siteduzero.com

nbreInstanceBis++; nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; this.setCategorie();
102/669
/** * Constructeur d'initialisation * @param pNom * Nom de la Ville * @param pNbre * Nombre d'habitants * @param pPays * Nom du pays */ public Ville(String pNom, int pNbre, String pPays) { //On incrmente nos variables chaque appel aux constructeurs nbreInstance++; nbreInstanceBis++; nomVille = pNom; nomPays = pPays; nbreHabitant = pNbre; this.setCategorie();
//*********************************************************************************** // ACCESSEURS
//*********************************************************************************** public static int getNombreInstanceBis() { return nbreInstanceBis; } /** * Retourne le nom de la ville * @return le nom de la ville */ public String getNom() { return nomVille; } /** * Retourne le nom du pays * @return le nom du pays */ public String getNomPays() { return nomPays; } /** * Retourne le nombre d'habitants * @return nombre d'habitants */ public int getNombreHabitant() { return nbreHabitant; } /** * Retourne la catgorie de la ville
www.siteduzero.com

* @return catgorie de la ville */ public char getCategorie() { return categorie; } * *
103/669
//**********************************************************************************
// MUTATEURS //**********************************************************************************
/** * Dfinit le nom de la ville * @param pNom * nom de la ville */ public void setNom(String pNom) { nomVille = pNom; } /** * Dfinit le nom du pays * @param pPays * nom du pays */ public void setNomPays(String pPays) { nomPays = pPays; } /** * Dfinit le nombre d'habitants * @param nbre * nombre d'habitants */ public void setNombreHabitant(int nbre) { nbreHabitant = nbre; this.setCategorie(); }
/** * Dfinit la catgorie de la ville */ private void setCategorie() { int bornesSuperieures[] = {0, 1000, 10000, 100000, 500000, 1000000, 5000000 10000000}; char categories[] = {'?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
int i = 0; while (i < bornesSuperieures.length && this.nbreHabitant >= bornesSuperieures i++; this.categorie = categories[i]; }
www.siteduzero.com
104/669
/** * Retourne la description de la ville * @return description ville */ public String decrisToi(){ return "\t"+this.nomVille+" est une ville de "+this.nomPays+", elle comporte : "+this.nbreHabitant+ " => elle est donc de catgorie : "+this.categorie; } /** * Retourne une chane de caractres selon le rsultat de la comparaison * @param v1 * objet Ville * @return comparaison de deux ville */ public String comparer(Ville v1){ String str = new String(); if (v1.getNombreHabitant() > this.nbreHabitant) str = v1.getNom()+" est une ville plus peuple que "+this.nomVille; else str = this.nomVille+" est une ville plus peuple que "+v1.getNom();
return str; } }
V ous avez d remarquer que l'accesseur de notre variable de classe dclare prive est aussi dclar static, et ceci est une rgle ! Toutes les mthodes de classes n'utilisant que des variables de classes doivent tre dclares static ! On les appelle des mthodes de classes car elles sont globales toutes vos instances ! Par contre ceci n'est plus vrai si une mthode utilise des variables d'instances et des variables de classes...
Et maintenant, si vous testez le code suivant, vous allez voir l'utilit des variables des classes : Code : Java Ville v = new Ville(); System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstance); System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstanceBis()); Ville v1 = new Ville("marseille", 1236, "france"); System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstance); System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstanceBis()); Ville v2 = new Ville("rio", 321654, "brsil"); System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstance); System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstanceBis());
www.siteduzero.com
105/669
Rsultat :
V ous voyez que le nombre augmente chaque instanciation ! Et je suppose que le fait que j'ai utilis le nom de classe Ville pour l'appel nos variables de classes a d vous surprendre. Mais vous deviez savoir ceci... Il vous faut savoir aussi que vous auriez galement utilis n'importe quelle instance pour faire ces appels. V ous auriez eu le mme rsultat - peu importe l'instance choisie - car cette donne ne dpend pas de l'instance, mais de la classe elle-mme.
Avant la fin de chapitre, j'ai une rvlation vous faire...
Astuce Eclipse
V oici une astuce qui, je pense, va vous simplifier la vie et quelques minutes de codage... Je vous vois dj en train de vous imaginer coder une classe magnifique avec une centaine de variables d'instances ainsi qu'une dizaine de variables de classes, et d'un seul coup...
BOUM ! !
V ous tombez la renverse lorsque vous devez faire tous les accesseurs de cette fabuleuse classe ! V oici quelque chose qui va vous plaire.
Eclipse vous fait les accesseurs automatiquement !

Bon : il faut tout de mme crer toutes les variables au pralable, mais bon... Nous allons prendre notre classe comme exemple. Conservez toutes les dclarations de variables d'instances et de classes, et effacez tous les accesseurs (mutateurs compris). Ensuite, rendez-vous dans le menu Source et choisissez l'option Generate Getters and Setters. Eclipse vous propose alors la liste des variables prsentes dans la classe Ville.
www.siteduzero.com
106/669
Ici, j'ai coch ce qui m'intressait et j'ai ensuite cliqu sur OK. Mes accesseurs sont tout prts ! Alors, j'suis gentil, non ? Comme vous pouvez le constater, Eclipse gnre des accesseurs diffrents de ceux que nous avions faits aux pralable... Pensez-donc mettre jour votre mthode main si vous voulez faire des tests...
Je profite de cet intermde Eclipse pour vous expliquer pourquoi j'ai mis autant de commentaires autour de mes variables et de mes mthodes. Par contre, ceci concerne les personnes qui ont tlcharg le JDK lors de la premire partie !
Comme je l'ai mentionn dans la premire partie, il y a une troisime syntaxe de commentaires et vous venez de la voir tout au long de ce chapitre. Il s'agit de commentaires javadoc ! Cette syntaxe est quasi identique aux commentaires multilignes une diffrence prs : la prsence d'une deuxime * au dbut du commentaire. V ous avez d constater que la couleur du commentaire tait diffrente.
www.siteduzero.com

Commentaire standard : commentaire de couleur verte. Commentaire javadoc : commentaire de couleur bleue.
107/669
quoi a sert ?
Tout simplement documenter vos programmes et surtout pouvoir gnrer une documentation automatiquement. Dans Eclipse, il vous suffit d'aller dans Project et de cliquer sur Generate Javadoc. V ous devez avoir une popup comme ceci :
Si la commande Javadoc n'est pas renseigne, il vous faut aller chercher, dans le rpertoire bin de votre JDK, le fichier javadoc.exe (comme sur la capture d'cran, chez moi c'est dans C:\SUN\SDK\jdk\bin\javadoc.exe). Il ne vous reste plus qu' cliquer sur Finish et tout approuver. V ous avez maintenant, dans votre dossier de code source, un dossier doc, o se trouve toute la javadoc de votre projet. Double cliquez sur index.html dans ce dossier, et voil ! Pour les personnes ayant essay la compilation en ligne de commande, il vous suffit d'aller dans votre dossier de source Java (l o se trouvent vos fichier .java) et de taper la commande : Code : Bash
www.siteduzero.com

javadoc Ville.java
108/669
Ce qu'il faut retenir

Aprs tout ceci, un petit topo ne fera pas de mal... Une classe permet de dfinir des objets. Ceux-ci ont des attributs (variable(s) d'instances) et des mthodes (mthodes de classes + accesseurs). Les objets permettent d'encapsuler du code et des donnes. Une classe, par dfaut, est dclare public. Le ou les constructeurs d'une classe doivent porter le mme nom que la classe, et pas de type de retour ! Il est recommand de dclarer ses variables d'instance private. Dans une classe, on accde aux variables de celle-ci grce au mot cl this. Une variable de classe est une variable devant tre dclare static. Les mthodes n'utilisant que des variables de classes doivent elles aussi tre dclares static. On instancie un nouvel objet grce au mot cl new. L'ordre des paramtres pass dans le constructeur doit tre respect. Eclipse vous aide dvelopper vos applications.
V oil ! V ous venez d'apercevoir les mandres de la programmation oriente objet... Je suis conscient que ce chapitre fut trs riche en nouveauts, vocabulaire, concepts et mthodologie... mais n'est-ce pas ce que je vous avait dit ? Maintenant, ce que je vous propose, c'est un petit QCM digestif ! a passe toujours mieux aprs le digeo ! V ous venez de voir l'un des chapitres les plus consquents de cette partie... Normalement, vous pouvez dsormais crer et grer des objets... Mais... (parce qu'il y a un mais) ... vous allez voir, au fil de la partie suivante, que la programmation oriente objet offre tout un ventail de possibilits. L'une des plus importantes n'est autre que la notion d'hritage. Sans perdre une seconde, je propose ceux qui se sentent d'attaque de passer la suite !
www.siteduzero.com
109/669
L'hritage !
Je vous arrte tout de suite... V ous ne toucherez rien ! Pas de rapport d'argent entre nous... Non, la notion d'hritage en programmation est toute autre, quoique ressemblante celle que vous connaissez. C'est l'un des fondements de la programmation oriente objet ! Imaginons que dans le programme fait prcdemment, nous voulions crer un autre type d'objet : des objets Capitale. Ceux-ci ne seront ni plus ni moins que des objets Ville avec un paramtre en plus... Disons un prsident ! Et donc, au moment de crer votre classe Capitale, au lieu de tout redfinir, nous allons dire que celle-ci est hrite de Ville. Trve de bavardage ! l'assaut !
La notion d'hritage
Comme je vous l'ai dj dit lors de l'introduction, la notion d'hritage est l'un des fondements de la programmation oriente objet. Grce elle, nous pourrons crer des classes hrites (appeles aussi classes drives) de nos classes mres (appeles aussi classes de base). Nous pourrons crer autant de classes drives, par rapport notre classe de base, que nous le souhaitons. Nous pourrons aussi nous servir d'une classe drive comme d'une classe de base pour crer une autre classe drive... Ce que vous devez savoir aussi, c'est que la notion d'hritage est l'un des piliers de la programmation vnementielle (autre nom de programmation graphique). Ceci sera abord dans la troisime partie de ce tuto. Pour l'instant, restons dans la programmation procdurale ! Reprenons l'exemple dont je vous parlais dans l'introduction. Nous allons donc crer une nouvelle classe, nomme Capitale hrite de Ville. V ous vous rendrez vite compte que les objets Capitale auront tous les attributs et mthodes associs des objets Ville ! Code : Java class Capitale extends Ville { }
C'est le mot-cl extends qui informe notre application que la classe Capitale est hrite de Ville. Pour vous le prouver, essayez ce morceau de code dans votre main : Code : Java Capitale cap = new Capitale(); System.out.println("\n\n"+cap.decrisToi());
V ous devriez avoir ceci :
Ceci est bien la preuve que notre objet Capitale possde les avantages de notre objet Ville. Les objets hrits peuvent accder toutes les mthodes public de leur classe mre, ici la mthode decrisToi(). Dans ce cas rudimentaire, notre objet Capitale ne possde que le constructeur par dfaut et les mthodes associes. En fait, lorsque vous dclarez une classe, si vous ne spcifiez pas de constructeur, la JVM crera au moment de l'interprtation le constructeur par dfaut. C'est le cas ici. De plus, notre classe Capitale hrite de la classe Ville, ceci a pour effet que le
www.siteduzero.com
110/669
constructeur de notre objet appelle, de faon tacite, le constructeur de la classe mre. C'est pour cela que les variables d'instances ont pu tre initialises ! Par contre, dans notre classe Capitale, nous ne pouvons pas utiliser directement les attributs de la classe Ville. Essayez ceci dans votre classe : Code : Java public class Capitale extends Ville{ public Capitale(){ this.nomVille = "toto"; } }
V ous allez avoir une belle erreur de compilation ! Pourquoi ?
Tout simplement parce les variables de la classe Ville sont dclars private. Comme seules les mthodes et les variables dclares public peuvent tre utilises dans une classe hrite, le compilateur rejette votre demande lorsque vous tentez d'accder des ressources prives d'une classe mre ! Comment y remdier tout en gardant la protection sur les variables de ma classe mre ?
C'est ici que je vais vous apprendre un nouveau mot cl : protected. En remplaant la dclaration des variables et des mthodes prives de la classe Ville en protected, cela aura pour effet de toujours protger l'accs celles-ci depuis du code utilisant un objet Ville ; mais cela permet aux classes qui hritent de cette dernire d'y avoir accs ! Donc, une fois toutes les variables et mthodes prives de la classe mre re-dclares en protected, notre objet Capitale aura accs celles-ci ! Ainsi, voici votre classe Ville revue et corrige : Code : Java public class Ville { /** * Variable publique compteur d'instances */ public static int nbreInstance = 0; /** * Variable prive compteur d'instances */ protected static int nbreInstanceBis = 0; /** * Stocke le */ protected /** * Stocke le */ protected /** * Stocke le */ protected /** * Stocke le */ protected nom de notre ville String nomVille; nom du pays de notre ville String nomPays; nombre d'habitants de notre ville int nbreHabitant; type de notre ville char categorie;
www.siteduzero.com

/** * Constructeur par dfaut */ public Ville(){ //On incrmente nos variables chaque appel au constructeur nbreInstance++; nbreInstanceBis++; nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitant = 0; this.setCategorie();
111/669
/** * Constructeur d'initialisation * @param pNom * Nom de la Ville * @param pNbre * Nombre d'habitants * @param pPays * Nom du pays */ public Ville(String pNom, int pNbre, String pPays) { nbreInstance++; nbreInstanceBis++; nomVille = pNom; nomPays = pPays; nbreHabitant = pNbre; this.setCategorie();
//*********************************************************************************** // ACCESSEURS
//*********************************************************************************** public static int getNombreInstanceBis() { return nbreInstanceBis; } /** * Retourne le nom de la ville * @return le nom de la ville */ public String getNom() { return nomVille; } /** * Retourne le nom du pays * @return le nom du pays */ public String getNomPays() { return nomPays; } /** * Retourne le nombre d'habitants * @return nombre d'habitants */
www.siteduzero.com

public int getNombreHabitant() { return nbreHabitant; } /** * Retourne la catgorie de la ville * @return catgorie de la ville */ public char getCategorie() { return categorie; } * *
112/669
//**********************************************************************************
// MUTATEURS //**********************************************************************************
/** * Dfinit le nom de la ville * @param pNom * nom de la ville */ public void setNom(String pNom) { nomVille = pNom; } /** * Dfinit le nom du pays * @param pPays * nom du pays */ public void setNomPays(String pPays) { nomPays = pPays; } /** * Dfinit le nombre d'habitants * @param nbre * nombre d'habitants */ public void setNombreHabitant(int nbre) { nbreHabitant = nbre; this.setCategorie(); }
/** * Dfinit la catgorie de la ville */ protected void setCategorie() { int bornesSuperieures[] = {0, 1000, 10000, 100000, 500000, 1000000, 5000000 10000000}; char categories[] = {'?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'}; int i = 0;
www.siteduzero.com
113/669
while (i < bornesSuperieures.length && this.nbreHabitant >= bornesSuperieures i++; this.categorie = categories[i]; } /** * Retourne la description de la ville * @return description ville */ public String decrisToi(){ return "\t"+this.nomVille+" est une ville de "+this.nomPays+", elle comporte : "+this.nbreHabitant+ " => elle est donc de catgorie : "+this.categorie; } /** * Retourne une chane de caractres selon le rsultat de la comparaison * @param v1 * objet Ville * @return comparaison de deux ville */ public String comparer(Ville v1){ String str = new String(); if (v1.getNombreHabitant() > this.nbreHabitant) str = v1.getNom()+" est une ville plus peuple que "+this.nomVille; else str = this.nomVille+" est une ville plus peuple que "+v1.getNom();
return str; } }
Un point important avant de continuer.
Contrairement au C++, Java ne gre pas les hritages multiples : une classe drive (ou encore classe fille) ne peut hriter que d'une seule classe mre !
V ous n'aurez donc Code : Java
JAMAIS ce genre de classe :
class Toto extends Titi, Tutu{ }
prsent, continuons la construction de notre objet hrit !
Construction d'un objet hrit

Il va de soi que cette opration va se concrtiser avec nos chers constructeurs. Notre classe Ville ne changera plus d'un poil, mais nous allons par contre agrmenter notre classe Capitale. Comme je vous l'avais dit, ce qui diffrenciera nos objets Capitale de nos objets Ville sera la prsence d'un champ nouveau : le nom du prsident. Ce qui signifie que nous devons crer un constructeur par dfaut et un constructeur d'initialisation pour notre objet Capitale.
www.siteduzero.com
114/669
Avant de foncer tte baisse, il faut que vous sachiez que nous pouvons faire appel aux variables de la classe mre dans nos constructeurs... Et ceci grce au mot-cl super. Ce qui aura pour effet de rcuprer les lments de l'objet de base, et de les envoyer notre objet hrit. Dmonstration : Code : Java class Capitale extends Ville { private String president; /** *Constructeur par dfaut */ public Capitale(){ //Ce mot cl appelle le constructeur de la classe mre. super(); president = "aucun"; } }
Si vous testez nouveau le petit exemple que je vous avais montr un peu plus haut, vous vous apercevrez que le constructeur par dfaut fonctionne toujours... Et pour cause, car ici, super() appelle le constructeur par dfaut de l'objet Ville dans notre constructeur de Capitale, puis nous avons rajout le prsident par dfaut. Mais la mthode decrisToi() ne prend pas en compte le nom du prsident... Eh bien le mot-cl super() fonctionne aussi pour les mthodes de classe. Ce qui nous donne une mthode decrisToi() un peu diffrente... car nous allons rajouter le champ prsident dans notre description. V oyez plutt : Code : Java class Capitale extends Ville { private String president; /** *Constructeur par dfaut */ public Capitale(){ //Ce mot cl appel le constructeur de la classe mre. super(); president = "aucun"; } /** *Description d'une capitale */ public String decrisToi(){ String str = super.decrisToi() + "\n \t ==>>" + this.president + " est son prsident"; //Pour bien vous montrer, j'ai ajout la ligne ci-dessous, mais vous n'tes pas obligs... System.out.println("Invocation de super.decrisToi()"); System.out.println(super.decrisToi()); return str; } }
www.siteduzero.com

Si vous relancez les mmes instructions prsentes dans le main, depuis le dbut, vous aurez quelque chose comme a :
115/669
Il y a du mieux, non ? Bon, d'accord, nous n'avons toujours pas fait le constructeur d'initialisation de Capitale... Eh bien ? Qu'est-ce que nous attendons ?
Code complet de notre classe
Capitale
Code : Java public class Capitale extends Ville { private String president; /** *Constructeur par dfaut */ public Capitale(){ //Ce mot cl appelle le constructeur de la classe mre. super(); president = "aucun";
/** * Constructeur d'initialisation de capitale */ public Capitale(String nom, int hab, String pays, String president){ super(nom, hab, pays); this.president = president; } /** *Description d'une capitale */ public String decrisToi(){ String str = super.decrisToi() + "\n \t ==>>" + this.president + " est son prsident"; return str; } /** * @return le nom du prsident */ public String getPresident() {
www.siteduzero.com

} return president;
116/669
/** * Dfinit le nom du prsident * @param president */ public void setPresident(String president) { this.president = president; } }
Donc : dans le constructeur d'initialisation de notre Capitale, vous remarquez la prsence de super(nom, hab, pays);. Difficile de ne pas le voir... Ici, cette ligne de code joue le mme rle que pour le constructeur par dfaut. Sauf qu'ici, le constructeur auquel super fait rfrence prend trois paramtres... donc super doit prendre ces paramtres. Si vous ne lui mettez aucun paramtre, super() renverra le constructeur par dfaut de la classe Ville...
Testez ce code : Code : Java Capitale cap = new Capitale("Paris", 654987, "France", "Sarko"); System.out.println("\n"+cap.decrisToi());
V ous devriez voir apparatre sous vos yeux bahis :
Je vais encore vous interpeler mais... ce que vous venez de faire sur la mthode decrisToi() s'appelle : une mthode polymorphe, ce qui nous conduit tout de suite la suite !
Le polymorphisme
V oici encore un des concepts fondamentaux de la programmation oriente objet : Le Ce concept complte parfaitement celui de l'hritage.
polymorphisme.
Comme vous l'avez vu, le polymorphisme n'est pas si compliqu qu'il pourrait sembler l'tre ! Nous pouvons le caractriser en disant qu'il permet de manipuler des objets sans vraiment connatre leur type.
Dans notre exemple, vous avez vu qu'il suffisait d'utiliser la mthode decrisToi() sur un objet Ville ou sur un objet Capitale, et cela sans se soucier de leur type. On pourrait construire un tableau d'objets, et appeler la decrisToi() sans se soucier de son contenu : villes, capitales, ou les deux. D'ailleurs nous allons le faire. Essayez ce code : Code : Java //Def d'un tableau de ville null
www.siteduzero.com

Ville[] tableau = new Ville[6]; //Dfinition d'un tableau de noms de Villes et d'un tableau de nombres d'habitants String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"}; int[] tab2 = {123456, 78456, 654987, 75832165, 1594,213}; /* Les 3 premiers lments du tableau seront des Villes, et le reste, des capitales */ for(int i = 0; i < 6; i++){ if (i <3){ Ville V = new Ville(tab[i], tab2[i], "france" ); tableau[i] = V; } else{ Capitale C = new Capitale(tab[i], tab2[i], "france", "Sarko"); tableau[i] = C; } } //il ne nous reste plus qu' dcrire tout notre tableau ! for(Ville v : tableau){ System.out.println(v.decrisToi()+"\n"); }
117/669
Rsultat :
Une petite nouveaut, la cration d'un tableau d'un certain nombre d'entres vides . Rien de bien compliqu cela, vous voyez que la syntaxe est toute simple. Nous crons un tableau de villes, avec des villes et des capitales (nous avons le droit de faire a, car les objets Capitale sont aussi des objets Ville... ), dans notre premire boucle for. Dans la seconde, nous affichons la description de ces objets... et vous voyez que la mthode polymorphe decrisToi() fait bien son travail ! Dans ta boucle, tu n'utilises que des objets Ville.
Tout fait. On appelle ceci la covariance des variables ! Cela signifie qu'une variable objet peut contenir un objet qui hrite du type de cette variable. Dans notre cas, un objet de type Ville peut contenir un objet de type Capitale. Dans ce cas, on dit que Ville est la super classe par rapport Capitale. La covariance est efficace dans le cas o la classe hritant redfinit certaines des mthodes de sa super classe.
www.siteduzero.com
118/669
Attention ne pas confondre la surcharge de mthode avec une mthode polymorphe.
Pour dire les choses simplement : une mthode surcharge a des paramtres que la mthode de base n'a pas, ou a le mme nombre de paramtres, mais de types diffrents ; une mthode polymorphe a un squelette identique celle de base, mais un traitement diffrent. Celle-ci fait rfrence une autre classe et donc, par extension, une autre instance de cette classe. On
peut dire que les mthodes
polymorphes sont typiques des classes hrites !

V ous devez savoir encore une chose sur l'hritage. Lorsque vous crez une classe (Ville par exemple), celle-ci est une classe hrite de la classe Object prsente dans Java. Cette criture est donc tout fait correcte : Code : Java class Ville extends Object{ .......... }
Toutes nos classes hritent donc des mthodes de la classe Object, comme equals(), qui prend un objet en paramtre, et qui permet de tester l'galit d'objets. V ous vous en tes d'ailleurs servis pour tester l'galit de String() dans la premire partie de ce tuto. Donc, si nous redfinissons une mthode de la classe Object dans la classe Ville, nous pourrions utiliser la covariance. La mthode de la classe Object qui est le plus souvent redfinie est la mthode toString(), qui retourne un String et qui a pour rle de dcrire l'objet en question (tout comme notre mthode decrisToi()). Nous allons donc faire un copier / coller de notre procdure de la mthode decrisToi() dans une nouvelle mthode de la classe Ville : toString(). V oici : Code : Java public String toString(){ return "\t"+this.nomVille+" est une ville de "+this.nomPays+", elle comporte : "+this.nbreHabitant+ " => elle est donc de catgorie : "+this.categorie; }
Nous faisons de mme dans la classe Capitale : Code : Java public String toString(){ String str = super.toString() + "\n \t ==>>" + this.president + " est son prsident"; return str; }
Maintenant, testez ce code : Code : Java //Def d'un tableau de ville null Ville[] tableau = new Ville[6];
www.siteduzero.com

//Dfinition d'un tableau de noms de Villes et d'un tableau de nombres d'habitants String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"}; int[] tab2 = {123456, 78456, 654987, 75832165, 1594,213}; /* Les 3 premiers lments du tableau seront des Villes et le reste des capitales */ for(int i = 0; i < 6; i++){ if (i <3){ Ville V = new Ville(tab[i], tab2[i], "france" ); tableau[i] = V; } else{ Capitale C = new Capitale(tab[i], tab2[i], "france", "Sarko"); tableau[i] = C; } } //il ne nous reste plus qu' dcrire tout notre tableau ! for(Object obj : tableau){ System.out.println(obj.toString()+"\n"); }
119/669
V ous pouvez constater qu'il fait exactement la mme chose que le prcdent ; nous n'avons pas nous soucier du type d'objet pour afficher sa description. Je pense que vous commencez apercevoir la puissance de Java ! ATTENTION : si vous ne redfinissez pas ou ne polymorphez pas une mthode d'une classe mre dans une classe fille (exemple de toString()), l'appel de celle-ci avec un objet fille, c'est la mthode de la classe mre qui sera invoque ! ! Une prcision : si vous avez un objet v de type Ville par exemple, que vous n'avez pas redfini la mthode toString() et que vous testez ce code : Code : Java System.out.println(v);
Cette instruction appelle automatiquement la mthode toString() de la classe Object ! Mais vu que vous avez redfini la mthode toString() dans votre classe Ville, ces deux instructions sont quivalentes : Code : Java System.out.println(v.toString()); //Est quivalent System.out.println(v);
Pour plus de clart, je conserverai la premire syntaxe ! Mais vous devez savoir ceci ! En clair, vous avez accs aux mthodes public et protected de la classe Object ds que vous crez une classe objet (hritage tacite). V ous pouvez donc utiliser les dites mthodes ; mais si vous ne les redfinissez pas... l'invocation se fera sur la classe mre avec les traitements de la classe mre. Si vous voulez un bel exemple de ce que je viens de vous dire, vous n'avez qu' retirer la redfinition de la mthode toString() dans les classes Ville et Capitale : vous verrez que le code de la mthode main fonctionne toujours, mais le rsultat n'est plus du tout le mme car, l'appel de la mthode toString(), la JVM va regarder si celle-ci existe dans la classe appelante et, si elle ne la trouve pas, elle remonte dans la hirarchie jusqu' arriver la classe Object... Attention 2 : ce code fonctionne bien mais, si vous remplacez la mthode toString() par la mthode decrisToi(), le
www.siteduzero.com

programme ne fonctionne plus... Object. V ous devez savoir qu'une mthode est invoquable par un objet QUE si celui-ci dfinit ladite mthode !
120/669
Et cela pour une bonne raison : la mthode decrisToi() n'existe pas dans la classe
Donc, ce code ne fonctionne pas : Code : Java public class Sdz1 { public static void main(String[] args){ //Def d'un tableau de ville null Ville[] tableau = new Ville[6]; //Dfinition d'un tableau de noms de Villes et d'un tableau de nombres d'habitants String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"}; int[] tab2 = {123456, 78456, 654987, 75832165, 1594,213}; /* Les 3 premiers lments du tableau seront des Villes, et le reste, des capitales */ for(int i = 0; i < 6; i++){ if (i <3){ Ville V = new Ville(tab[i], tab2[i], "france" ); tableau[i] = V; } else{ Capitale C = new Capitale(tab[i], tab2[i], } tableau[i] = C;
"france", "Sarko"); } tableau !
//il ne nous reste plus qu' dcrire tout notre for(Object v : tableau){ System.out.println(v.decrisToi()+"\n"); }
Pour que cela fonctionne, vous devez dire la JVM que la rfrence de type Object est en fait une rfrence de type Ville. Comme ceci : Code : Java public class Sdz1 { public static void main(String[] args){ //Def d'un tableau de ville null Ville[] tableau = new Ville[6]; //Dfinition d'un tableau de noms de Villes et d'un tableau de nombres d'habitants
www.siteduzero.com

String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"}; int[] tab2 = {123456, 78456, 654987, 75832165, 1594,213}; /* Les 3 premiers lments du tableau seront des Villes, et le reste, des capitales */ for(int i = 0; i < 6; i++){ if (i <3){ Ville V = new Ville(tab[i], tab2[i], "france" ); tableau[i] = V; } else{ Capitale C = new Capitale(tab[i], tab2[i], } tableau[i] = C;
121/669
"france", "Sarko"); } tableau !
//il ne nous reste plus qu' dcrire tout notre for(Object v : tableau){
System.out.println(((Ville)v).decrisToi()+"\n"); } } }
V ous transtypez la rfrence v en Ville par cette syntaxe : Code : Java ((Ville)v).decrisToi();
Ici, l'ordre des oprations s'effectue comme ceci : vous transtypez la rfrence v en Ville vous appliquez la mthode decrisToi() la rfrence appelante, ici, une rfrence Object change en Ville.
V ous voyez donc l'intrt des mthodes polymorphes. Avec celles-ci, vous n'avez plus vous soucier du type de variable appelante ; cependant, n'utilisez le type Object qu'avec parcimonie. Il existe encore un type de mthode dont je ne vous ai pas encore parl. Il s'agit des mthodes dites final . Ces mthodes sont figes et vous ne pourrez JAMAIS redfinir une mthode dclare final . Un exemple de ce type de mthode est la mthode getClass() de la classe Object : vous ne pourrez pas redfinir cette mthode et heureusement, car celle-ci retourne un objet Capitale dans le fonctionnement de Java (nous verrons cela plus tard). Il existe aussi des classes dclares final . V ous avez compris que ces classes sont immuables... Et vous ne pouvez donc pas faire hriter un objet d'une classe dclare final !
Ce qu'il faut retenir

Encore un petit topo des familles. Je pense qu'avec ce genre de chapitre, ce n'est pas du luxe... Une classe hrite d'une autre classe par le biais du mot cl extends. Une classe ne peut hriter que d'une seule et unique classe ! Si nous ne dfinissons pas de constructeur dans nos classes, la JVM se charge d'en crer un l'interprtation.
www.siteduzero.com
122/669
Si aucun constructeur n'est dfini dans une classe fille, la JVM en crera un et appellera automatiquement le constructeur de la classe mre. La classe fille hrite de toutes les proprits et mthodes public et protected de la classe mre. Les mthodes et proprits private d'une classe mre ne sont pas accessibles dans la classe fille. On peut redfinir (changer tout le code) d'une mthode hrite. On peut utiliser le polymorphisme sur une mthode par le biais du mot cl super. Le polymorphisme permet, entre autres, d'ajouter des traitements spcifiques une mthode en continuant d'utiliser les traitements dj dfinis (utilisation de super). Grce l'hritage et au polymorphisme, nous pouvons utiliser la covariance des variables ! Si une mthode d'une classe mre n'est pas redfinie ou polymorphe, l'appel de cette mthode par le biais d'un objet enfant, c'est la mthode de la classe mre qui sera appele ! V ous ne pouvez pas hriter d'une classe dclare final. Une mthode dclare final est non redfinissable.
Je crois que vous tes prts pour un petit QCM... Mais prenez le temps de digrer tout ceci ! Faites des essais, testez, comparez, c'est le meilleur moyen de bien comprendre les choses. Si vous tes prts pour la suite, allons tout de suite voir ce qui se passe : Apprendre modliser.
www.siteduzero.com
123/669
Apprendre modliser
Dans ce chapitre nous allons voir le principe de modlisation d'objet. Ne vous leurrez pas, a sera assez indigeste, mais faites-moi confiance...
UML, mais qu'est-ce donc ?

UML est le sigle signifiant Unified Modeling Language : traduisez par " langage de modlisation unifi". Il ne s'agit pas d'un langage de programmation mais plutt d'une mthodologie de modlisation comme la mthode merise, etc. quoi a sert ?
Je sais que vous tes des Zr0s avertis en matire de programmation, ainsi qu'en informatique en gnral, mais mettez-vous dans la peau d'une personne totalement dnue de toute connaissance dans le domaine. Il fallait trouver un langage commun entre les commerciaux, les responsables de projets informatiques, les dveloppeurs afin que tout ce petit monde se comprenne. Avec UML, c'est le cas. En fait, avec UML, vous pouvez modliser toutes les parties de dveloppement d'une application informatique, de sa conception la mise en route, tout ceci grce des diagrammes. Il est vrai que certains de ces diagrammes sont plus adapts des informaticiens, mais il en existe qui permettent de voir comment interagit l'application dans son contexte de fonctionnement... Et dans ce genre de cas, la connaissance de l'entreprise pour laquelle l'application est prvue est de mise. On utilise donc un mode de communication commun tout le monde : UML. Il existe bien sr des outils de modlisation afin de crer de tels diagrammes. Personnellement, j'utilise argoUML mais il en existe d'autres, comme : boUML Together Poseidon Pyut ...
ArgoUML a le mrite d'tre gratuit et fait en Java... donc multi-plates-formes. Avec ces outils, vous pouvez raliser les diffrents types de diagrammes qu'UML vous propose : diagramme de use case (cas d'utilisation) : permet de dterminer les diffrents cas d'utilisation d'un programme informatique ; diagramme de classes : celui dont nous allons nous servir ; permet de modliser des classes ainsi que les interactions entre elles ; des diagrammes de squences : permettent de visualiser le droulement d'une application dans un contexte donn ; et d'autres encore...
V oici un exemple de diagramme de classe :
www.siteduzero.com
124/669
V ous avez d remarquer qu'il s'agissait des classes que nous avons utilises lors des chapitres prcdents. Je ne vous cache pas non plus qu'il s'agit d'une version simplifie... En effet, vous pouvez constater que je n'ai pas mis toutes les mthodes dclares public de la classe Object ainsi que des classes que nous avons codes. Je ne vais pas vous apprendre utiliser argoUML non plus, mais plutt savoir lire un diagramme car, dans certains cas, il s'avre pratique de modliser les classes et l'interaction entres celles-ci. Ne serait-ce que pour avoir plus de recul sur notre travail. Mais aussi parce qu'il y a des concepts de programmation qu'il est plus facile d'expliquer avec un diagramme qu'avec de longs discours...
Modliser un objet
prsent, nous allons apprendre lire un diagramme de classes. V ous avez devin qu'une classe est modlise sous cette forme :
V oici une classe nomme ObjetA qui a comme attributs : numero de type int nom de type String et bool de type boolean. Et comme mthodes : getNom() qui retourne une chane de caractres setNom() qui ne renvoie rien afficher() qui renvoie elle aussi une chane de caractres. La porte des attributs et des mthodes n'est pas modlise ici... V ous voyez que la modlisation d'un objet est toute simple et trs comprhensible ! Maintenant, voyons les interactions entre objets.
www.siteduzero.com
125/669
Modliser les interactions entre objets

V ous allez voir que les interactions sont aussi trs simples modliser. En fait, comme vous avez pu le voir sur l'exemple, les interactions sont modlises par des flches de types diffrents. Nous allons voir maintenant celles que nous pouvons d'ores et dj utiliser, dans l'tat actuel de nos connaissances (au fur et mesure, nous verrons d'autres flches). Regardez ceci :
Sur ce diagramme, vous pouvez voir un deuxime objet qui a lui aussi des paramtres. Mais ne vous y trompez pas, ObjetB possde aussi les attributs et les mthodes de la classe ObjectA. Et d'aprs vous, pourquoi ? Car la flche qui relie nos deux objets signifie " extends ". En gros, vous pouvez lire ce diagramme comme suit : l'ObjetB hrite de l'ObjetA, ou encore ObjetB est un objetA. Nous allons voir une autre flche d'interaction. Je sais que nous n'avons pas encore vu ce cas de figure, mais il est simple comprendre. Comme nous pouvons mettre des objets de type String dans des classes que nous dveloppons, nous pouvons aussi mettre comme variable d'instance, ou de classe, un objet que nous avons cod. V oici un diagramme modlisant ce cas de figure :
Dans cet exemple simpliste, vous voyez que nous avons toujours notre hritage entre un objet A et un objet B mais dans ce cas,
www.siteduzero.com
126/669
l'ObjetA (et donc l'ObjetB ) ont une variable de classe de type ObjetC, ainsi qu'une mthode ayant un type de retour ObjetC (car la mthode va retourner un ObjetC). V ous pouvez lire ce diagramme comme suit : l'ObjetA a un ObjetC. Ici, il n'y a qu'un seul objetC : " a UN". V oici le code Java correspondant ce diagramme.
Fichier ObjetA.java
Code : Java public class ObjetA{ protected ObjetC obj = new ObjetC(); public ObjetC getObject(){ return obj; }
Fichier ObjetB.java
Code : Java public class ObjetB extends ObjetA{ }
Fichier ObjetC.java
Code : Java public class ObjetC{ }
Il y a encore une dernire flche que nous pouvons voir car elle ne diffre que lgrement de la premire. V oici un diagramme la mettant en oeuvre :
www.siteduzero.com
127/669
Nous avons ici le mme diagramme que prcdemment, l'exception de l'ObjetD. Ici, nous devons lire le diagramme comme suit : l'ObjetA est compos d'ObjetD. Ici, il y aura plusieurs instances d'ObjetD dans ObjetA. V ous pouvez d'ailleurs remarquer que la variable d'instance correspondante est de type tableau... V oici le code Java correspondant :
Fichier ObjetA.java
Code : Java public class ObjetA{ protected ObjetC obj = new ObjetC(); protected ObjetD[] objD = new ObjetD[10]; public ObjetC getObject(){ return obj; } public ObjectD[] getObjectD(){ return objD; }
Fichier ObjetB.java
Code : Java public class ObjetB extends ObjetA{ }
Fichier ObjetC.java
Code : Java public class ObjetC{
www.siteduzero.com

}
128/669
Fichier ObjetD.java
Code : Java public class ObjetD{ }
Il est bien vident que ces classes ne font strictement rien.. Mais je les ai utilises titre d'exemple pour la modlisation...
V oil, c'en est fini pour le moment. Attendez-vous donc avoir des diagrammes dans vos prochains chapitres... Il n'y aura pas de QCM car j'estime qu'il n'y a rien de difficile ici. Aprs ce que nous avons vu au cours de ce chapitre et des prcdents, nous allons tout de suite voir les classes abstraites !
www.siteduzero.com
129/669
Les classes abstraites

Nous voici de retour dans l'un des fondements du langage Java. En effet, vous verrez ici que les classes abstraites sont vraiment pratiques. Sans plus attendre : let's go !
Qu'est-ce que c'est ?

Ne vous en faites pas... Ici abstraite n'a rien de commun avec un certain mouvement de peinture. En fait, une classe abstraite est quasiment comme une classe normale. Oui, comme une classe que vous avez maintenant l'habitude de coder. Ceci dit, elle a tout de mme une particularit :
vous ne pouvez pas l'instancier !

V ous avez bien entendu Code : Java . Imaginons que nous ayons une classe A dclare abstraite. Ce code ne compilera pas :
public class Test{ public static void main(String[] args){ A obj = new A();//Erreur de compilation ! ! } }
quoi a sert, alors ?
J'attendais cette question... C'est pour a que je n'ai pas commenc directement par un exemple de classe abstraite. Tout d'abord, je vais vous donner un exemple de situation (de programme, en fait). Imaginez que vous tes en train de raliser un programme qui gre diffrents types d'animaux (oui, je sais : l'exemple est bte, mais il a le mrite d'tre simple comprendre). Dans ce programme, vous avez : des des des des des loups chiens chats lions tigres.
Je pense tout de mme que vous n'allez pas faire toutes vos classes btement... il va de soi que tous ces animaux ont des choses en commun ! Et qui dit chose en commun... dit hritage. Que pouvons-nous dfinir de commun tous ces animaux, sinon : une couleur un poids qu'ils crient qu'ils se dplacent qu'ils mangent qu'ils boivent.
Nous pouvons donc faire une classe mre, appelons-la Animal. Avec ce que nous avons dgag de commun, nous pouvons lui dfinir des attributs et des mthodes. V oici donc quoi pourraient ressembler nos classes pour le moment :
www.siteduzero.com
130/669
Nous avons bien notre classe mre Animal et nos animaux qui en hritent. prsent, laissez-moi vous poser une question. Vu que notre classe Animal est public dans notre cas, qu'est-ce qu'est cens faire un objet Animal ? Quel est son poids, sa couleur, que mange-t-il ? Si nous avons un morceau de code qui ressemble ceci : Code : Java public class Test{ public static void main(String[] args){ Animal ani = new Animal(); ani.manger();//Que doit-il faire ? ? } }
...personnellement, je ne sais pas comment mange un objet Animal... Vous conviendrez que toutes les classes ne sont pas bonnes tre instancies ! C'est l que rentrent en jeu nos classes abstraites. En fait, ces classes servent dfinir une super classe. D'accord, mais comment on empche une classe d'tre instanciable puisque tu nous a dit que la JVM dclare un constructeur par dfaut... On ne peut donc pas omettre le constructeur ! Tout fait. Pour rpondre cette question : suivez le guide !
Une classe Animal trs abstraite

En fait, il existe une rgle pour qu'une classe soit considre comme abstraite. Elle doit tre dclare avec le mot cl abstract. V oici un exemple illustrant mes dires : Classe dclare abstraite : Code : Java abstract class Animal{ }
Une telle classe peut avoir le mme contenu qu'une classe normale. Ses enfants pourront utiliser tous ses lments dclars
www.siteduzero.com
131/669
(attributs et mthodes) public. Cependant, ce type de classe permet de dfinir des mthodes abstraites. Ces mthodes ont une particularit ; elles n'ont pas de corps ! En voici un exemple : Code : Java abstract class Animal{ abstract void manger();//une mthode abstraite }
V ous voyez pourquoi on dit " mthode abstraite", difficile de voir ce que cette mthode sait faire... Retenez bien qu'une mthode abstraite n'est compose que de l'entte de la mthode suivie d'un point-virgule :
Jusque-l a va, mais concrtement, quoi a sert ?
Tout d'abord, vous devez savoir qu'une mthode abstraite ne peut exister que dans une classe abstraite. Si dans une classe, vous avez une mthode dclare abstraite, vous DEVEZ DCLARER CETTE CLASSE COMME ETANT ABSTRAITE. Maintenant voyons quoi cela peut servir. V ous avez vu les avantages de l'hritage et du polymorphisme. Dans ce cas, nos classes enfants hriteront aussi des classes abstraites mais, vu que celles-ci n'ont pas de corps, nos classes enfants seront OBLIGES de redfinir ces mthodes ! De ce fait, nos classes enfants auront des mthodes polymorphes en leur sein et donc, la covariance des variables repointe le bout de son nez... La covariance applique aux classes abstraites donne ceci : Code : Java public class Test{ public static void main(String args[]){ Animal loup = new Loup(); Animal chien = new Chien(); loup.manger(); chien.crier(); } }
Attends ! Tu nous as dit qu'on ne pouvait instancier de classe abstraites ?
Et je maintiens mes dires. Ici, nous n'avons pas instanci notre classe abstraite. Nous avons instanci un objet Loup que nous avons mis dans un objet de type Animal : il en va de mme pour l'instanciation de la classe Chien. V ous devez vous rappeler que l'instance se cre avec le mot cl new. En aucun cas le fait de dclarer une variable d'un type de classe donne (ici, Animal) est une instanciation ! Ici nous instancions un Loup et un Chien.
V ous pouvez aussi utiliser une variable de type Object comme rfrence pour un objet Loup, un objet Chien... V ous savez dj que ce code fonctionne : Code : Java public class Test{ public static void main(String[] args){
www.siteduzero.com

} Object obj = new Loup();
132/669
Par contre, ceci pose problme : Code : Java public class Test{ public static void main(String[] args){ Object obj = new Loup(); Loup l = obj;//Problme de rfrence } }
Eh oui ! V ous essayez ici de mettre une rfrence de type Object dans une rfrence de type Loup . Pour avertir la JVM que la rfrence que vous voulez mettre dans votre objet de type Loup est un Loup, vous devez utiliser le transtypage ! Revoyons notre code : Code : Java public class Test{ public static void main(String[] args){ Object obj = new Loup(); Loup l = (Loup)obj;//Vous prvenez la JVM que la rfrence que vous passez est de type Loup } }
V ous pourrez bien videmment instancier directement un objet Loup, un objet Chien ou tout autre. Pour le moment, nous n'avons aucun code dans aucune classe ! Les exemples que je vous ai fournis ne font rien du tout, mais ils seront censs fonctionner lorsque nous aurons mis des morceaux de code dans nos classes. prsent, toffons nos classes et notre diagramme avant d'avoir un code qui fonctionne bien !
toffons notre exemple

Nous allons donc rajouter des morceaux de code nos classes. Tout d'abord, voyons le topo de ce que nous savons. Nos objets auront tous une couleur et un poids diffrents. Nos classes auront donc le droit de modifier ceux-ci. Ici, nous partons du principe que tous nos animaux mangeront de la viande. La mthode manger() sera donc dfinie dans la classe Animal. Idem pour la mthode boire(). Ils boiront tous de l'eau . Par contre, ils ne crient pas et ne se dplaceront pas de la mme manire. Nous ferons donc des mthodes polymorphes et dclarerons les mthodes crier() et deplacement() abstraites dans la classe Animal.
V oici ce que donneraient nos classes :
www.siteduzero.com
133/669
J'ai colori la classe abstraite en bleu mais il y un autre moyen de savoir si une classe est abstraite : le nom de celle-ci est en italique. Je ne sais pas si c'est une convention ou non, mais argoUML la diffrencie de cette faon ! Nous voyons bien que notre classe Animal est dclare abstraite et que nos classes filles hritent de celle-ci. De plus, nos classes filles ne redfinissent que deux mthodes sur quatre, on en conclut ici que ces deu

Langue

Apprenez A Programmer en Java

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apprenez A Programmer en Java

Transféré par

Droits d'auteur :

Formats disponibles

Apprenez programmer en Java

Licence Creative Commons BY-NC-SA 2.0 Dernire mise jour le 16/04/2012

Parlons d'Eclipse ............................................................................................................................................................... 7

Votre premier programme ............................................................................................................................................... 17

Les variables et les oprateurs ....................................................................................................................................... 26

Lire les entres clavier .................................................................................................................................................... 36

Les conditions ................................................................................................................................................................. 42

Les boucles ..................................................................................................................................................................... 50

TP n1 : un tableau de conversion Celsius - Fahrenheit ! .............................................................................................. 58

Les tableaux .................................................................................................................................................................... 63

Les mthodes de classe ................................................................................................................................................. 74

Partie 2 : Java Orient Objet ............................................................................................................. 84

L'hritage ! ..................................................................................................................................................................... 109

Apprendre modliser .................................................................................................................................................. 122

Les classes abstraites ................................................................................................................................................... 128

Les interfaces ................................................................................................................................................................ 141

Les exceptions .............................................................................................................................................................. 151

Les collections d'objets ................................................................................................................................................. 168

La gnricit en Java .................................................................................................................................................... 173

Java et la rflexivit ....................................................................................................................................................... 185

Partie 3 : Java et la programmation vnementielle ....................................................................... 195

Une histoire de conteneur ............................................................................................................................................. 200

Faire une animation simple ........................................................................................................................................... 216

Votre premier bouton ..................................................................................................................................................... 224

Interaction bouton(s) - application ................................................................................................................................. 247

TP : une calculatrice ...................................................................................................................................................... 269

Les threads .................................................................................................................................................................... 284

Les listes : l'objet JComboBox ...................................................................................................................................... 298

Les cases cocher : l'objet JCheckBox ........................................................................................................................ 311

Les champs de texte : l'objet JTextField ....................................................................................................................... 324

Les applets .................................................................................................................................................................... 352

Les botes de dialogue .................................................................................................................................................. 367

Les menus ..................................................................................................................................................................... 390

TP : l'ardoise maZique .................................................................................................................................................. 446

Les flux d'entres / sorties (1/2) .................................................................................................................................... 454

Les flux d'entres / sorties (2/2) .................................................................................................................................... 480

TP : Le penduZ .............................................................................................................................................................. 486

Grez vos conteneurs ................................................................................................................................................... 490

Les arbres ..................................................................................................................................................................... 504

Les tableaux, les vrais ................................................................................................................................................... 537

Ce que vous pouvez voir en plus .................................................................................................................................. 571

Partie 4 : Les Design patterns ......................................................................................................... 581

Soyez l'coute de vos objets : le pattern observer .................................................................................................... 623

Un pattern puissant : le pattern MVC ............................................................................................................................ 632

Un vritable assemblage : le pattern composite ........................................................................................................... 648

Partie 5 : Annexes ........................................................................................................................... 660

Annexe B : Les objets travaillant avec des flux ............................................................................................................. 665

Annexe C : Eclipse ........................................................................................................................................................ 666

Apprenez programmer en Java

Apprenez programmer en Java

Exemples de programmes raliss en Java

Partie 1 : Bien commencer en Java

Partie 1 : Bien commencer en Java

Partie 1 : Bien commencer en Java

avant tout vous assurer d'avoir un environnement

Partie 1 : Bien commencer en Java

Euh... a veut dire quoi, JSE ?

Partie 1 : Bien commencer en Java

Prsentation rapide de l'interface

Partie 1 : Bien commencer en Java

Partie 1 : Bien commencer en Java

Dans celui-ci, nous pourrons configurer Eclipse selon nos besoins.