Tutoriel : Apprenez à programmer en Java

Installer les outils nécessaires

JRE ou JDK

Commencez par télécharger l'environnement Java sur le site d'Oracle, comme le montre la figure suivante. Choisissez la dernière version stable.

Vous avez sans doute remarqué qu'on vous propose de télécharger soit le JRE, soit le JDK (Java Development Kit). La différence entre ces deux environnements est écrite, mais pour les personnes fâchées avec l'anglais, sachez que le JRE contient tout le nécessaire pour que vos programmes Java puissent être exécutés sur votre ordinateur ; le JDK, en plus de contenir le JRE, contient tout le nécessaire pour développer, compiler…

L'IDE contenant déjà tout le nécessaire pour le développement et la compilation, nous n'avons besoin que du JRE. Une fois que vous avez cliqué sur Download JRE, vous arrivez sur la page représentée à la figure suivante.

Cochez la case : Accept License Agreement puis cliquez sur le lien correspondant à votre système d'exploitation (x86 pour un système 32 bits et x64 pour un système 64 bits). Une popup de téléchargement doit alors apparaître.

Je vous ai dit que Java permet de développer différents types d'applications ; il y a donc des environnements permettant de créer des programmes pour différentes plates-formes :

• J2SE (Java 2 Standard Edition, celui qui nous intéresse dans cet ouvrage) : permet de développer des applications dites « client lourd », par exemple Word, Excel, la suite OpenOffice.org… Toutes ces applications sont des « clients lourds » . C'est ce que nous allons faire dans ce cours

• J2EE (Java 2 Enterprise Edition) : permet de développer des applications web en Java. On parle aussi de clients légers.

• J2ME (Java 2 Micro Edition) : permet de développer des applications pour appareils portables, comme des téléphones portables, des PDA…

Eclipse IDE

Avant toute chose, quelques mots sur le projet Eclipse. « Eclipse IDE » est un environnement de développement libre permettant de créer des programmes dans de nombreux langages de programmation (Java, C++, PHP…). C'est l'outil que nous allons utiliser pour programmer.

Je vous invite donc à télécharger Eclipse IDE. Une fois la page de téléchargement choisissez Eclipse IDE for Java Developers, en choisissant la version d'Eclipse correspondant à votre OS (Operating System = système d'exploitation), comme indiqué à la figure suivante.

Sélectionnez maintenant le miroir que vous souhaitez utiliser pour obtenir Eclipse. Voilà, vous n'avez plus qu'à attendre la fin du téléchargement.

Pour ceux qui l'avaient deviné, Eclipse est le petit logiciel qui va nous permettre de développer nos applications ou nos applets, et aussi celui qui va compiler tout ça. Notre logiciel va donc permettre de traduire nos futurs programmes Java en langage byte code, compréhensible uniquement par votre JRE, fraîchement installé.

La spécificité d'Eclipse IDE vient du fait que son architecture est totalement développée autour de la notion de plugin. Cela signifie que toutes ses fonctionnalités sont développées en tant que plugins. Pour faire court, si vous voulez ajouter des fonctionnalités à Eclipse, vous devez :

• télécharger le plugin correspondant ;

• copier les fichiers spécifiés dans les répertoires spécifiés ;

• démarrer Eclipse, et ça y est !

Vous devez maintenant avoir une archive contenant Eclipse. Décompressez-la où vous voulez, entrez dans ce dossier et lancez Eclipse. Au démarrage, comme le montre la figure suivante, Eclipse vous demande dans quel dossier vous souhaitez enregistrer vos projets ; sachez que rien ne vous empêche de spécifier un autre dossier que celui proposé par défaut. Une fois cette étape effectuée, vous arrivez sur la page d'accueil d'Eclipse. Si vous avez envie d'y jeter un oeil, allez-y !

Présentation rapide de l'interface

Je vais maintenant vous faire faire un tour rapide de l'interface d'Eclipse. Voici les principaux menus :

• File : C'est ici que nous pourrons créer de nouveaux projets Java, les enregistrer et les exporter le cas échéant.
  Les raccourcis à retenir sont :

  • ALT + SHIFT + N : nouveau projet ;

  • CTRL + S : enregistrer le fichier où l'on est positionné ;

  • CTRL + SHIFT + S : tout sauvegarder ;

  • CTRL + W : fermer le fichier où l'on est positionné ;

  • CTRL + SHIFT + W : fermer tous les fichiers ouverts.

• Edit : Dans ce menu, nous pourrons utiliser les commandes « copier » , « coller », etc.

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

La barre d'outils

La barre d'outils ressemble à la figure suivante.

Nous avons dans l'ordre :

1. nouveau général : cliquer sur ce bouton revient à faire Fichier > Nouveau ;

2. enregistrer : revient à faire CTRL + S ;

3. imprimer : ai-je besoin de préciser ?

4. exécuter la classe ou le projet spécifié : nous verrons ceci plus en détail ;

5. créer un nouveau projet : revient à faire Fichier > Nouveau > Java Project ;

6. créer une nouvelle classe : créer un nouveau fichier. Cela revient à faire Fichier > Nouveau > Classe.

Maintenant, je vais vous demander de créer un nouveau projet Java, comme indiqué aux figures suivantes.

Renseignez le nom de votre projet comme je l'ai fait dans le premier encadré de la deuxième figure. Vous pouvez aussi voir où sera enregistré ce projet. Un peu plus compliqué, maintenant : vous avez un environnement Java sur votre machine, mais dans le cas où vous en auriez plusieurs, vous pouvez aussi spécifier à Eclipse quel JRE utiliser pour ce projet, comme sur le deuxième encadré de la deuxième figure. Vous pourrez changer ceci à tout moment dans Eclipse en allant dans Window > Preferences, en dépliant l'arbre Java dans la fenêtre et en choisissant Installed JRE.

Vous devriez avoir un nouveau projet dans la fenêtre de gauche, comme à la figure suivante.

Pour boucler la boucle, ajoutons dès maintenant une nouvelle classe dans ce projet comme nous avons appris à le faire plus tôt via la barre d'outils. La figure suivante représente la fenêtre sur laquelle vous devriez tomber.

Dans l'encadré 1, nous pouvons voir où seront enregistrés nos fichiers Java. Dans l'encadré 2, nommez votre classe Java ; moi, j'ai choisi « sdz1 ». Dans l'encadré 3, Eclipse vous demande si cette classe a quelque chose de particulier. Eh bien oui ! Cochez
public static void main(String[] args) (nous reviendrons plus tard sur ce point), puis cliquez sur Finish. La fenêtre principale d'Eclipse se lance, comme à la figure suivante.

Avant de commencer à coder, nous allons explorer l'espace de travail. Dans l'encadré de gauche (le vert), vous trouverez le dossier de votre projet ainsi que son contenu. Ici, vous pourrez gérer votre projet comme bon vous semble (ajout, suppression…). Dans l'encadré positionné au centre (le bleu), je pense que vous avez deviné : c'est ici que nous allons écrire nos codes source. Dans l'encadré du bas (le rouge), c'est là que vous verrez apparaître le contenu de vos programmes… ainsi que les erreurs éventuelles ! Et pour finir, c'est dans l'encadré de droite (le violet), dès que nous aurons appris à coder nos propres fonctions et nos objets, que la liste des méthodes et des variables sera affichée.

Votre premier programme

Comme je vous l'ai maintes fois répété, les programmes Java sont, avant d'être utilisés par la machine virtuelle, précompilés en byte code (par votre IDE ou à la main). Ce byte code n'est compréhensible que par une JVM, et c'est celle-ci qui va faire le lien entre ce code et votre machine.

Vous aviez sûrement remarqué que sur la page de téléchargement 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 présente différemment selon qu'on se trouve sous Mac, sous Linux ou encore sous Windows. Par contre, le byte code, lui, reste le même quel que soit l'environnement avec lequel a été développé et précompilé votre programme Java. Conséquence directe : quel que soit l'OS sous lequel a été codé un programme Java, n'importe quelle machine pourra l'exécuter si elle dispose d'une JVM !

Eh bien, un byte code (il existe plusieurs types de byte code, mais nous parlons ici de celui créé par Java) n'est rien d'autre qu'un code intermédiaire entre votre code Java et le code machine. Ce code particulier se trouve dans les fichiers précompilés de vos programmes ; en Java, un fichier source a pour extension .java et un fichier précompilé a l'extension .class : c'est dans ce dernier que vous trouverez du byte code. Je vous invite à examiner un fichier .class à la fin de cette partie (vous en aurez au moins un), mais je vous préviens, c'est illisible !

Par contre, vos fichiers .java sont de simples fichiers texte dont l'extension a été changée. Vous pouvez donc les ouvrir, les créer ou encore les mettre à jour avec le Bloc-notes de Windows, par exemple. Cela implique que, si vous le souhaitez, vous pouvez écrire des programmes Java avec le Bloc-notes ou encore avec Notepad++.

Reprenons. Vous devez savoir que tous les programmes Java sont composés d'au moins une classe. Elle doit contenir une méthode appelée main : ce sera le point de démarrage de notre programme.

Une méthode est une suite d'instructions à exécuter. C'est un morceau de logique de notre programme. Une méthode contient :

• un en-tête : celui-ci va être en quelque sorte la carte d'identité de la méthode ;

• un corps : le contenu de la méthode, délimité par des accolades ;

• une valeur de retour : le résultat que la méthode va retourner.

Je vous avais demandé de créer un projet Java ; ouvrez-le ! Vous voyez la fameuse classe dont je vous parlais ? Ici, elle s'appelle « sdz1 », comme à la figure suivante. Vous pouvez voir que le mot class est précédé du mot public, dont nous verrons la signification lorsque nous programmerons des objets.

Pour le moment, ce que vous devez retenir, c'est que votre classe est définie par un mot clé (class), qu'elle a un nom (ici, « sdz1 ») et que son contenu est délimité par des accolades ({ }). Nous écrirons nos codes sources entre les accolades de la méthode main. La syntaxe de cette méthode est toujours la même :

public static void main(String[] args){
  //Contenu de votre classe
}

Bonne question ! Je vous ai dit précédemment que votre programme Java, avant de pouvoir être exécuté, doit être précompilé en byte code. Eh bien, la possibilité de forcer le compilateur à ignorer certaines instructions existe ! C’est ce qu’on appelle des commentaires, et deux syntaxes sont disponibles pour commenter son texte :

1. Les commentaires unilignes : introduits par les symboles « // », ils mettent tout ce qui les suit en commentaire, du moment que le texte se trouve sur la même ligne ;

2. Les commentaires multilignes : ils sont introduits par les symboles « /* » et se terminent par les symboles « */ ».

public static void main(String[] args){
  //Un commentaire
  //Un autre
  //Encore un autre

  /*
  Un commentaire
  Un autre
  Encore un autre
  */

Ceci n'est pas un commentaire !
}

C'est simple : au début, vous ne ferez que de très petits programmes. Mais dès que vous aurez pris de la bouteille, leurs tailles et le nombre de classes qui les composeront vont augmenter. Vous serez contents de trouver quelques lignes de commentaires au début de votre classe pour vous dire à quoi elle sert, ou encore des commentaires dans une méthode qui effectue des choses compliquées afin de savoir où vous en êtes dans vos traitements…

Il existe en fait une troisième syntaxe, mais elle a une utilité particulière. Elle permettra de générer une documentation pour votre programme (on l'appelle « Javadoc » pour « Java Documentation »). Je n'en parlerai que très peu, et pas dans ce chapitre. Nous verrons cela lorsque nous programmerons des objets, mais pour les curieux, je vous conseille le très bon cours de dworkin sur ce sujet disponible sur le Site du Zéro.

À partir de maintenant et jusqu'à ce que nous programmions des interfaces graphiques, nous allons faire ce qu'on appelle des programmes procéduraux. Cela signifie que le programme s'exécutera de façon procédurale, c'est-à-dire qui s'effectue de haut en bas, une ligne après l'autre. Bien sûr, il y a des instructions qui permettent de répéter des morceaux de code, mais le programme en lui-même se terminera une fois parvenu à la fin du code. Cela vient en opposition à la programmation événementielle (ou graphique) qui, elle, est basée sur des événements (clic de souris, choix dans un menu…).

Hello World

Maintenant, essayons de taper le code suivant :

public static void main(String[] args){
  System.out.print("Hello World !");
}

Une fois que vous avez saisi cette ligne de code dans votre méthode main, il vous faut lancer le programme. Si vous vous souvenez bien de la présentation faite précédemment, vous devez cliquer sur la flèche blanche dans un rond vert, comme à la figure suivante.

Si vous regardez dans votre console, dans la fenêtre du bas sous Eclipse, vous devriez voir quelque chose ressemblant à la figure suivante.

Expliquons un peu cette ligne de code.

Littéralement, elle signifie « la méthode print() va écrire « Hello World ! » en utilisant l'objet out de la classe System » . Avant que vous arrachiez les cheveux, voici quelques précisions :

• System : ceci correspond à l'appel d'une classe qui se nomme « System » . C'est une classe utilitaire qui permet surtout d'utiliser l'entrée et la sortie standard, c'est-à-dire la saisie clavier et l'affichage à l'écran.

• out : objet de la classe System qui gère la sortie standard.

• print : méthode qui écrit dans la console le texte passé en paramètre (entre les parenthèses).

Prenons le code suivant :

System.out.print("Hello World !");
System.out.print("My name is");
System.out.print("Cysboy");

Lorsque vous l'exécutez, vous devriez voir des chaînes de caractères qui se suivent sans saut de ligne. Autrement dit, ceci s'affichera dans votre console :

Hello World !My name isCysboy

Je me doute que vous souhaiteriez insérer un retour à la ligne pour que votre texte soit plus lisible… Pour cela, vous avez plusieurs solutions :

• soit vous utilisez un caractère d'échappement, ici  ;

• soit vous utilisez la méthode println() à la place de la méthode print().

Donc, si nous reprenons notre code précédent et que nous appliquons cela, voici ce que ça donnerait :

System.out.print("Hello World ! \n");
System.out.println("My name is");
System.out.println("\nCysboy");

Avec pour résultat :

Hello World !
My name is
 
Cysboy

Vous pouvez voir que :

• lorsque vous utilisez le caractère d'échappement , quelle que soit la méthode appelée, celle-ci ajoute immédiatement un retour à la ligne à son emplacement ;

• lorsque vous utilisez la méthode println(), celle-ci ajoute automatiquement un retour à la ligne à la fin de la chaîne passée en paramètre ;

• un caractère d'échappement peut être mis dans la méthode println().

J'en profite au passage pour vous mentionner deux autres caractères d'échappement :

1. va insérer un retour chariot, parfois utilisé aussi pour les retours à la ligne ;

2. va faire une tabulation.

Je vous propose maintenant de passer un peu de temps sur la compilation de vos programmes en ligne de commande. Cette partie n'est pas obligatoire, loin de là, mais elle ne peut être qu'enrichissante.

Compilation en ligne de commande (Windows)

Bienvenue donc aux plus curieux ! Avant de vous apprendre à compiler et à exécuter un programme en ligne de commande, il va vous falloir le JDK (Java SE Development Kit). C'est avec celui-ci que nous aurons de quoi compiler nos programmes. Le nécessaire à l'exécution des programmes est dans le JRE… mais il est également inclus dans le JDK. Je vous invite donc à retourner sur le site d'Oracle et à télécharger ce dernier. Une fois cette opération effectuée, il est conseillé de mettre à jour votre variable d'environnement %PATH%.

Votre « variable d'environnement ». C'est grâce à elle que Windows trouve des exécutables sans qu'il soit nécessaire de lui spécifier le chemin d'accès complet. Vous — enfin, Windows — en a plusieurs, mais nous ne nous intéresserons qu'à une seule. En gros, cette variable contient le chemin d'accès à certains programmes.

Par exemple, si vous spécifiez le chemin d'accès à un programme X dans votre variable d'environnement et que, par un malheureux hasard, vous n'avez plus aucun raccourci vers X, vous l'avez définitivement perdu dans les méandres de votre PC. Eh bien vous pourrez le lancer en faisant Démarrer > Exécuter et en tapant la commande X.exe (en partant du principe que le nom de l'exécutable est « X.exe »</minicode>).

J'y arrive. Une fois votre JDK installé, ouvrez le répertoire bin de celui-ci, ainsi que celui de votre JRE. Nous allons nous attarder sur deux fichiers.

Dans le répertoire bin de votre JRE, vous devez avoir un fichier nommé java.exe, que vous retrouvez aussi dans le répertoire bin de votre JDK. C'est grâce à ce fichier que votre ordinateur peut lancer vos programmes par le biais de la JVM. Le deuxième ne se trouve que dans le répertoire bin de votre JDK, il s'agit de javac.exe (Java compiler). C'est celui-ci qui va précompiler vos programmes Java en byte code.

Alors, pourquoi mettre à jour la variable d'environnement pour le JDK ? Eh bien, compiler et exécuter en ligne de commande revient à utiliser ces deux fichiers en leur précisant où se trouvent les fichiers à traiter. Cela veut dire que si l'on ne met pas à jour la variable d'environnement de Windows, il nous faudrait :

• ouvrir l'invite de commande ;

• se positionner dans le répertoire bin de notre JDK ;

• appeler la commande souhaitée ;

• préciser 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.

Allez dans le panneau de configuration de votre PC ; de là, cliquez sur l'icône Système ; choisissez l'onglet Avancé et vous devriez voir en bas un bouton nommé Variables d'environnement : cliquez dessus. Une nouvelle fenêtre s'ouvre. Dans la partie inférieure intitulée Variables système, cherchez la variable Path. Une fois sélectionnée, cliquez sur Modifier. Encore une fois, une fenêtre, plus petite celle-ci, s'ouvre devant vous. Elle contient le nom de la variable et sa valeur.

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 le chemin d'accès au répertoire bin de votre JDK, en terminant celui-ci par un point-virgule ! Chez moi, ça donne ceci : C:\Sun\SDK\jdk\bin.

Auparavant, ma variable d'environnement contenait, avant mon ajout :

%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;

Et maintenant :

%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;C:\Sun\SDK\jdk\bin;

Validez les changements : vous êtes maintenant prêts à compiler en ligne de commande.

Pour bien faire, allez dans le répertoire de votre premier programme et effacez le .class. Ensuite, faites Démarrer > Exécuter (ou encore touche Windows + R et tapez « cmd » .

Par exemple, lorsque j'ouvre la console, je me trouve dans le dossier C: oto iti et mon application se trouve dans le dossier C:\sdz, je fais donc :

cd ..
cd ..
cd sdz

Après de la première instruction, je me retrouve dans le dossier C: oto. Grâce à la deuxième instruction, j'arrive à la racine de mon disque. Via la troisième instruction, je me retrouve dans le dossier C:\sdz. Nous sommes maintenant dans le dossier contenant notre fichier Java ! Cela dit, nous pouvions condenser cela en :

cd ../../sdz

Maintenant, vous pouvez créer votre fichier .class en exécutant la commande suivante :

javac <nomDeFichier.java>

Si, dans votre dossier, vous avez un fichier test.java, compilez-le en faisant :

javac test.java

Et si vous n'avez aucun message d'erreur, vous pouvez vérifier que le fichier test.class est présent en utilisant l'instruction dir qui liste le contenu d'un répertoire. Cette étape franchie, vous pouvez lancer votre programme Java en faisant ce qui suit :

java <nomFichierClassSansExtension>

Ce qui nous donne :

java test

Et normalement, le résultat de votre programme Java s'affiche sous vos yeux ébahis !

Voilà : vous avez compilé et exécuté un programme Java en ligne de commande… Vous avez pu voir qu'il n'y a rien de vraiment compliqué et, qui sait, vous en aurez peut-être besoin un jour.

En résumé

• La JVM est le cœur de Java.

• Elle fait fonctionner vos programmes Java, précompilés en byte code.

• Les fichiers contenant le code source de vos programmes Java ont l'extension .java.

• Les fichiers précompilés correspondant à vos codes source Java ont l'extension .class.

• Le byte code est un code intermédiaire entre celui de votre programme et celui que votre machine peut comprendre.

• Un programme Java, codé sous Windows, peut être précompilé sous Mac et enfin exécuté sous Linux.

• Votre machine NE PEUT PAS comprendre le byte code, elle a besoin de la JVM.

• Tous les programmes Java sont composés d'au moins une classe.

• Le point de départ de tout programme Java est la méthode public static void main(String[] args).

• On peut afficher des messages dans la console grâce à ces instructions :

  • System.out.println, qui affiche un message avec un saut de ligne à la fin ;

  • System.out.print, qui affiche un message sans saut de ligne.

Petit rappel

Avant de commencer, je vous propose un petit rappel sur le fonctionnement d'un ordinateur et particulièrement sur la façon dont ce dernier interprète notre façon de voir le monde…

Vous n'êtes pas sans savoir que votre ordinateur ne parle qu'une seule langue : le binaire ! Le langage binaire est une simple suite de 0 et de 1. Vous devez vous rendre compte qu'il nous serait très difficile, en tant qu'êtres humains, d'écrire des programmes informatiques pour expliquer à nos ordinateurs ce qu'ils doivent faire, entièrement en binaire… Vous imaginez ! Des millions de 0 et de 1 qui se suivent ! Non, ce n'était pas possible ! De ce fait, des langages de programmation ont été créés afin que nous ayons à disposition des instructions claires pour créer nos programmes. Ces programmes sont ensuite compilés pour que nos instructions humainement compréhensibles soient, après coup, compréhensible par votre machine.

Le langage binaire est donc une suite de 0 et de 1 qu'on appelle bit. Si vous êtes habitués à la manipulation de fichiers (audio, vidéos, etc.) vous devez savoir qu'il existe plusieurs catégories de poids de programme (Ko, Mo, Go, etc.). Tous ces poids correspondent au système métrique informatique. Le tableau suivant présente les poids les plus fréquemment rencontrés :

Si vous vous posez cette question c'est parce que vous ne savez pas encore compter comme un ordinateur et que vous êtes trop habitués à utiliser un système en base 10. Je sais, c'est un peu confus… Pour comprendre pourquoi ce découpage est fait de la sorte, vous devez comprendre que votre façon de compter n'est pas identique à celle de votre machine. En effet, vous avez l'habitude de compter ainsi :

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ... 254, 255, 256 ... 12345678, 12345679, 12345680

Cette façon de compter repose sur une base 10, car elle se décompose en utilisant des puissances de 10. Ainsi, le nombre 1024 peut se décomposer de cette façon : 1*1000 + 0*100 + 2*10 + 4*1

Pour bien comprendre ce qui suit, vous devez aussi savoir que tout nombre élevé à la puissance 0 vaut 1, donc 10^0 = 1. Partant de ce postulat, nous pouvons donc réécrire la décomposition du nombre 1024 ainsi : 1*10^3 + 0*10^2 + 2*10^1 + 4*10^0. Nous multiplions donc la base utilisée, ordonnée par puissance, par un nombre compris entre 0 et cette base moins 1 (de 0 à 9).

Sauf que votre machine parle en binaire, elle compte donc en base 2. Cela revient donc à appliquer la décomposition précédente en remplaçant les 10 par des 2. Par contre, vous n'aurez que deux multiplicateurs possibles : 0 ou 1 (et oui, vous êtes en base 2). De ce fait, en base 2, nous pourrions avoir ce genre de chose : 1*2^3 + 1*2^2 + 0*2^1 + 1*2^0, qui peut se traduire de la sorte : 1*8 + 1*4 + 0*2 + 1*1 donc 8 + 4 + 0 + 1 soit 13.

Donc, 1101 en base 2 s'écrit 13 en base 10. Et donc pourquoi des paquets de 1024 comme délimiteur de poids ? Car ce nombre correspond à une puissance de 2 : 1024 = 2^1^0.

Dans le monde de l'informatique, il existe une autre façon de compter très répandue : l'hexadécimal. Dans ce cas, nous comptons en base 16 :

1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 1C.... 5E, 5F, 60, ... A53A, A53B, A53C...

Le côté pratique de cette notation c'est qu'elle se base sur une subdivision d'un octet. Pour représenter un nombre de 0 à 15 (donc les seize premiers nombres), 4 bits sont nécessaires : 0*2^3 + 0*2^2 + 0*2^1 + 0*2^0 = 0 et 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0 = 15. En fait, vous savez maintenant qu'un octet est un regroupement de 8 bits. Utiliser l'hexadécimal permet de simplifier la notation binaire car, si vous regroupez votre octet de bits en deux paquets de 4 bits, vous pouvez représenter chaque paquet avec un caractère hexadécimal. Voici un exemple :

10110100 -> 1011 0100
1011 (en base 2) = 11 (base 10) = B (en base 16)
0100 (en base 2) = 4 (base 10) = 4 (en base 16)
Donc 10110100 -> 1011 0100 -> B4

La figure suivante représente un nombre binaire plus conséquent :

Les différents types de variables

Nous allons commencer par découvrir comment créer des variables dans la mémoire. Pour cela, il faut les déclarer. Une déclaration de variable se fait comme ceci :

<Type de la variable> <Nom de la variable> ;

Cette opération se termine toujours par un point-virgule « ; » (comme toutes les instructions de ce langage). Ensuite, on l'initialise en entrant une valeur.

En Java, nous avons deux types de variables :

1. des variables de type simple ou « primitif » ;

2. des variables de type complexe ou des « objets ».

Ce qu'on appelle des types simples ou types primitifs, en Java, ce sont tout bonnement des nombres entiers, des nombres réels, des booléens ou encore des caractères, et vous allez voir qu'il y a plusieurs façons de déclarer certains de ces types.

Les variables de type numérique

Le type byte (1 octet) peut contenir les entiers entre -128 et +127.

byte temperature;
temperature = 64;

Le type short (2 octets) contient les entiers compris entre -32768 et +32767.

short vitesseMax;
vitesseMax = 32000;

Le type int (4 octets) va de -2*109 à 2*109 (2 et 9 zéros derrière… ce qui fait déjà un joli nombre).

int temperatureSoleil;
temperatureSoleil = 15600000; //La température est exprimée en kelvins

Le type long (8 octets) peut aller de -9*10^18 à 9*10^18 (encore plus gros…).

long anneeLumiere;
anneeLumiere = 9460700000000000L;

Le type float (4 octets) est utilisé pour les nombres avec une virgule flottante.

float pi;
pi = 3.141592653f;

Ou encore :

float nombre;
nombre = 2.0f;

Le type double (8 octets) est identique à float, si ce n'est qu'il contient plus de chiffres derrière la virgule et qu'il n'a pas de suffixe.

double division;
division = 0.333333333333333333333333333333333333333333334d;

Des variables stockant un caractère

Le type char contient un caractère stocké entre apostrophes (« ' ' »), comme ceci :

char caractere;
caractere = 'A';

Des variables de type booléen

Le type boolean, lui, ne peut contenir que deux valeurs  : true (vrai) ou false (faux), sans guillemets (ces valeurs sont natives dans le langage, il les comprend directement et sait les interpréter).

boolean question;
question = true;

Et aussi le type String

Le type String permet de gérer les chaînes de caractères, c'est-à-dire le stockage de texte.

Il s'agit d'une variable d'un type plus complexe que l'on appelle objet. Vous verrez que celle-ci s'utilise un peu différemment des variables précédentes :

//Première méthode de déclaration
String phrase;
phrase = "Titi et Grosminet";

//Deuxième méthode de déclaration
String str = new String();
str = "Une autre chaîne de caractères";

//Troisième méthode de déclaration
String string = "Une autre chaîne";

//Quatrième méthode de déclaration
String chaine = new String("Et une de plus !");

Cela a été mentionné plus haut : String n'est pas un type de variable, mais un objet. Notre variable est un objet, on parle aussi d'une instance : ici, une instance de la classe String. Nous y reviendrons lorsque nous aborderons les objets.

C'est simple : il s'agit d'une convention de nommage. En fait, c'est une façon d'appeler nos classes, nos variables, etc. Il faut que vous essayiez de la respecter 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 le nom d'une variable est composé de plusieurs mots, le premier commence par une minuscule, le ou les autres par une majuscule, et ce, sans séparation ;

• tout ceci sans accentuation !

Je sais que la première classe que je vous ai demandé de créer ne respecte pas cette convention, mais je ne voulais pas vous en parler à ce moment-là… Donc, à présent, je vous demanderai de ne pas oublier ces règles !

Voici quelques exemples de noms de classes et de variables :

public class Toto{}
public class Nombre{}
public class TotoEtTiti{}
String chaine;
String chaineDeCaracteres;
int nombre;
int nombrePlusGrand;

Donc, pour en revenir au pourquoi du comment, je vous ai dit que les variables de type String sont des objets. Les objets sont définis par une ossature (un squelette) qui est en fait une classe. Ici, nous utilisons un objet String défini par une classe qui s'appelle « String » ; c'est pourquoi String a une majuscule et pas int, float, etc., qui eux ne sont pas définis par une classe.

Faites donc bien attention lors de vos déclarations de variables… Une petite astuce quand même (enfin deux, plutôt) : on peut très bien compacter les phases de déclaration et d'initialisation en une seule phase ! Comme ceci :

int entier = 32;
float pi = 3.1416f;
char carac = 'z';
String mot = new String("Coucou");

Et lorsque nous avons plusieurs variables d'un même type, nous pouvons résumer tout ceci à une déclaration :

int nbre1 = 2, nbre2 = 3, nbre3 = 0;

Ici, toutes les variables sont des entiers, et toutes sont initialisées.

Avant de nous lancer dans la programmation, nous allons faire un peu de mathématiques avec nos variables.

Les opérateurs arithmétiques

Les opérateurs arithmétiques sont ceux que l'on apprend à l'école primaire… ou presque :

• « + » : permet d'additionner deux variables numériques (mais aussi de concaténer des chaînes de caractères ; ne vous inquiétez pas, on aura l'occasion d'y revenir).

• « - » : permet de soustraire deux variables numériques.

• « * » : permet de multiplier deux variables numériques.

• « / » : permet de diviser deux variables numériques (mais je crois que vous aviez deviné).

• « % » : permet de renvoyer le reste de la division entière de deux variables de type numérique ; cet opérateur s'appelle le modulo.

Quelques exemples de calcul

int nbre1, nbre2, nbre3;  //Déclaration des variables
 
nbre1 = 1 + 3;            //nbre1 vaut 4
nbre2 = 2 * 6;            //nbre2 vaut 12
nbre3 = nbre2 / nbre1;    //nbre3 vaut 3
nbre1 = 5 % 2;            //nbre1 vaut 1, car 5 = 2 * 2 + 1
nbre2 = 99 % 8;           //nbre2 vaut 3, car 99 = 8 * 12 + 3
nbre3 = 6 % 3;            //là, nbre3 vaut 0, car il n'y a pas de reste

Ici, nous voyons bien que nous pouvons affecter des résultats d'opérations sur des nombres à nos variables, mais aussi affecter des résultats d'opérations sur des variables de même type.

Maintenant, voici quelque chose que les personnes qui n'ont jamais programmé ont du mal à intégrer. Je garde la même déclaration de variables que ci-dessus.

int nbre1, nbre2, nbre3;    //Déclaration des variables
nbre1 = nbre2 = nbre3 = 0;  //Initialisation
 
nbre1 = nbre1 + 1;     //nbre1 = lui-même, donc 0 + 1 => nbre1 = 1
nbre1 = nbre1 + 1;     //nbre1 = 1 (cf. ci-dessus), maintenant, nbre1 = 1 + 1 = 2
nbre2 = nbre1;         //nbre2 = nbre1 = 2
nbre2 = nbre2 * 2;     //nbre2 = 2 => nbre2 = 2 * 2 = 4
nbre3 = nbre2;         //nbre3 = nbre2 = 4
nbre3 = nbre3 / nbre3; //nbre3 = 4 / 4 = 1
nbre1 = nbre3;         //nbre1 = nbre3 = 1
nbre1 = nbre1 - 1;     //nbre1 = 1 - 1 = 0

Et là aussi, il existe une syntaxe qui raccourcit l'écriture de ce genre d'opérations. Regardez bien :

nbre1 = nbre1 + 1;
nbre1 += 1;
nbre1++;
++nbre1;

Les trois premières syntaxes correspondent exactement à la même opération. La troisième sera certainement celle que vous utiliserez le plus, mais elle ne fonctionne que pour augmenter d'une unité la valeur de nbre1 ! Si vous voulez augmenter de 2 la valeur d'une variable, utilisez les deux syntaxes précédentes. On appelle cela l'incrémentation. La dernière fait la même chose que la troisième, mais il y a une subtilité dont nous reparlerons dans le chapitre sur les boucles.

Pour la soustraction, la syntaxe est identique :

nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;

Même commentaire que pour l'addition, sauf qu'ici, la troisième syntaxe s'appelle la décrémentation.

Les raccourcis pour la multiplication fonctionnent de la même manière ; regardez plutôt :

nbre1 = nbre1 * 2;
nbre1 *= 2;
nbre1 = nbre1 / 2;
nbre1 /= 2;

Voici les raisons de ma mise en garde : comme je vous l'ai dit précédemment, chaque type de variable a une capacité différente et, pour faire simple, nous allons comparer nos variables à différents récipients. Une variable de type :

• byte correspondrait à un dé à coudre, elle ne peut pas contenir grand-chose ;

• int serait un verre, c'est déjà plus grand ;

• double serait un baril. Pfiou, on en met là-dedans

À partir de là, ce n'est plus qu'une question de bon sens. Vous devez facilement constater qu'il est possible de mettre le contenu d'un dé à coudre dans un verre ou un baril. Par contre, si vous versez le contenu d'un baril dans un verre… il y en a plein par terre !
Ainsi, si nous affectons le résultat d'une opération sur deux variables de type double dans une variable de type int, le résultat sera de type int et ne sera donc pas un réel mais un entier.

Pour afficher le contenu d'une variable dans la console, appelez l'instruction System.out.println(maVariable);, ou encore System.out.print(maVariable);.

Je suppose que vous voudriez aussi mettre du texte en même temps que vos variables… Eh bien sachez que l'opérateur « + » sert aussi d'opérateur de concaténation, c'est-à-dire qu'il permet de mélanger du texte brut et des variables. Voici un exemple d'affichage avec une perte de précision :

double nbre1 = 10, nbre2 = 3;
int resultat = (int)(nbre1 / nbre2);
System.out.println("Le résultat est = " + resultat);

Cependant, pour le bien de ce chapitre, nous n'allons pas utiliser cette méthode. Vous allez constater que le résultat affiché est 3 au lieu de 3.33333333333333… Et je pense que ceci vous intrigue :

int resultat = (int)(nbre1 / nbre2);

.

Avant que je ne vous explique, remplacez la ligne citée précédemment par :

int resultat = nbre1 / nbre2;

.

Vous allez voir qu'Eclipse n'aime pas du tout ! Pour comprendre cela, nous allons voir les conversions.

Les conversions, ou « cast »

Comme expliqué précédemment, 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 déplaise, vous serez amenés à convertir des variables.

D'un type int en type float :

int i = 123;
float j = (float)i;

D'un type int en double :

int i = 123;
double j = (double)i;

Et inversement :

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.

Vous l'avez vu : nous pouvons passer directement d'un type int à un type double. L'inverse, cependant, ne se déroulera pas sans une perte de précision. En effet, comme vous avez pu le constater, lorsque nous castons un double en int, la valeur de ce double est tronquée, ce qui signifie que l'int en question ne prendra que la valeur entière du double, quelle que soit celle des décimales.

Pour en revenir à notre problème de tout à l’heure, il est aussi possible de caster le résultat d'une opération mathématique en la mettant entre « ( ) » et en la précédant du type de cast souhaité. Donc :

double nbre1 = 10, nbre2 = 3;
int resultat = (int)(nbre1 / nbre2);
System.out.println("Le résultat est = " + resultat);

Voilà qui fonctionne parfaitement. Pour bien faire, vous devriez mettre le résultat de l'opération en type double. Et si on fait l'inverse : si nous déclarons deux entiers et que nous mettons le résultat dans un double ? Voici une possibilité :

int nbre1 = 3, nbre2 = 2;
double resultat = nbre1 / nbre2;
System.out.println("Le résultat est = " + resultat);

Vous aurez « 1 » comme résultat. Je ne caste pas ici, car un double peut contenir un int.

En voici une autre :

int nbre1 = 3, nbre2 = 2;
double resultat = (double)(nbre1 / nbre2);
System.out.println("Le résultat est = " + resultat);

Idem… Afin de comprendre pourquoi, vous devez savoir qu'en Java, comme dans d'autres langages d'ailleurs, il y a la notion de priorité d'opération ; et là, nous en avons un très bon exemple !

Dans le cas qui nous intéresse, il y a trois opérations :

• un calcul ;

• un cast sur le résultat de l'opération ;

• une affectation dans la variable resultat.

Eh bien, Java exécute notre ligne dans cet ordre ! Il fait le calcul (ici 3/2), il caste le résultat en double, puis il l'affecte dans notre variable resultat.

Vous vous demandez sûrement pourquoi vous n'avez pas 1.5… C'est simple : lors de la première opération de Java, la JVM voit un cast à effectuer, mais sur un résultat 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 résultat correct, il faudrait caster chaque nombre avant de faire l'opération, comme ceci :

int nbre1 = 3, nbre2 = 2;
double resultat = (double)(nbre1) / (double)(nbre2);
System.out.println("Le résultat est = " + resultat); 
//affiche : Le résultat est = 1.5

Je ne vais pas trop détailler ce qui suit (vous verrez cela plus en détail dans la partie sur la programmation orientée objet) ; mais vous allez maintenant apprendre à transformer l'argument d'un type donné, int par exemple, en String.

int i = 12;
String j = new String();
j = j.valueOf(i);

j est donc une variable de type String contenant la chaîne de caractères 12. Sachez que ceci fonctionne aussi avec les autres types numériques. Voyons maintenant comment faire marche arrière en partant de ce que nous venons de faire.

int i = 12;
String j = new String();
j = j.valueOf(i);
int k = Integer.valueOf(j).intValue();

Maintenant, la variable k de type int contient le nombre « 12 ».

Depuis Java 7 : le formatage des nombres

Comme vous le savez sûrement, le langage Java est en perpétuelle évolution. Les concepteurs ne cessent d'ajouter de nouvelles fonctionnalités qui simplifient la vie des développeurs. Ainsi dans la version 7 de Java, vous avez la possibilité de formater vos variables de types numériques avec un séparateur, l'underscore (_), ce qui peut s'avérer très pratique pour de grands nombres qui peuvent être difficiles à lire. Voici quelques exemples :

double nombre = 1000000000000;
//Peut s'écrire ainsi
double nombre = 1____000____000___000_000;
//Le nombre d'underscore n'a pas d'importance, vous pouvez en mettre autant que vous le souhaitez

//Voici quelques autres exemple d'utilisation
int entier = 32_000;
double monDouble = 12_34_56_78_89_10;
double monDouble2 = 1234_5678_8910;

Les underscore doivent être placés entre deux caractères numériques : ils ne peuvent donc pas être utilisés en début ou en fin de déclaration ni avant ou après un séparateur de décimal. Ainsi, ces déclarations ne sont pas valides :

double d = 123_.159;
int entier = _123;
int entier2 = 123_;

Avant Java 7, il était possible de déclarer des expressions numériques en hexadécimal, en utilisant le préfixe « 0x » :

int entier = 255; //Peut s'écrire « int entier = 0xFF; »
int entier = 20; //Peut s'écrire « int entier = 0x14; »
int entier = 5112; //Peut s'écrire « int entier = 0x13_F8; »

Depuis java 7, vous avez aussi la possibilité d'utiliser la notation binaire, en utilisant le préfixe « 0b » :

int entier = 0b1111_1111; //Est équivalent à : « int entier = 255; »
int entier = 0b1000_0000_0000; //Est équivalent à : « int entier = 2048; »
int entier = 0b100000000000; //Est équivalent à : « int entier = 2048; »

Certains programmes Java travaillent directement sur les bits, il peut donc être plus pratique de les représenter ainsi avant de les manipuler.

• Les variables sont essentielles dans la construction de programmes informatiques.

• On affecte une valeur dans une variable avec l'opérateur égal (« = »).

• Après avoir affecté une valeur à une variable, l'instruction doit se terminer par un point-virgule (« ; »).

• Vos noms de variables ne doivent contenir ni caractères accentués ni espaces et doivent, dans la mesure du possible, respecter la convention de nommage Java.

• Lorsque vous effectuez des opérations sur des variables, prenez garde à leur type : vous pourriez perdre en précision.

• Vous pouvez caster un résultat en ajoutant un type devant celui-ci : (int), (double), etc.

• Prenez garde aux priorités lorsque vous castez le résultat d'opérations, faute de quoi ce dernier risque d'être incorrect.

La classe Scanner

Je me doute qu'il vous tardait de pouvoir communiquer avec votre application… Le moment est enfin venu ! Mais je vous préviens, la méthode que je vais vous donner présente des failles. Je vous fais confiance pour ne pas rentrer n'importe quoi n'importe quand !

Je vous ai dit que vos variables de type String sont en réalité 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. Cet objet peut prendre différents paramètres, mais ici nous n'en utiliserons qu'un : celui qui correspond à l'entrée standard en Java. Lorsque vous faites System.out.println();, je vous rappelle que vous appliquez la méthode println() sur la sortie standard ; ici, nous allons utiliser l'entrée standard System.in. Donc, avant d'indiquer à Java qu'il faut lire ce que nous allons taper au clavier, nous devrons instancier un objet Scanner. Avant de vous expliquer ceci, créez une nouvelle classe et tapez cette ligne de code dans votre méthode main :

Scanner sc = new Scanner(System.in);

Vous devez avoir une jolie vague rouge sous le mot Scanner. Cliquez sur la croix rouge sur la gauche et faites un double-clic sur Import 'Scanner' java.util (figure suivante). Et là, l'erreur disparaît !

Maintenant, regardez au-dessus de la déclaration de votre classe, vous devriez voir cette ligne :

import java.util.Scanner;

Voilà ce que nous avons fait. Je vous ai dit qu'il fallait indiquer à Java où se trouve la classe Scanner. Pour faire ceci, nous devons importer la classe Scanner grâce à l'instruction import. La classe que nous voulons se trouve dans le package java.util.

Les classes qui se trouvent dans les packages autres que java.lang (package automatiquement importé par Java, on y trouve entre autres la classe System) sont à importer à la main dans vos classes Java pour pouvoir vous en servir. La façon dont nous avons importé la classe java.util.Scanner dans Eclipse est très commode. Vous pouvez aussi le faire manuellement :

//Ceci importe la classe Scanner du package java.util
import java.util.Scanner; 
//Ceci importe toutes les classes du package java.util
import java.util.*;

Récupérer ce que vous tapez

Voici l'instruction pour permettre à Java de récupérer ce que vous avez saisi pour ensuite l'afficher :

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 lancée, le message que vous avez écrit auparavant s'affiche dans la console, en bas d'Eclipse. Pensez à cliquer dans la console afin que ce que vous saisissez y soit écrit et que Java puisse récupérer ce que vous avez inscrit (figure suivante) !

Si vous remplacez la ligne de code qui récupère une chaîne de caractères comme suit :

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 devriez constater que lorsque vous introduisez votre variable de type Scanner et que vous introduisez le point permettant d'appeler des méthodes de l'objet, Eclipse vous propose une liste de méthodes associées à cet objet (ceci s'appelle l'autocomplétion) ; de plus, lorsque vous commencez à taper le début de la méthode nextInt(), le choix se restreint jusqu'à ne laisser que cette seule méthode.

Exécutez et testez ce programme : vous verrez qu'il fonctionne à la perfection. Sauf… si vous saisissez autre chose qu'un nombre entier !

Vous savez maintenant que pour lire un int, vous devez utiliser nextInt(). De façon générale, dites-vous que pour récupérer un type de variable, il vous suffit d'appeler next<Type de variable commençant par une majuscule> (rappelez-vous de la convention de nommage Java).

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
double d = sc.nextDouble();
long l = sc.nextLong();
byte b = sc.nextByte();
//Etc.

Voici comment on pourrait récupérer un caractère :

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 caractère : " + carac);

Qu'avons-nous fait ici ? Nous avons récupéré une chaîne de caractères, puis utilisé une méthode de l'objet String (ici, charAt(0) ) afin de récupérer le premier caractère saisi. Même si vous tapez une longue chaîne de caractères, l'instruction charAt(0) ne renverra que le premier caractère.

Vous devez vous demander pourquoi charAt(0) et non charAt(1) : nous aborderons ce point lorsque nous verrons les tableaux… Jusqu'à ce qu'on aborde les exceptions, je vous demanderai d'être rigoureux et de faire attention à ce que vous attendez comme type de données afin d'utiliser la méthode correspondante.

Une précision s'impose, toutefois : la méthode nextLine() récupère le contenu de toute la ligne saisie et replace la « tête de lecture » au début d'une autre ligne. Par contre, si vous avez invoqué une méthode comme nextInt(), nextDouble() et que vous invoquez directement après la méthode nextLine(), celle-ci ne vous invitera pas à saisir une chaîne de caractères : elle videra la ligne commencée par les autres instructions. En effet, celles-ci ne repositionnent pas la tête de lecture, l'instruction nextLine() le fait à leur place. Pour faire simple, ceci :

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 chaîne : ");
    String str = sc.nextLine();      
    System.out.println("FIN ! ");
   }
}

… ne vous demandera pas de saisir une chaîne et affichera directement « Fin ». Pour pallier ce problème, il suffit de vider la ligne après les instructions ne le faisant pas automatiquement :

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 chaîne : ");
    //On vide la ligne avant d'en lire une autre
    sc.nextLine();
    String str = sc.nextLine();      
    System.out.println("FIN ! ");
  }
}

En résumé

• La lecture des entrées clavier se fait via l'objet Scanner.

• Ce dernier se trouve dans le package java.util que vous devrez importer.

• Pour pouvoir récupérer ce vous allez taper dans la console, vous devrez initialiser l'objet Scanner avec l'entrée standard, System.in.

• Il y a une méthode de récupération de données pour chaque type (sauf les char) : nextLine() pour les String, nextInt() pour les int ...

La structure if… else

Avant de pouvoir créer et évaluer des conditions, vous devez savoir que pour y parvenir, nous allons utiliser ce qu'on appelle des « opérateurs logiques ». Ceux-ci sont surtout utilisés lors de conditions (si [test] alors [faire ceci]) pour évaluer différents cas possibles. Voici les différents opérateurs à connaître :

• « == » : permet de tester l'égalité.

• « != » : permet de tester l’inégalité.

• « < » : strictement inférieur.

• « <= » : inférieur ou égal.

• « > » : strictement supérieur.

• « >= » : supérieur ou égal.

• « && » : l'opérateur ET. Il permet de préciser une condition

• « || » : le OU. Même combat que le précédent.

• «  ? : » : l'opérateur ternaire. Pour celui-ci, vous comprendrez mieux avec un exemple qui sera donné vers la fin de ce chapitre.

Comme je vous l'ai dit dans le chapitre précédent, les opérations en Java sont soumises à des priorités. Tous ces opérateurs se plient à cette règle, de la même manière que les opérateurs arithmétiques…

Imaginons un programme qui demande à un utilisateur d'entrer un nombre entier relatif (qui peut être soit négatif, soit nul, soit positif). Les structures conditionnelles vont nous permettre de gérer ces trois cas de figure. La structure de ces conditions ressemble à ça :

if(//condition)
{
  //Exécution des instructions si la condition est remplie
}
else
{
  //Exécution des instructions si la condition n'est pas remplie
}

Cela peut se traduire par « si… sinon… ».

Le résultat de l'expression évaluée par l'instruction if sera un boolean, donc soit true, soit false. La portion de code du bloc if ne sera exécutée que si la condition est remplie. Dans le cas contraire, c'est le bloc de l'instruction else qui le sera. Mettons notre petit exemple en pratique :

int i = 10;
 
if (i < 0)
  System.out.println("le nombre est négatif");
else
  System.out.println("le nombre est positif");

Essayez ce petit code, et vous verrez comment il fonctionne. Dans ce cas, notre classe affiche « le nombre est positif ». Expliquons un peu ce qui se passe.

• Dans un premier temps, la condition du if est testée : elle dit « si i est strictement inférieur à 0 alors fais ça ».

• Dans un second temps, vu que la condition précédente est fausse, le programme exécute le else.

Bien observé. En fait, les accolades sont présentes dans la structure « normale » des conditions, mais lorsque le code à l'intérieur de l'une d'entre elles n'est composé que d'une seule ligne, 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 ajouter une condition. Comment faire ? La condition du if est remplie si le nombre est strictement négatif, ce qui n'est pas le cas ici puisque nous allons le mettre à 0. Le code contenu dans la clause else est donc exécuté si le nombre est égal ou strictement supérieur à 0. Il nous suffit d'ajouter une condition à l'intérieur de la clause else, comme ceci :

int i = 0;
if (i < 0)
{
  System.out.println("Ce nombre est négatif !");
} 
else
{
  if(i == 0)
    System.out.println("Ce nombre est nul !");
 
  else
    System.out.println("Ce nombre est positif !");
 
}

Maintenant que vous avez tout compris, je vais vous présenter une autre façon d'écrire ce code, avec le même résultat : on ajoute juste un petit « sinon si… ».

int i = 0;
if (i < 0)
  System.out.println("Ce nombre est négatif !");      
  
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 négatif alors le code de cette condition est exécuté.

• sinon si i est strictement positif alors le code de cette condition est exécuté.

• sinon i est forcément nul alors le code de cette condition est exécuté.

Ici, je vais très fortement insister sur un point : regardez l'affichage du code et remarquez le petit décalage entre le test et le code à exécuter. On appelle cela l'indentation !

Pour vous repérer dans vos futurs programmes, cela sera très 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. Il sera difficile de distinguer les tests du code. Vous n'êtes pas obligés de le faire, mais je vous assure que vous y viendrez.

Les conditions multiples

Derrière ce nom barbare se cachent simplement plusieurs tests dans une instruction if (ou else if). Nous allons maintenant utiliser les opérateurs logiques que nous avons vus au début en vérifiant si un nombre donné appartient à un intervalle connu. Par exemple, on va vérifier si un entier est compris entre 50 et 100.

int i = 58;
if(i < 100 && i > 50) 
  System.out.println("Le nombre est bien dans l'intervalle.");
else
  System.out.println("Le nombre n'est pas dans l'intervalle.");

Nous avons utilisé l'opérateur &&. La condition de notre if est devenue : « si i est inférieur à 100 ET supérieur à 50 ».

Cet opérateur vous initie à la notion d'intersection d'ensembles. Ici, nous avons deux conditions qui définissent un ensemble chacune :

• i < 100 définit l'ensemble des nombres inférieurs à 100 ;

• i > 50 définit l'ensemble des nombres supérieurs à 50.

L'opérateur « && » permet de faire l'intersection de ces ensembles. La condition regroupe donc les nombres qui appartiennent à ces deux ensembles, c’est-à-dire les nombres de 51 à 99 inclus. Réfléchissez bien à l'intervalle que vous voulez définir. Voyez ce code :

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 je ne connais aucun nombre qui soit à la fois plus petit et plus grand que 100 ! Reprenez le code précédent et remplacez l'opérateur « && » par « || » (petit rappel, il s'agit du OU). À l'exécution du programme et après plusieurs tests de valeur pour i, vous pourrez vous apercevoir que tous les nombres remplissent cette condition, sauf 100.

La structure switch

Le switch est surtout utilisé lorsque nous voulons des conditions « à la carte ». Prenons l'exemple d'une interrogation comportant deux questions : pour chacune d'elles, on peut obtenir uniquement 0 ou 10 points, ce qui nous donne au final trois notes et donc trois appréciations possibles, comme ceci :

• 0/20 : tu peux revoir ce chapitre, petit Zéro !

• 10/20 : je crois que tu as compris l'essentiel ! Viens relire ce chapitre à l'occasion.

• 20/20 : bravo !

Dans ce genre de cas, on utilise un switch pour éviter des else if à répétition et pour alléger un peu le code. Je vais vous montrer comment se construit une instruction switch ; puis nous allons l'utiliser tout de suite après.

Syntaxe

switch (/*Variable*/)
{
  case /*Argument*/:
    /*Action*/;
    break;        
  default:
    /*Action*/;             
}

Voici les opérations qu'effectue cette expression :

• La classe évalue l'expression figurant après le switch (ici /*Variable*/).

• Si la première languette (case /*Valeur possible de la variable*/:) correspond à la valeur de /*Variable*/, l'instruction figurant dans celle-ci sera exécutée.

• Sinon, on passe à la languette suivante, et ainsi de suite.

• Si aucun des cas ne correspond, la classe va exécuter ce qui se trouve dans l'instruction default:/*Action*/;. Voyez ceci comme une sécurité.

Notez bien la présence de l'instruction break;. Elle permet de sortir du switch si une languette correspond. Pour mieux juger de l'utilité de cette instruction, enlevez tous les break; et compilez votre programme. Vous verrez le résultat… Voici un exemple de switch que vous pouvez essayer :

int note = 10; //On imagine que la note maximale est 20

switch (note)
{
  case 0:
    System.out.println("Ouch !");
    break;
  case 10:
    System.out.println("Vous avez juste la moyenne.");
    break;
  case 20:
    System.out.println("Parfait !");
    break;
  default:
    System.out.println("Il faut davantage travailler.");
}

Si vous avez essayé ce programme en supprimant l'instruction break;, vous avez dû vous rendre compte que le switch exécute le code contenu dans le case 10:, mais aussi dans tous ceux qui suivent ! L'instruction break; permet de sortir de l'opération en cours. Dans notre cas, on sort de l'instruction switch, mais nous verrons une autre utilité à break; dans le chapitre suivant.

Depuis la version 7 de Java, l'instruction switch accepte les objets de type String en paramètre. De ce fait, cette instruction est donc valide :

String chaine = "Bonjour";

switch(chaine) {
  case "Bonjour":
    System.out.println("Bonjour monsieur !");
    break;
  case "Bonsoir":
    System.out.println("Bonsoir monsieur !");
    break;
  default:
    System.out.println("Bonjoir ! :p");
}

La condition ternaire

Les conditions ternaires sont assez complexes et relativement peu utilisées. Je vous les présente ici à titre indicatif. La particularité de ces conditions réside dans le fait que trois opérandes (c'est-à-dire des variables ou des constantes) sont mis en jeu, mais aussi que ces conditions sont employées pour affecter des données à une variable. Voici à quoi ressemble la structure de ce type de condition :

int x = 10, y = 20;
int max = (x < y) ? y : x ; //Maintenant, max vaut 20

Décortiquons ce qu'il se passe :

• Nous cherchons à affecter une valeur à notre variable max, mais de l'autre côté de l'opérateur d'affectation se trouve une condition ternaire…

• Ce qui se trouve entre les parenthèses est évalué : x est-il plus petit que y ? Donc, deux cas de figure se profilent à l'horizon :

  • si la condition renvoie true (vrai), qu'elle est vérifiée, la valeur qui se trouve après le ? sera affectée ;

  • sinon, la valeur se trouvant après le symbole: sera affectée.

• L'affectation est effective : vous pouvez utiliser votre variable max.

Vous pouvez également faire des calculs (par exemple) avant d'affecter les valeurs :

int x = 10, y = 20;
int max = (x < y) ? y * 2 : x * 2 ; //Ici, max vaut 2 * 20 donc 40

N'oubliez pas que la valeur que vous allez affecter à votre variable doit être du même type que votre variable. Sachez aussi que rien ne vous empêche d'insérer une condition ternaire dans une autre condition ternaire :

int x = 10, y = 20;

int max = (x < y) ? (y < 10) ? y % 10 : y * 2 : x ; //Max vaut 40

//Pas très facile à lire…
//Vous pouvez entourer votre deuxième instruction ternaire par des parenthèses pour mieux voir :

max = (x < y) ? ((y < 10) ? y % 10 : y * 2) : x ; //Max vaut 40

• Les conditions vous permettent de n'exécuter que certains morceaux de code.

• Il existe plusieurs sortes de structures conditionnelles :

  • la structure if... elseif... else ;

  • la structure switch... case... default ;

  • la structure  ? :.

• Si un bloc d'instructions contient plus d'une ligne, vous devez l'entourer d'accolades afin de bien en délimiter le début et la fin.

• Pour pouvoir mettre une condition en place, vous devez comparer des variables à l'aide d'opérateurs logiques.

• Vous pouvez mettre autant de comparaisons renvoyant un boolean que vous le souhaitez dans une condition.

• Pour la structure switch, pensez à mettre les instructions break; si vous ne souhaitez exécuter qu'un seul bloc case.

La boucle while

Pour décortiquer précisément ce qui se passe dans une boucle, nous allons voir comment elle se construit ! Une boucle commence par une déclaration : ici while. Cela veut dire, à peu de chose près, « tant que ». Puis nous avons une condition : c'est elle qui permet à la boucle de s'arrêter. Une boucle n'est utile que lorsque nous pouvons la contrôler, et donc lui faire répéter une instruction un certain nombre de fois. C'est à ça que servent les conditions. Ensuite nous avons une ou plusieurs instructions : c'est ce que va répéter notre boucle (il peut même y avoir des boucles dans une boucle !

while (/* Condition */)
{
  //Instructions à répéter
}

Nous allons travailler sur un exemple concret mais d'abord, réfléchissons à « comment notre boucle va travailler ». Pour cela, il faut déterminer notre exemple.

Nous allons afficher « Bonjour, <un prénom> », prénom qu'il faudra taper au clavier ; puis nous demanderons si l'on veut recommencer. Pour cela, il nous faut une variable qui va recevoir le prénom, donc dont le type sera String, ainsi qu'une variable pour récupérer la réponse. Et là, plusieurs choix s'offrent à nous : soit un caractère, soit une chaîne de caractères, soit un entier. Ici, nous prendrons une variable de type char. C'est parti !

//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 réponse donnée est égale à oui…
while (reponse == 'O')
{
  //On affiche une instruction
  System.out.println("Donnez un prénom : ");
  //On récupère le prénom saisi
  prenom = sc.nextLine();
  //On affiche notre phrase avec le prénom
  System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
  //On demande si la personne veut faire un autre essai
  System.out.println("Voulez-vous réessayer ? (O/N)");
  //On récupère la réponse de l'utilisateur
  reponse = sc.nextLine().charAt(0);
}
 
System.out.println("Au revoir…");
//Fin de la boucle

Vous avez dû cligner des yeux en lisant reponse = sc.nextLine().charAt(0);. Rappelez-vous comment on récupère un char avec l'objet Scanner : nous devons récupérer un objet String et ensuite prendre le premier caractère de celui-ci ! Eh bien cette syntaxe est une contraction de ce que je vous avais fait voir auparavant.

Détaillons un peu ce qu'il se passe. Dans un premier temps, nous avons déclaré et initialisé nos variables. Ensuite, la boucle évalue la condition qui nous dit : tant que la variable reponse contient « O », on exécute la boucle. Celle-ci contient bien le caractère « O », donc nous entrons dans la boucle. Puis l'exécution des instructions suivant l'ordre dans lequel elles apparaissent dans la boucle a lieu. À la fin, c'est-à-dire à l'accolade fermante de la boucle, le compilateur nous ramène au début de la boucle.

Voilà. C'est pas mal, mais il faudrait forcer l'utilisateur à ne taper que « O » ou « N ». Comment faire ? C'est très simple : avec une boucle ! Il suffit de forcer l'utilisateur à entrer soit « N » soit « O » avec un while ! Attention, il nous faudra réinitialiser la variable reponse à « ' ' » (caractère vide). Il faudra donc répéter la phase « Voulez-vous réessayer ? » tant que la réponse donnée n'est pas « O » ou « N ».

Voici notre programme dans son intégralité :

String prenom;
char reponse = 'O';
Scanner sc = new Scanner(System.in);
while (reponse == 'O')
{
  System.out.println("Donnez un prénom : ");
  prenom = sc.nextLine();
  System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");                        
  //Sans ça, nous n'entrerions pas dans la deuxième boucle
  reponse = ' ';
                        
  //Tant que la réponse 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 réessayer ? (O/N)");
    reponse = sc.nextLine().charAt(0);
  }
}
System.out.println("Au revoir…");

Vous pouvez tester ce code (c'est d'ailleurs vivement conseillé) : vous verrez que si vous n'entrez pas la bonne lettre, le programme vous posera sans cesse sa question, comme à la figure suivante !

Attention à écrire correctement vos conditions et à bien vérifier vos variables dans vos while, et dans toutes vos boucles en général. Sinon c'est le drame ! Essayez d'exécuter le programme précédent sans la réinitialisation de la variable reponse, et vous verrez le résultat ! On n'entre jamais dans la deuxième boucle, car reponse = 'O' (puisque initialisée ainsi au début du programme). Là, vous ne pourrez jamais changer sa valeur… Le programme ne s'arrêtera donc jamais ! On appelle ça une « boucle infinie ». En voici un autre exemple.

int a = 1, b = 15;
while (a < b)
{
  System.out.println("coucou " +a+ " fois !!");
}

Si vous lancez ce programme, vous allez voir une quantité astronomique de « coucou 1 fois !! ». Nous aurions dû ajouter une instruction dans le bloc d'instructions de notre while pour changer la valeur de a à chaque tour de boucle, comme ceci :

int a = 1, b = 15;
while (a < b)
{
  System.out.println("coucou " +a+ " fois !!");
  a++;
}

Ce qui nous donnerait comme résultat la figure suivante.

Vous auriez aussi pu utiliser cette syntaxe :

int a = 1, b = 15;
while (a++ < b)
   System.out.println("coucou " +a+ " fois !!");

Souvenez-vous de ce dont je vous parlais au chapitre précédent sur la priorité des opérateurs. Ici, l'opérateur « < » a la priorité sur l'opérateur d'incrémentation « ++ ». Pour faire court, la boucle while teste la condition et ensuite incrémente la variable a. Par contre, essayez ce code :

int a = 1, b = 15;
while (++a < b)
  System.out.println("coucou " +a+ " fois !!");

Vous devez remarquer qu'il y a un tour de boucle en moins ! Eh bien avec cette syntaxe, l'opérateur d'incrémentation est prioritaire sur l'opérateur d'inégalité (ou d'égalité), c'est-à-dire que la boucle incrémente la variable a, et ce n'est qu'après l'avoir fait qu'elle teste la condition !

La boucle do… while

Puisque je viens de vous expliquer comment fonctionne une boucle while, je ne vais pas vraiment m'attarder sur la boucle do… while. En effet, ces deux boucles ne sont pas cousines, mais plutôt sœurs. Leur fonctionnement est identique à deux détails près.

do{
  //Instructions
}while(a < b);

Première différence

La boucle do… while s'exécutera au moins une fois, contrairement à sa sœur. C'est-à-dire que la phase de test de la condition se fait à la fin, car la condition se met après le while.

Deuxième différence

C'est une différence de syntaxe, qui se situe après la condition du while. Vous voyez la différence ? Oui ? Non ? Il y a un « ;» après le while. C'est tout ! Ne l'oubliez cependant pas, sinon le programme ne compilera pas.

Mis à part ces deux éléments, ces boucles fonctionnent exactement de la même manière. D'ailleurs, refaisons notre programme précédent avec une boucle do… while.

String prenom = new String();
//Pas besoin d'initialiser : on entre au moins une fois dans la boucle !
char reponse = ' ';
 
Scanner sc = new Scanner(System.in);
 
do{
  System.out.println("Donnez un prénom : ");
  prenom = sc.nextLine();
  System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
       
  do{
    System.out.println("Voulez-vous réessayer ? (O/N)");
    reponse = sc.nextLine().charAt(0);
  }while(reponse != 'O' && reponse != 'N');
        
}while (reponse == 'O');
 
System.out.println("Au revoir…");

Vous voyez donc que ce code ressemble beaucoup à celui utilisé avec la boucle while, mais il comporte une petite subtilité : ici, plus besoin de réinitialiser la variable reponse, puisque de toute manière, la boucle s'exécutera au moins une fois !

La boucle for

Cette boucle est un peu particulière puisqu'elle prend tous ses attributs dans sa condition et agit en conséquence. Je m'explique : jusqu'ici, nous avions fait des boucles avec :

• déclaration d'une variable avant la boucle ;

• initialisation de cette variable ;

• incrémentation de celle-ci dans la boucle.

Eh bien on met tout ça dans la condition de la boucle for, et c'est tout. Il existe une autre syntaxe pour la boucle for depuis le JDK 1.5. Nous la verrons lorsque nous aborderons les tableaux. Mais je sais bien qu'un long discours ne vaut pas un exemple, alors voici une boucle for sous vos yeux ébahis :

for(int i = 1; i <= 10; i++)
{
  System.out.println("Voici la ligne "+i);
}

Ce qui donne la figure suivante.

Vous aurez sûrement remarqué la présence des « ; » dans la condition pour la séparation des champs. Ne les oubliez surtout pas, sinon le programme ne compilera pas.

Nous pouvons aussi inverser le sens de la boucle, c'est-à-dire qu'au lieu de partir de 0 pour aller à 10, nous allons commencer à 10 pour atteindre 0 :

for(int i = 10; i >= 0; i--)
  System.out.println("Il reste "+i+" ligne(s) à écrire");

On obtient la figure suivante.

Pour simplifier, la boucle for est un peu le condensé d'une boucle while dont le nombre de tours se détermine via un incrément. Nous avons un nombre de départ, une condition qui doit être remplie pour exécuter une nouvelle fois la boucle et une instruction de fin de boucle qui incrémente notre nombre de départ. Remarquez que rien ne nous empêche de cumuler les déclarations, les conditions et les instructions de fin de boucle :

for(int i = 0, j = 2; (i < 10 && j < 6); i++, j+=2){
  System.out.println("i = " + i + ", j = " + j);
}

Ici, cette boucle n'effectuera que deux tours puisque la condition (i < 10 && j < 6) est remplie dès le deuxième tour, la variable j commençant à 2 et étant incrémentée de deux à chaque tour de boucle.

• Les boucles vous permettent simplement d'effectuer des tâches répétitives.

• Il existe plusieurs sortes de boucles :

  • la boucle while(condition){…} évalue la condition puis exécute éventuellement un tour de boucle (ou plus) ;

  • la boucle do{…}while(condition); fonctionne exactement comme la précédente, mais effectue un tour de boucle quoi qu'il arrive ;

  • la boucle for permet d'initialiser un compteur, une condition et un incrément dans sa déclaration afin de répéter un morceau de code un nombre limité de fois.

• Tout comme les conditions, si une boucle contient plus d'une ligne de code à exécuter, vous devez l'entourer d'accolades afin de bien en délimiter le début et la fin.

Élaboration

Voici les caractéristiques du programme que nous allons devoir réaliser :

• le programme demande quelle conversion nous souhaitons effectuer, Celsius vers Fahrenheit ou l'inverse ;

• on n'autorise que les modes de conversion définis dans le programme (un simple contrôle sur la saisie fera l'affaire) ;

• enfin, on demande à la fin à l'utilisateur s'il veut faire une nouvelle conversion, ce qui signifie que l'on doit pouvoir revenir au début du programme !

Avant de vous lancer dans la programmation à proprement parler, je vous conseille fortement de réfléchir à votre code… sur papier. Réfléchissez à ce qu'il vous faut comme nombre de variables, les types de variables, comment va se dérouler le programme, les conditions et les boucles utilisées.

À toutes fins utiles, voici la formule de conversion pour passer des degrés Celsius en degrés Fahrenheit : F = \frac{9}{5} imes C + 32 ; pour l'opération inverse, c'est comme ceci : C = \frac{(F - 32) imes 5 }{9}.

La figure suivante est un aperçu de ce que je vous demande.

Je vais également vous donner une fonction toute faite qui vous permettra éventuellement d'arrondir vos résultats. Je vous expliquerai le fonctionnement des fonctions dans deux chapitres. Vous pouvez très bien ne pas vous en servir. Pour ceux qui souhaitent tout de même l'utiliser, la voici :

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 à la figure suivante.

Voici comment utiliser cette fonction : imaginez que vous avez la variable faren à arrondir, et que le résultat obtenu est enregistré dans une variable arrondFaren ; vous procéderez comme suit :

arrondFaren = arrondi(faren,1); //Pour un chiffre après la virgule
arrondFaren = arrondi(faren, 2);//Pour deux chiffres après la virgule, etc.

Quelques dernières recommandations : essayez de bien indenter votre code ! Prenez votre temps. Essayez de penser à tous les cas de figure. Maintenant à vos papiers, crayons, neurones, claviers… et bon courage !

Correction

STOP ! C'est fini ! Il est temps de passer à la correction de ce premier TP. Ça va ? Pas trop mal à la tête ? Je me doute qu'il a dû y avoir quelques tubes d'aspirine vidés. Mais vous allez voir qu'en définitive, ce TP n'était pas si compliqué que ça.

Surtout, n'allez pas croire que ma correction est parole d'évangile. Il y avait différentes manières d'obtenir le même résultat. Voici tout de même une des solutions possibles.

import java.util.Scanner;

class Sdz1 {
  public static void main(String[] args) {
    //Notre objet Scanner
    Scanner sc = new Scanner(System.in);

    //initialisation des variables
    double aConvertir, convertit=0;
    char reponse=' ', mode = ' ';

    System.out.println("CONVERTISSEUR DEGRÉS CELSIUS ET DEGRÉS FAHRENHEIT");
    System.out.println("-------------------------------------------------");
    
    do{//tant que reponse = O //boucle principale
       
      do{//tant que reponse n'est pas O ou N
        mode = ' ';
        System.out.println("Choisissez le mode de conversion : ");
        System.out.println("1 - Convertisseur Celsius - Fahrenheit");
        System.out.println("2 - Convertisseur Fahrenheit - Celsius ");
        mode = sc.nextLine().charAt(0);
       
        if(mode != '1' && mode != '2')
          System.out.println("Mode inconnu, veuillez réitérer votre choix.");

      }while (mode != '1' && mode != '2');
       
      //saisie de la température à convertir
      System.out.println("Température à convertir :");
      aConvertir = sc.nextDouble();
      //Pensez à vider la ligne lue
      sc.nextLine();
     
      //Selon le mode, on calcule différemment et on affiche le résultat
      if(mode == '1'){
        convertit = ((9.0/5.0) * aConvertir) + 32.0;
        System.out.print(aConvertir + " °C correspond à : ");
        System.out.println(arrondi(convertit, 2) + " °F.");
      }
      else{
        convertit = ((aConvertir - 32) * 5) / 9;
        System.out.print(aConvertir + " °F correspond à : ");
        System.out.println(arrondi(convertit, 2) + " °C.");
      }
     
      //On invite l'utilisateur à recommencer ou à quitter
      do{       
        System.out.println("Souhaitez-vous convertir une autre température ?(O/N)");
        reponse = sc.nextLine().charAt(0);
       
      }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);
  } 
}

Explications concernant ce code

• Tout programme commence par une phase de déclaration des variables.

• Nous affichons le titre de notre programme.

• Ensuite, vous voyez deux do{ consécutifs correspondant à deux conditions à vérifier :

  • la volonté de l'utilisateur d'effectuer une nouvelle conversion ;

  • la vérification du mode de conversion.

• Nous affichons les renseignements à l'écran, et récupérons la température à convertir pour la stocker dans une variable.

• Selon le mode sélectionné, on convertit la température et on affiche le résultat.

• On invite l'utilisateur à recommencer.

• 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'espère que vous avez apprécié 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 !

Tableau à une dimension

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 ! C'est très logique : comme nous l'avons vu auparavant, une variable d'un type donné ne peut contenir que des éléments de ce type : une variable de type int ne peut pas recevoir une chaîne de caractères. Il en va de même pour les tableaux. Voyons tout de suite comment ils se déclarent :

<type du tableau> <nom du tableau> [] = { <contenu du tableau>};

La déclaration ressemble beaucoup à celle d'une variable quelconque, si ce n'est la présence de crochets « [ ] » après le nom de notre tableau et d'accolades « { } » encadrant l'initialisation de celui-ci. Dans la pratique, ça nous donnerait quelque chose comme ceci :

int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};

Vous remarquez bien que la déclaration et l'initialisation d'un tableau se font comme avec une variable ordinaire : il faut utiliser des « ' ' » pour initialiser un tableau de caractères, des « " " » pour initialiser un tableau de String, etc. Vous pouvez aussi déclarer un tableau vide, mais celui-ci devra impérativement contenir un nombre de cases bien défini. Par exemple, si vous voulez un tableau vide de six entiers :

int tableauEntier[] = new int[6];
//Ou encore
int[] tableauEntier2 = new int[6];

Cette opération est très simple, car vraiment ressemblante à ce que vous faisiez avec vos variables ; je vous propose donc tout de suite de nous pencher sur une belle variante de ces tableaux…

Les tableaux multidimensionnels

Ici, les choses se compliquent un peu, car un tableau multidimensionnel n'est rien d'autre qu'un tableau contenant au minimum deux tableaux… Je me doute bien que cette notion doit en effrayer plus d'un, mais en réalité, elle n'est pas si difficile que ça à appréhender. Comme tout ce que je vous apprends en général !

Je ne vais pas vous faire de grand laïus sur ce type de tableau, puisque je pense sincèrement qu'un exemple vous en fera beaucoup mieux comprendre le concept. Imaginez un tableau avec deux lignes : la première contiendra les premiers nombres pairs, et le deuxième contiendra les premiers nombres impairs.

Ce tableau s'appellera premiersNombres. Voilà ce que cela donnerait :

int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };

Nous voyons bien ici les deux lignes de notre tableau symbolisées par les doubles crochets [ ][ ]. Et comme je l'ai dit plus haut, ce genre de tableau est composé de plusieurs tableaux. Ainsi, pour passer d'une ligne à l'autre, nous jouerons avec la valeur du premier crochet. Exemple : premiersNombres[0][0] correspondra au premier élément de la ligne paire, et premiersNombres[1][0] correspondra au premier élément de la ligne impaire.

La figure suivante représente un petit schéma en guise de synthèse.

Maintenant, je vais vous proposer de vous amuser un peu avec les tableaux…

Utiliser et rechercher dans un tableau

Avant d'attaquer, je dois vous dire quelque chose de primordial : un tableau débute toujours à l'indice 0 ! Je m'explique : prenons l'exemple du tableau de caractères contenant les lettres de l'alphabet dans l'ordre qui a été donné plus haut. Si vous voulez afficher la lettre « a » à l'écran, vous devrez taper cette ligne de code :

System.out.println(tableauCaractere[0]);

Cela implique qu'un tableau contenant 4 éléments aura comme indices possibles 0, 1, 2 ou 3. Le 0 correspond au premier élément, le 1 correspond au 2e élément, le 2 correspond au 3e élément et le 3 correspond au 4e élément.

Ce que je vous propose, c'est tout simplement d'afficher un des tableaux présentés ci-dessus dans son intégralité. Sachez qu'il existe une instruction qui retourne la taille d'un tableau : grâce à elle, nous pourrons arrêter notre boucle (car oui, nous allons utiliser une boucle). Il s'agit de l'instruction <mon tableau>.length. Notre boucle for pourrait donc ressembler à ceci :

char tableauCaractere[] = {'a','b','c','d','e','f','g'};
       
for(int i = 0; i < tableauCaractere.length; i++)
{
  System.out.println("À l'emplacement " + i +" du tableau nous avons = " + tableauCaractere[i]);
}

Cela affichera :

À l'emplacement 0 du tableau nous avons = a
À l'emplacement 1 du tableau nous avons = b
À l'emplacement 2 du tableau nous avons = c
À l'emplacement 3 du tableau nous avons = d
À l'emplacement 4 du tableau nous avons = e
À l'emplacement 5 du tableau nous avons = f
À l'emplacement 6 du tableau nous avons = g

Maintenant, nous allons essayer de faire une recherche dans un de ces tableaux. En gros, il va falloir effectuer une saisie clavier et regarder si celle-ci est présente dans le tableau… Gardez la partie de code permettant de faire plusieurs fois la même action ; ensuite, faites une boucle de recherche incluant la saisie clavier, un message si la saisie est trouvée dans le tableau, et un autre message si celle-ci n'est pas trouvée. Ce qui nous donne :

char tableauCaractere[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
int i = 0;
char reponse = ' ',carac = ' ';
Scanner sc = new Scanner(System.in);
         
do {//Boucle principale
  do {//On répète 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);
    //Boucle de recherche dans le tableau
    while(i < tableauCaractere.length && carac != tableauCaractere[i])
      i++;
         
    //Si i < 7 c'est que la boucle n'a pas dépassé le nombre de cases du tableau 
    if (i < tableauCaractere.length)
      System.out.println(" La lettre " +carac+ " se trouve bien dans le tableau !");
    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 à nouveau ? (O/N)");
    reponse = sc.nextLine().charAt(0);
  }while(reponse != 'N' && reponse != 'O');      
}while (reponse == 'O');
                
System.out.println("Au revoir !");

Le résultat de ce code se trouve à la figure suivante.

Explications sur la recherche

Dans notre while, il y a deux conditions.

La première correspond au compteur : tant que celui-ci est inférieur ou égal au nombre d'éléments du tableau, on l'incrémente pour regarder la valeur suivante. Nous passons ainsi en revue tout ce qui se trouve dans notre tableau. Si nous n'avions mis que cette condition, la boucle n'aurait fait que parcourir le tableau, sans voir si le caractère saisi correspond bien à un caractère de notre tableau, d'où la deuxième condition.

La deuxième correspond à la comparaison entre le caractère saisi et la recherche dans le tableau. Grâce à elle, si le caractère saisi se trouve dans le tableau, la boucle prend fin, et donc i a une valeur inférieure à 7.

À ce stade, notre recherche est terminée. Après cela, les conditions coulent de source ! Si nous avons trouvé une correspondance entre le caractère saisi et notre tableau, i prendra une valeur inférieure à 7 (vu qu'il y a 7 éléments dans notre tableau, l'indice maximum étant 7-1, soit 6). Dans ce cas, nous affichons un message confirmant la présence de l’élément recherché. Dans le cas contraire, c'est l'instruction du else qui s'exécutera.

En travaillant avec les tableaux, vous serez confrontés, un jour ou l'autre, au message suivant :

java.lang.ArrayIndexOutOfBoundsException

Ceci signifie qu'une erreur a été rencontrée, car vous avez essayé de lire (ou d'écrire dans) une case qui n'a pas été définie dans votre tableau ! Voici un exemple (nous verrons les exceptions lorsque nous aborderons la programmation orientée objet) :

String[] str = new String[10];
//L'instruction suivante va déclencher une exception
//Car vous essayez d'écrire à la case 11 de votre tableau 
//Alors que celui-ci n'en contient que 10 (ça commence à 0 !)
str[10] = "Une exception";

Nous allons maintenant travailler sur le tableau bidimensionnel mentionné précédemment. Le principe est vraiment identique à celui d'un tableau simple, sauf qu'ici, il y a deux compteurs. Nous allons travailler sur un code permettant d'afficher les données par ligne, c'est-à-dire l'intégralité du sous-tableau de nombres pairs, puis le sous-tableau de nombres impairs.

Avec une boucle while

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++;
}

Le résultat se trouve à la figure suivante.

Détaillons un peu ce code :

• Dans un premier temps, on initialise les variables.

• On entre ensuite dans la première boucle (qui s'exécutera deux fois, donc i vaut 0 la première fois, et vaudra 1 pendant la deuxième), et on initialise j à 0.

• On entre ensuite dans la deuxième 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 incrémenté et passe à 1.

• On reprend le début de la première boucle : initialisation de j à 0.

• On entre à nouveau dans la deuxième boucle, où le processus est le même que précédemment (mais là, i vaut 1).

• Enfin, nous sortons des boucles et le programme termine son exécution.

Le même résultat avec une boucle for

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("");     
}

Je vous avais parlé d'une nouvelle syntaxe pour cette boucle, la voici :

String tab[] = {"toto", "titi", "tutu", "tete", "tata"};
 
for(String str : tab)
  System.out.println(str);

Ceci signifie qu'à chaque tour de boucle, la valeur courante du tableau est mise dans la variable str. Vous constaterez que cette forme de boucle for est particulièrement adaptée aux parcours de tableaux !

Attention cependant, il faut impérativement que la variable passée en premier paramètre de la boucle for soit de même 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 etc.).

Concernant les tableaux à deux dimensions, que va retourner l'instruction de la première boucle for ? Un tableau ! Nous devrons donc faire une deuxième boucle afin de parcourir ce dernier !

Voici un code qui permet d'afficher un tableau à deux dimensions de façon conventionnelle et selon la version du JDK 1.5 (cette syntaxe ne fonctionnera pas sur les versions antérieures au JDK 1.5) :

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]);
    i++;
  }
  j++;
}

Je vous laisse le soin d'essayer ce code. Vous pourrez voir que nous récupérons un tableau au cours de la première boucle et parcourons ce même tableau afin de récupérer les valeurs de celui-ci dans la deuxième. Simple, non ? En tout cas, je préfère nettement cette syntaxe ! Après, c'est à vous de voir…

• Un tableau est une variable contenant plusieurs données d'un même type.

• Pour déclarer un tableau, il faut ajouter des crochets [ ] à la variable ou à son type de déclaration.

• Vous pouvez ajouter autant de dimensions à votre tableau que vous le souhaitez, ceci en cumulant des crochets à la déclaration.

• Le premier élément d'un tableau est l'élément 0.

• Vous pouvez utiliser la syntaxe du JDK 1.5 de la boucle for pour parcourir vos tableaux : for(String str : monTableauDeString).

Quelques méthodes utiles

Vous l'aurez compris, il existe énormément de méthodes dans le langage Java, présentes dans des objets comme String : vous devrez les utiliser tout au long de cet ouvrage (et serez même amenés à en modifier le comportement). À ce point du livre, vous pouvez catégoriser les méthodes en deux « familles » : les natives et les vôtres.

Des méthodes concernant les chaînes de caractères

La méthode toLowerCase() permet de transformer tout caractère alphabétique en son équivalent minuscule. Elle n'a aucun effet sur les chiffres : ce ne sont pas des caractères alphabétiques. Vous pouvez donc l'utiliser sans problème sur une chaîne de caractères comportant des nombres.
Elle s'emploie comme ceci :

String chaine = new String("COUCOU TOUT LE MONDE !"), chaine2 = new String();
chaine2 = chaine.toLowerCase();   //Donne "coucou tout le monde !"

la méthode toUpperCase() est simple, puisqu'il s'agit de l'opposé de la précédente. Elle transforme donc une chaîne de caractères en capitales, et s'utilise comme suit :

String chaine = new String("coucou coucou"), chaine2 = new String();
chaine2 = chaine.toUpperCase();   //Donne "COUCOU COUCOU"

La méthode length() renvoie la longueur d'une chaîne de caractères (en comptant les espaces).

String chaine = new String("coucou ! "); 
int longueur = 0;
longueur = chaine.length();   //Renvoie 9

La méthode equals() permet de vérifier (donc de tester) si deux chaînes de caractères sont identiques. C'est avec cette fonction que vous effectuerez vos tests de condition sur les String. Exemple concret :

String str1 = new String("coucou"), str2 = new String("toutou");
 
if (str1.equals(str2))
  System.out.println("Les deux chaînes sont identiques !");
 
else
  System.out.println("Les deux chaînes sont différentes !");

Vous pouvez aussi demander la vérification de l'inégalité grâce à l'opérateur de négation. Vous vous en souvenez ? Il s'agit de « ! ». Cela nous donne :

String str1 = new String("coucou"), str2 = new String("toutou");
 
if (!str1.equals(str2))
  System.out.println("Les deux chaînes sont différentes !");
 
else
  System.out.println("Les deux chaînes sont identiques !");

Ce genre de condition fonctionne de la même façon pour les boucles. Dans l'absolu, cette fonction retourne un booléen, c'est pour cette raison que nous pouvons y recourir dans les tests de condition.

Le résultat de la méthode charAt() sera un caractère : il s'agit d'une méthode d'extraction de caractère. Elle ne peut s'opérer que sur des String ! Par ailleurs, elle présente la même particularité que les tableaux, c'est-à-dire que, pour cette méthode, le premier caractère sera le numéro 0. Cette méthode prend un entier comme argument.

String nbre = new String("1234567");
char carac = nbre.charAt(4);   //Renverra ici le caractère 5

La méthode substring() extrait une partie d'une chaîne de caractères. Elle prend deux entiers en arguments : le premier définit le premier caractère (inclus) de la sous-chaîne à extraire, le second correspond au dernier caractère (exclu) à extraire. Là encore, le premier caractère porte le numéro 0.

String chaine = new String("la paix niche"), chaine2 = new String();
chaine2 = chaine.substring(3,13);   //Permet d'extraire "paix niche"

La méthode indexOf() explore une chaîne de caractères à la recherche d'une suite donnée de caractères, et renvoie la position (ou l'index) de la sous-chaîne passée en argument. la méthode indexOf() explore à partir du début de la chaîne, lastIndexOf() explore en partant de la fin, mais renvoie l'index à partir du début de la chaîne. Ces deux méthodes prennent un caractère ou une chaîne de caractères comme argument, et renvoient un int. Tout comme charAt() et substring(), le premier caractère porte le numéro 0. Je crois qu'ici, un exemple s'impose, plus encore que pour les autres fonctions :

String mot = new String("anticonstitutionnellement");
int n = 0;
 
n = mot.indexOf('t');           //n vaut 2
n = mot.lastIndexOf('t');       //n vaut 24
n = mot.indexOf("ti");          //n vaut 2
n = mot.lastIndexOf("ti");      //n vaut 12
n = mot.indexOf('x');           //n vaut -1

Les méthodes que nous allons voir nécessitent la classe Math, présente dans java.lang. Elle fait donc partie des fondements du langage. Par conséquent, aucun import particulier n'est nécessaire pour utiliser la classe Math qui regorge de méthodes utiles :

double X = 0.0;
X = Math.random();
//Retourne un nombre aléatoire 
//compris entre 0 et 1, comme 0.0001385746329371058

double sin = Math.sin(120);     //La fonction sinus
double cos = Math.cos(120);     //La fonction cosinus
double tan = Math.tan(120);     //La fonction tangente
double abs = Math.abs(-120.25); //La fonction valeur absolue (retourne le nombre sans le signe)
double d = 2;
double exp = Math.pow(d, 2);    //La fonction exposant
//Ici, on initialise la variable exp avec la valeur de d élevée au carré
//La méthode pow() prend donc une valeur en premier paramètre, et un exposant en second

Ces méthodes retournent toutes un nombre de type double.

Je ne vais pas vous faire un récapitulatif de toutes les méthodes présentes dans Java, sinon j'y serai encore dans mille ans… Toutes ces méthodes sont très utiles, croyez-moi. Cependant, les plus utiles sont encore celles que nous écrivons nous-mêmes ! C'est tellement mieux quand cela vient de nous.

Créer sa propre méthode

Voici un exemple de méthode que vous pouvez écrire :

public static double arrondi(double A, int B) {
  return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}

Décortiquons un peu cela :

• Tout d'abord, il y a le mot clé public. C'est ce qui définit la portée de la méthode, nous y reviendrons lorsque nous programmerons des objets.

• Ensuite, il y a static. Nous y reviendrons aussi.

• Juste après, nous voyons double. Il s'agit du type de retour de la méthode. Pour faire simple, ici, notre méthode va renvoyer un double !

• Vient ensuite le nom de la méthode. C'est avec ce nom que nous l'appellerons.

• Puis arrivent les arguments de la méthode. Ce sont en fait les paramètres dont la méthode a besoin pour travailler. Ici, nous demandons d'arrondir le doubleA avec B chiffres derrière la virgule.

• Finalement, vous pouvez voir une instruction return à l'intérieur de la méthode. C'est elle qui effectue le renvoi de la valeur, ici un double.

Nous verrons dans ce chapitre les différents types de renvoi ainsi que les paramètres que peut accepter une méthode.

Vous devez savoir deux choses concernant les méthodes :

1. elles ne sont pas limitées en nombre de paramètres;

2. il en existe trois grands types :

   • les méthodes qui ne renvoient rien. Les méthodes de ce type n'ont pas d'instruction return, et elles sont de type void ;

   • les méthodes qui retournent des types primitifs (double, int etc.). Elles sont de type double, int, char etc. Celles-ci possèdent une instruction return ;

   • les méthodes qui retournent des objets. Par exemple, une méthode qui retourne un objet de type String. Celles-ci aussi comportent une instruction return.

Jusque-là, nous n'avons écrit que des programmes comportant une seule classe, ne disposant elle-même que d'une méthode : la méthode main. Le moment est donc venu de créer vos propres méthodes. Que vous ayez utilisé ou non la méthode arrondi dans votre TP, vous avez dû voir que celle-ci se place à l'extérieur de la méthode main, mais tout de même dans votre classe !

Pour rappel, jetez un œil à la capture d'écran du premier TP, à la figure suivante.

Puisque nous venons d'étudier les tableaux, nous allons créer des méthodes pour eux. Vous devez certainement vous souvenir de la façon de parcourir un tableau. Et si nous faisions une méthode qui permet d'afficher le contenu d'un tableau sans que nous soyons obligés de retaper la portion de code contenant la boucle ? Je me doute que vous n'en voyez pas l'intérêt maintenant, car exception faite des plus courageux d'entre vous, vous n'avez utilisé qu'un ou deux tableaux dans votre main du chapitre précédent. Si je vous demande de déclarer vingt-deux tableaux et que je vous dis : « Allez, bande de Zéros ! Parcourez-moi tout ça ! », vous n'allez tout de même pas écrire vingt-deux boucles for ! De toute façon, je vous l'interdis. Nous allons écrire une méthode. Celle-ci va :

• prendre un tableau en paramètre ;

• parcourir le tableau à notre place ;

• effectuer tous les System.out.println() nécessaires ;

• ne rien renvoyer.

Avec ce que nous avons défini, nous savons que notre méthode sera de type void et qu'elle prendra un tableau en paramètre. Voici un exemple de code complet :

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);
  }
}

Bon. Vous voyez que la méthode parcourt le tableau passé en paramètre. Si vous créez plusieurs tableaux et appelez la méthode sur ces derniers, vous vous apercevrez que la méthode affiche le contenu de chaque tableau !

Voici un exemple ayant le même effet que la méthode parcourirTableau, à la différence que celle-ci retourne une valeur : ici, ce sera une chaîne de caractères.

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("Méthode toString() !\n----------");
    String retour = "";
                   
    for(String str : tab)
      retour += str + "\n"; 
                   
    return retour;
  }         
}

Vous voyez que la deuxième méthode retourne une chaîne de caractères, que nous devons afficher à l'aide de l'instruction System.out.println(). Nous affichons la valeur renvoyée par la méthode toString(). La méthode parcourirTableau, quant à 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 au sein de la méthode toString(), afin de vous montrer où elle était appelée.

Il nous reste un point important à aborder. Imaginez un instant que vous ayez plusieurs types d'éléments à parcourir : des tableaux à une dimension, d'autres à deux dimensions, et même des objets comme des ArrayList (nous les verrons plus tard, ne vous inquiétez pas). Sans aller aussi loin, vous n'allez pas donner un nom différent à la méthode parcourirTableau pour chaque type primitif !

Vous avez dû remarquer que la méthode que nous avons créée ne prend qu'un tableau de String en paramètre. Pas un tableau d'int ou de long, par exemple. Si seulement nous pouvions utiliser la même méthode pour différents types de tableaux… C'est là qu'entre en jeu ce qu'on appelle la surcharge.

La surcharge de méthode

La surcharge de méthode consiste à garder le nom d'une méthode (donc un type de traitement à faire : pour nous, lister un tableau) et à changer la liste ou le type de ses paramètres. Dans le cas qui nous intéresse, nous voulons que notre méthode parcourirTableau puisse parcourir n'importe quel type de tableau. Nous allons donc surcharger notre méthode afin qu'elle puisse aussi travailler avec des int, comme le montre cet exemple :

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 méthodes, vous pourrez parcourir de la même manière :

• les tableaux d'entiers ;

• les tableaux de chaînes de caractères.

Vous pouvez faire de même avec les tableaux à deux dimensions. Voici à quoi pourrait ressembler le code d'une telle méthode (je ne rappelle pas le code des deux méthodes ci-dessus) :

static void parcourirTableau(String[][] tab)
{
  for(String tab2[] : tab)
  {
    for(String str : tab2)
      System.out.println(str);
  }
}

La surcharge de méthode fonctionne également en ajoutant des paramètres à la méthode. Cette méthode est donc valide :

static void parcourirTableau(String[][] tab, int i)
{
  for(String tab2[] : tab)
  {
    for(String str : tab2)
      System.out.println(str);
  }
}

En fait, c'est la JVM qui va se charger d'invoquer l'une ou l'autre méthode : vous pouvez donc créer des méthodes ayant le même nom, mais avec des paramètres différents, en nombre ou en type. La machine virtuelle fait le reste. Ainsi, si vous avez bien défini toutes les méthodes ci-dessus, ce code fonctionne :

String[] tabStr = {"toto", "titi", "tata"};
int[] tabInt = {1, 2, 3, 4};
String[][] tabStr2 = {{"1", "2", "3", "4"}, {"toto", "titi", "tata"}};

//La méthode avec un tableau de String sera invoquée
parcourirTableau(tabStr);
//La méthode avec un tableau d'int sera invoquée
parcourirTableau(tabInt);
//La méthode avec un tableau de String à deux dimensions sera invoquée
parcourirTableau(tabStr2);

Vous venez de créer une méthode qui vous permet de centraliser votre code afin de ne pas avoir à retaper sans arrêt les mêmes instructions. Dans la partie suivante, vous apprendrez à créer vos propres objets. Elle sera très riche en informations, mais ne vous inquiétez pas : nous apprendrons tout à partir de zéro. ;)

En résumé

• Une méthode est un morceau de code réutilisable qui effectue une action bien définie.

• Les méthodes se définissent dans une classe.

• Les méthodes ne peuvent pas être imbriquées. Elles sont déclarées les unes après les autres.

• Une méthode peut être surchargée en modifiant le type de ses paramètres, leur nombre, ou les deux.

• Pour Java, le fait de surcharger une méthode lui indique qu'il s'agit de deux, trois ou X méthodes différentes, car les paramètres d'appel sont différents. Par conséquent, Java ne se trompe jamais d'appel de méthode, puisqu'il se base sur les paramètres passés à cette dernière.

J'ose espérer que vous avez apprécié 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 méandres de la programmation orientée objet !
Alors ?... Toujours prêts ? :p

Structure de base

Une classe peut être comparée à un moule qui, lorsque nous le remplissons, nous donne un objet ayant la forme du moule ainsi que toutes ses caractéristiques. Comme quand vous étiez enfants, lorsque vous vous amusiez avec de la pâte à modeler.

Si vous avez bien suivi la première partie de ce cours, vous devriez savoir que notre classe contenant la méthode main ressemble à ceci :

class ClasseMain{

  public static void main(String[] args){ 
    //Vos données, variables, différents traitements…
  }//Fin de la méthode main

}//Fin de votre classe

Créez cette classe et cette méthode main (vous savez le faire, maintenant). Puisque nous allons faire de la POO (Programmation Orientée Objet), nous allons créer une seconde classe dans ce fameux projet ! Créons sans plus tarder une classe Ville. Allez dans File > New > Class ou utilisez le raccourci dans la barre d'outils, comme sur la figure suivante.

Nommez votre classe « Ville » (avec un « V » majuscule, convention de nommage oblige). Cette fois, vous ne devez pas y créer la méthode main.

Au final, vous devriez avoir le rendu de la figure suivante.

Ici, notre classe Ville est précédée du mot clé public. Vous devez savoir que lorsque nous créons une classe comme nous l'avons fait, Eclipse nous facilite la tâche en ajoutant automatiquement ce mot clé, qui correspond à la portée de la classe. Retenez pour l'instant que public class UneClasse{} et class UneClasse{} sont presque équivalents !

En programmation, la portée détermine qui peut faire appel à une classe, une méthode ou une variable. Vous avez déjà rencontré la portée public : cela signifie que tout le monde peut faire appel à l'élément. Ici dans le cas qui nous intéresse il s'agit d'une méthode. Une méthode marquée comme public peut donc être appelée depuis n'importe quel endroit du programme.

Nous allons ici utiliser une autre portée : private. Elle signifie que notre méthode ne pourra être appelée que depuis l'intérieur de la classe dans laquelle elle se trouve ! Les méthodes déclarées private correspondent souvent à des mécanismes internes à une classe que les développeurs souhaitent « cacher » ou simplement ne pas rendre accessibles de l'extérieur de la classe…

Bon. Toutes les conditions sont réunies pour commencer activement la programmation orientée objet ! Et si nous allions créer notre première ville ?

Les constructeurs

Vu que notre objectif dans ce chapitre est de construire un objet Ville, il va falloir définir les données qu'on va lui attribuer. Nous dirons qu'un objet Ville possède :

• un nom, sous la forme d'une chaîne de caractères ;

• un nombre d'habitants, sous la forme d'un entier ;

• un pays apparenté, sous la forme d'une chaîne de caractères.

Nous allons faire ceci en mettant des variables d'instance (de simples variables identiques à celles que vous manipulez habituellement) dans notre classe. Celle-ci va contenir une variable dont le rôle sera de stocker le nom, une autre stockera le nombre d'habitants et la dernière se chargera du pays ! Voici à quoi ressemble notre classe Ville à présent :

public class Ville{
  String nomVille;
  String nomPays;
  int nbreHabitants; 
}

Contrairement aux classes, les variables d'instance présentes dans une classe sont public si vous ne leur spécifiez pas de portée. Alors, on parle de variable d'instance, parce que dans nos futures classes Java qui définiront des objets, il y aura plusieurs types de variables (nous approfondirons ceci dans ce chapitre). Pour le moment, sachez qu'il y a trois grands types de variables dans une classe objet :

1. Les variables d'instance : ce sont elles qui définiront les caractéristiques de notre objet.

2. Les variables de classe : celles-ci sont communes à toutes les instances de votre classe.

3. Les variables locales : ce sont des variables que nous utiliserons pour travailler dans notre objet.

Dans l'immédiat, nous allons travailler avec des variables d'instance afin de créer des objets différents. Il ne nous reste plus qu'à créer notre premier objet, pour ce faire, nous allons devoir utiliser ce qu'on appelle des constructeurs.

Un constructeur est une méthode d'instance qui va se charger de créer un objet et, le cas échéant, d'initialiser ses variables de classe ! Cette méthode a pour rôle de signaler à la JVM (Java Virtual Machine) qu'il faut réserver de la mémoire pour notre futur objet et donc, par extension, d'en réserver pour toutes ses variables.

Notre premier constructeur sera ce qu'on appelle communément un constructeur par défaut, c'est-à-dire qu'il ne prendra aucun paramètre, mais permettra tout de même d'instancier un objet, et vu que nous sommes perfectionnistes, nous allons y initialiser nos variables d'instance. Voici votre premier constructeur :

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 nbreHabitants;
     
  //Constructeur par défaut
  public Ville(){
    System.out.println("Création d'une ville !");      
    nomVille = "Inconnu";
    nomPays = "Inconnu";
    nbreHabitants = 0;
  } 
}

Vous avez remarqué que le constructeur est en fait une méthode qui n'a aucun type de retour (void, double…) et qui porte le même nom que notre classe ! Ceci est une règle immuable : le (les) constructeur(s) d'une classe doit (doivent) porter le même nom que la classe !

Son corollaire est qu'un objet peut avoir plusieurs constructeurs. Il s'agit de la même méthode, mais surchargée ! Dans notre premier constructeur, nous n'avons passé aucun paramètre, mais nous allons bientôt en mettre.

Vous pouvez d'ores et déjà créer une instance de Ville. Cependant, commencez par vous rappeler qu'une instance d'objet se fait grâce au mot clé new, comme lorsque vous créez une variable de type String.

Maintenant, vu que nous allons créer des objets Ville, nous allons procéder comme avec les String. Vérifions que l'instanciation s’effectue comme il faut. Allons dans notre classe contenant la méthode main et instancions un objet Ville. Je suppose que vous avez deviné que le type de notre objet sera Ville !

public class Sdz1{ 
  public static void main(String[] args){   
    Ville ville = new Ville(); 
  } 
}

Exécutez ce code, vous devriez avoir l'équivalent de la figure suivante sous les yeux.

Maintenant, nous devons mettre des données dans notre objet, ceci afin de pouvoir commencer à travailler… Le but sera de parvenir à une déclaration d'objet se faisant comme ceci :

Ville ville1 = new Ville("Marseille", 123456789, "France");

Vous avez remarqué qu'ici, les paramètres sont renseignés : eh bien il suffit de créer une méthode qui récupère ces paramètres et initialise les variables de notre objet, ce qui achèvera notre constructeur d'initialisation.

Voici le constructeur de notre objet Ville, celui qui permet d'avoir des objets avec des paramètres différents :

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 nbreHabitants;
 
  //Constructeur par défaut
  public Ville(){
    System.out.println("Création d'une ville !");          
    nomVille = "Inconnu";
    nomPays = "Inconnu";
    nbreHabitants = 0;
  }
 
  //Constructeur avec paramètres
  //J'ai ajouté un « p » en première lettre des paramètres.
  //Ce n'est pas une convention, mais ça peut être un bon moyen de les repérer.
  public Ville(String pNom, int pNbre, String pPays)
  {
    System.out.println("Création d'une ville avec des paramètres !");
    nomVille = pNom;
    nomPays = pPays;
    nbreHabitants = pNbre;
  }        
}

Dans ce cas, l'exemple de déclaration 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 paramètres passés lors de l'initialisation de votre objet : sinon, c'est l'erreur de compilation à coup sûr ! Ainsi :

//L'ordre est respecté -> aucun souci
Ville ville1 = new Ville("Marseille", 123456789, "France");
//Erreur dans l'ordre des paramètres -> erreur de compilation au final
Ville ville2 = new Ville(12456, "France", "Lille");

Par contre, notre objet présente un gros défaut : les variables d'instance qui le caractérisent sont accessibles dans votre classe contenant votre main ! Ceci implique que vous pouvez directement modifier les attributs de la classe. Testez ce code et vous verrez que le résultat est identique à la figure suivante :

public class Sdz1 {
 
  public static void main(String[] args)
  {
    Ville ville =  new Ville();
    System.out.println(ville.nomVille);
    ville.nomVille = "la tête à toto ! ! ! !";
    System.out.println(ville.nomVille);
                
    Ville ville2 = new Ville("Marseille", 123456789, "France");
    ville2.nomPays = "La tête à tutu ! ! ! ! ";
    System.out.println(ville2.nomPays);
  }
          
}

Vous constatez que nous pouvons accéder aux variables d'instance en utilisant le « . », comme lorsque vous appelez la méthode subString() de l'objet String. C'est très risqué, et la plupart des programmeurs Java vous le diront. Dans la majorité des cas, nous allons contrôler les modifications des variables de classe, de manière à ce qu'un code extérieur ne fasse pas n'importe quoi avec nos objets ! En plus de ça, imaginez que vous souhaitiez faire quelque chose à chaque fois qu'une valeur change ; si vous ne protégez pas vos données, ce sera impossible à réaliser… C'est pour cela que nous protégeons nos variables d'instance en les déclarant private, comme ceci :

public class Ville {

  private String nomVille;
  private String nomPays;
  private int nbreHabitants;
   
  //…     
}

Désormais, ces attributs ne sont plus accessibles en dehors de la classe où ils sont déclarés ! Nous allons maintenant voir comment accéder tout de même à nos données.

Accesseurs et mutateurs

Un accesseur est une méthode qui va nous permettre d'accéder aux variables de nos objets en lecture, et un mutateur nous permettra d'en faire de même en écriture ! Grâce aux accesseurs, vous pourrez afficher les variables de vos objets, et grâce aux mutateurs, vous pourrez les modifier :

public class Ville {

  //Les variables et les constructeurs n'ont pas changé…
          
  //*************   ACCESSEURS *************
    
  //Retourne le nom de la ville
  public String getNom()  {  
    return nomVille;
  }

  //Retourne le nom du pays
  public String getNomPays()
  {
    return nomPays;
  }

  // Retourne le nombre d'habitants
  public int getNombreHabitants()
  {
    return nbreHabitants;
  } 
 
  //*************   MUTATEURS   *************

  //Définit le nom de la ville
  public void setNom(String pNom)
  {
    nomVille = pNom;
  }

  //Définit le nom du pays
  public void setNomPays(String pPays)
  {
    nomPays = pPays;
  }

  //Définit le nombre d'habitants
  public void setNombreHabitants(int nbre)
  {
    nbreHabitants = nbre;
  }  
}

Nos accesseurs sont bien des méthodes, et elles sont public pour que vous puissiez y accéder depuis une autre classe que celle-ci : depuis le main, par exemple. Les accesseurs sont du même type que la variable qu'ils doivent retourner. Les mutateurs sont, par contre, de type void. Ce mot clé signifie « rien » ; en effet, ces méthodes ne retournent aucune valeur, elles se contentent de les mettre à jour.

À présent, essayez ce code dans votre méthode main :

Ville v = new Ville();
Ville v1 = new Ville("Marseille", 123456, "France");       
Ville v2 = new Ville("Rio", 321654, "Brésil");

System.out.println("\n v = "+v.getNom()+" ville de  "+v.getNombreHabitants()+ " habitants se situant en "+v.getNomPays());
System.out.println(" v1 = "+v1.getNom()+" ville de  "+v1.getNombreHabitants()+ " habitants se situant en "+v1.getNomPays());
System.out.println(" v2 = "+v2.getNom()+" ville de  "+v2.getNombreHabitants()+ " habitants se situant en "+v2.getNomPays()+"\n\n");
        
/*
  Nous allons interchanger les Villes v1 et v2
  tout ça par l'intermédiaire d'un autre objet Ville.        
*/       
Ville temp = new Ville();
temp = v1;
v1 = v2;
v2 = temp;
       
System.out.println(" v1 = "+v1.getNom()+" ville de  "+v1.getNombreHabitants()+ " habitants se situant en "+v1.getNomPays());
System.out.println(" v2 = "+v2.getNom()+" ville de  "+v2.getNombreHabitants()+ " habitants se situant en "+v2.getNomPays()+"\n\n");

/*       
  Nous allons maintenant interchanger leurs noms
  cette fois par le biais de leurs mutateurs.
*/   
v1.setNom("Hong Kong");
v2.setNom("Djibouti");
      
System.out.println(" v1 = "+v1.getNom()+" ville de  "+v1.getNombreHabitants()+ " habitants se situant en "+v1.getNomPays());
System.out.println(" v2 = "+v2.getNom()+" ville de  "+v2.getNombreHabitants()+ " habitants se situant en "+v2.getNomPays()+"\n\n");

À la compilation, vous devriez obtenir la figure suivante.

Vous voyez bien que les constructeurs ont fonctionné, que les accesseurs tournent à merveille et que vous pouvez commencer à travailler avec vos objets Ville. Par contre, pour afficher le contenu, on pourrait faire plus simple, comme par exemple créer une méthode qui se chargerait de faire tout ceci… Je sais ce que vous vous dites : « Mais les accesseurs, ce ne sont pas des méthodes ? ». Bien sûr que si, mais il vaut mieux bien distinguer les différents types de méthodes dans un objet :

• les constructeurs -> méthodes servant à créer des objets ;

• les accesseurs -> méthodes servant à accéder aux données des objets ;

• les méthodes d'instance → méthodes servant à la gestion des objets.

Avec nos objets Ville, notre choix est un peu limité par le nombre de méthodes possibles, mais nous pouvons tout de même en faire une ou deux pour l'exemple :

• faire un système de catégories de villes par rapport à leur nombre d'habitants ( <1000 -> A, <10 000 -> B…). Ceci est déterminé à la construction ou à la redéfinition du nombre d'habitants : ajoutons donc une variable d'instance de type char à notre classe et appelons-la categorie. Pensez à ajouter le traitement aux bons endroits ;

• faire une méthode de description de notre objet Ville ;

• une méthode pour comparer deux objets par rapport à leur nombre d'habitants.

Par contre, un problème va se poser ! Vous savez déjà qu'en Java, on appelle les méthodes d'un objet comme ceci : monString.subString(0,4);. Cependant, vu qu'il va falloir qu'on travaille depuis l'intérieur de notre objet, vous allez encore avoir un mot clé à retenir… Cette fois, il s'agit du mot clé this. Voici tout d'abord le code de notre classe Ville en entier, c'est-à-dire comportant les méthodes dont on vient de parler :

public class Ville {
 
  private String nomVille;
  private String nomPays;
  private int nbreHabitants;
  private char categorie;
   
  public Ville(){
    System.out.println("Création d'une ville !");          
    nomVille = "Inconnu";
    nomPays = "Inconnu";
    nbreHabitants = 0;
    this.setCategorie();
  }
 
  public Ville(String pNom, int pNbre, String pPays)
  {
    System.out.println("Création d'une ville avec des paramètres !");
    nomVille = pNom;
    nomPays = pPays;
    nbreHabitants = pNbre;
    this.setCategorie();
  }  
    
  //Retourne le nom de la ville
  public String getNom()  {  
    return nomVille;
  }

  //Retourne le nom du pays
  public String getNomPays()
  {
    return nomPays;
  }

  // Retourne le nombre d'habitants
  public int getNombreHabitants()
  {
    return nbreHabitants;
  } 

  //Retourne la catégorie de la ville
  public char getCategorie()
  {
    return categorie;
  } 
 
  //Définit le nom de la ville
  public void setNom(String pNom)
  {
    nomVille = pNom;
  }

  //Définit le nom du pays
  public void setNomPays(String pPays)
  {
    nomPays = pPays;
  }

  //Définit le nombre d'habitants
  public void setNombreHabitants(int nbre)
  {
    nbreHabitants = nbre;
    this.setCategorie();
  }  
 
  //Définit la catégorie 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.nbreHabitants >= bornesSuperieures[i])
      i++;

    this.categorie = categories[i];
  }

  //Retourne la description de la ville
  public String decrisToi(){
    return "\t"+this.nomVille+" est une ville de "+this.nomPays+ ", elle comporte : "+this.nbreHabitants+" habitant(s) => elle est donc de catégorie : "+this.categorie;
  }

  //Retourne une chaîne de caractères selon le résultat de la comparaison
  public String comparer(Ville v1){
    String str = new String();

    if (v1.getNombreHabitants() > this.nbreHabitants)
      str = v1.getNom()+" est une ville plus peuplée que "+this.nomVille;
     
    else
      str = this.nomVille+" est une ville plus peuplée que "+v1.getNom();
     
    return str;
  }
}

Pour expliciter le fonctionnement du mot clé this, prenons l'exemple de la méthode comparer(Ville V1). La méthode va s'utiliser comme suit :

Ville V = new Ville("Lyon", 654, "France");
Ville V2 = new Ville("Lille", 123, "France");
 
V.comparer(V2);

Dans cette méthode, nous voulons comparer le nombre d'habitants de chacun des deux objets Ville. Pour accéder à la variable nbreHabitants de l'objet V2, il suffit d'utiliser la syntaxe V2.getNombreHabitants() ; nous ferons donc référence à la propriété nbreHabitants de l'objet V2.
Mais l'objet V, lui, est l'objet appelant de cette méthode. Pour se servir de ses propres variables, on utilise alors this.nbreHabitants, ce qui a pour effet de faire appel à la variable nbreHabitants de l'objet exécutant la méthode comparer(Ville V).

Explicitons un peu les trois méthodes qui ont été décrites précédemment.

La méthode categorie()

Elle ne prend aucun paramètre, et ne renvoie rien : elle se contente de mettre la variable de classe categorie à jour. Elle détermine dans quelle tranche se trouve la ville grâce au nombre d'habitants de l'objet appelant, obtenu au moyen du mot clé this. Selon le nombre d'habitants, le caractère renvoyé changera. Nous l'appelons lorsque nous construisons un objet Ville (que ce soit avec ou sans paramètre), mais aussi lorsque nous redéfinissons le nombre d'habitants : de cette manière, la catégorie est automatiquement mise à jour, sans qu'on ait besoin de faire appel à la méthode.

La méthode decrisToi()

Celle-ci nous renvoie un objet de type String. Elle fait référence aux variables qui composent l'objet appelant la méthode, toujours grâce à this, et nous renvoie donc une chaîne de caractères qui nous décrit l'objet en énumérant ses composants.

La méthode comparer(Ville V1)

Elle prend une ville en paramètre, pour pouvoir comparer les variables nbreHabitants de l'objet appelant la méthode et de celui passé en paramètre pour nous dire quelle ville est la plus peuplée ! Et si nous faisions un petit test ?

Ville v = new Ville();
Ville v1 = new Ville("Marseille", 1236, "France");       
Ville v2 = new Ville("Rio", 321654, "Brésil");
        
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 donner le résultat de la figure suivante.

Je viens d'avoir une idée : et si nous essayions de savoir combien de villes nous avons créées ? Comment faire ? Avec une variable de classe !

Les variables de classes

Comme je vous le disais au début de ce chapitre, il y a plusieurs types de variables dans une classe. Nous avons vu les variables d'instance qui forment la carte d'identité d'un objet ; maintenant, voici les variables de classe.

Celles-ci peuvent s'avérer très utiles. Dans notre exemple, nous allons compter le nombre d'instances de notre classe Ville, mais nous pourrions les utiliser pour bien d'autres choses (un taux de TVA 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 !

Créons sans plus attendre notre compteur d'instances. Il s'agira d'une variable de type int que nous appellerons nbreInstance, et qui sera public ; nous mettrons aussi son homologue en private en place et l'appellerons nbreInstanceBis (il sera nécessaire de mettre un accesseur en place pour cette variable). Afin qu'une variable soit une variable de classe, elle doit être précédée du mot clé static. Cela donnerait dans notre classe Ville :

public class Ville {
   
  //Variables publiques qui comptent les instances
  public static int nbreInstances = 0;

  //Variable privée qui comptera aussi les instances
  private static int nbreInstancesBis = 0;        
  
  //Les autres variables n'ont pas changé

  public Ville(){
    //On incrémente nos variables à chaque appel aux constructeurs
    nbreInstances++;
    nbreInstancesBis++;          
    //Le reste ne change pas.
  }

  public Ville(String pNom, int pNbre, String pPays)
  {  
    //On incrémente nos variables à chaque appel aux constructeurs
    nbreInstances++;
    nbreInstancesBis++;          
    //Le reste ne change pas
  }
  public static int getNombreInstancesBis()
  {
    return nbreInstancesBis;
  }  
  //Le reste du code est le même qu'avant
}

Vous avez dû remarquer que l'accesseur de notre variable de classe déclarée privée est aussi déclaré static : ceci est une règle ! Toutes les méthodes de classe n'utilisant que des variables de classe doivent être déclarées static. On les appelle des méthodes de classe, car il n'y en a qu'une pour toutes vos instances. Par contre ce n’est plus une méthode de classe si celle-ci utilise des variables d'instance en plus de variables de classe…

À présent, si vous testez le code suivant, vous allez constater l'utilité des variables de classe :

Ville v = new Ville();                
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstances);
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstancesBis());
	                        
Ville v1 = new Ville("Marseille", 1236, "France");        
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstances);
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstancesBis());
                
Ville v2 = new Ville("Rio", 321654, "Brésil");        
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstances);
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstancesBis());

Le résultat, visible à la figure suivante, montre que le nombre augmente à chaque instanciation.

Lorsque vous avez vu les méthodes, vous les avez déclarées public. Vous auriez également pu les déclarer private, mais attention, dans les deux cas, il faut aussi qu'elles soient static, car elles sont exécutées dans un contexte static : la méthode main.

Le principe d'encapsulation

Voilà, vous venez de construire votre premier objet « maison ». Cependant, sans le savoir, vous avez fait plus que ça : vous avez créé un objet dont les variables sont protégées de l'extérieur. En effet, depuis l'extérieur de la classe, elles ne sont accessibles que via les accesseurs et mutateurs que nous avons défini. C'est le principe d'encapsulation !

En fait, lorsqu'on procède de la sorte, on s'assure que le fonctionnement interne à l'objet est intègre, car toute modification d'une donnée de l'objet est maîtrisée. Nous avons développé des méthodes qui s'assurent qu'on ne modifie pas n'importe comment les variables.

Prenons l'exemple de la variable nbreHabitants. L'encapsuler nous permet, lors de son affectation, de déduire automatiquement la catégorie de l'objet Ville, chose qui n'est pas facilement faisable sans encapsulation. Par extension, si vous avez besoin d'effectuer des opérations déterminées lors de l'affectation du nom d'une ville par exemple, vous n'aurez pas à passer en revue tous les codes source utilisant l'objet Ville : vous n'aurez qu'à modifier l'objet (ou la méthode) en question, et le tour sera joué.

Si vous vous demandez l'utilité de tout cela, dites-vous que vous ne serez peut-être pas seuls à développer vos logiciels, et que les personnes utilisant vos classes n'ont pas à savoir ce qu'il s'y passe : seules les fonctionnalités qui leurs sont offertes comptent. Vous le verrez en continuant la lecture de cet ouvrage, Java est souple parce qu'il offre beaucoup de fonctionnalités pouvant être retravaillées selon les besoins, mais gardez à l'esprit que certaines choses vous seront volontairement inaccessibles, pour éviter que vous ne « cassiez » quelque chose.

• Une classe permet de définir des objets. Ceux-ci ont des attributs (variables d'instance) et des méthodes (méthodes d’instance + accesseurs).

• Les objets permettent d'encapsuler du code et des données.

• Le ou les constructeurs d'une classe doivent porter le même nom que la classe et n'ont pas de type de retour.

• L'ordre des paramètres passés dans le constructeur doit être respecté.

• Il est recommandé de déclarer ses variables d'instance private, pour les protéger d'une mauvaise utilisation par le programmeur.

• On crée des accesseurs et mutateurs (méthodes getters et setters) pour permettre une modification sûre des variables d'instance.

• Dans une classe, on accède aux variables de celle-ci grâce au mot clé this.

• Une variable de classe est une variable devant être déclarée static.

• Les méthodes n'utilisant que des variables de classe doivent elles aussi être déclarées static.

• On instancie un nouvel objet grâce au mot clé new.

Le principe de l'héritage

Comme je vous l'ai dit dans l'introduction, la notion d'héritage est l'un des fondements de la programmation orientée objet. Grâce à elle, nous pourrons créer des classes héritées (aussi appelées classes classes dérivées) de nos classes mères (aussi appelées classes classes de base). Nous pourrons créer autant de classes dérivées, par rapport à notre classe de base, que nous le souhaitons. De plus, nous pourrons nous servir d'une classe dérivée comme d'une classe de base pour élaborer encore une autre classe dérivée.

Reprenons l'exemple dont je vous parlais dans l'introduction. Nous allons créer une nouvelle classe, nommée Capitale, héritée de Ville. Vous vous rendrez vite compte que les objets Capitale auront tous les attributs et toutes les méthodes associés aux objets Ville !

class Capitale extends Ville {

}

C'est le mot clé extends qui informe Java que la classe Capitale est héritée de Ville. Pour vous le prouver, essayez ce morceau de code dans votre main :

Capitale cap = new Capitale();
System.out.println(cap.decrisToi());

Vous devriez avoir la figure suivante en guise de rendu.

C'est bien la preuve que notre objet Capitale possède les propriétés de notre objet Ville. Les objets hérités peuvent accéder à toutes les méthodes public (ce n'est pas tout à fait vrai… Nous le verrons avec le mot clé protected) de leur classe mère, dont la méthode decrisToi() dans le cas qui nous occupe.

En fait, lorsque vous déclarez une classe, si vous ne spécifiez pas de constructeur, le compilateur (le programme qui transforme vos codes sources en byte code) créera, au moment de l'interprétation, le constructeur par défaut. En revanche, dès que vous avez créé un constructeur, n'importe lequel, la JVM ne crée plus le constructeur par défaut.

Notre classe Capitale hérite de la classe Ville, par conséquent, le constructeur de notre objet appelle, de façon tacite, le constructeur de la classe mère. C'est pour cela que les variables d'instance ont pu être initialisées ! Par contre, essayez ceci dans votre classe :

public class Capitale extends Ville{ 
  public Capitale(){
    this.nomVille = "toto";
  } 
}

Vous allez avoir une belle erreur de compilation ! Dans notre classe Capitale, nous ne pouvons pas utiliser directement les attributs de la classe Ville.

Pourquoi cela ? Tout simplement parce les variables de la classe Ville sont déclarées private. C'est ici que le nouveau mot clé protected fait son entrée. En fait, seules les méthodes et les variables déclarées public ou protected peuvent être utilisées dans une classe héritée ; le compilateur rejette votre demande lorsque vous tentez d'accéder à des ressources privées d'une classe mère !

Remplacer private par protected dans la déclaration de variables ou de méthodes de la classe Ville aura pour effet de les protéger des utilisateurs de la classe tout en permettant aux objets enfants d'y accéder. Donc, une fois les variables et méthodes privées de la classe mère déclarées en protected, notre objet Capitale aura accès à celles-ci ! Ainsi, voici la déclaration de nos variables dans notre classe Ville revue et corrigée :

public class Ville {
 
  public static int nbreInstances = 0;
  protected static int nbreInstancesBis = 0;
  protected String nomVille;
  protected String nomPays;
  protected int nbreHabitants;
  protected char categorie;
  
  //Tout le reste est identique. 
}

Notons un point important avant de continuer. Contrairement au C++, Java ne gère pas les héritages multiples : une classe dérivée (aussi appelée classe fille) ne peut hériter que d'une seule classe mère ! Vous n'aurez donc jamais ce genre de classe :

class AgrafeuseBionique extends AgrafeuseAirComprime, AgrafeuseManuelle{

}

La raison est toute simple : si nous admettons que nos classes AgrafeuseAirComprime et AgrafeuseManuelle ont toutes les deux une méthode agrafer() et que vous ne redéfinissez pas cette méthode dans l'objet AgrafeuseBionique, la JVM ne saura pas quelle méthode utiliser et, plutôt que de forcer le programmeur à gérer les cas d'erreur, les concepteurs du langage ont préféré interdire l'héritage multiple.

À présent, continuons la construction de notre objet hérité : nous allons agrémenter notre classe Capitale. Comme je vous l'avais dit, ce qui différenciera nos objets Capitale de nos objets Ville sera la présence d'un nouveau champ : le nom d'un monument. Cela implique que nous devons créer un constructeur par défaut et un constructeur d'initialisation pour notre objet Capitale.

Avant de foncer tête baissée, il faut que vous sachiez que nous pouvons faire appel aux variables de la classe mère dans nos constructeurs grâce au mot clé super. Cela aura pour effet de récupérer les éléments de l'objet de base, et de les envoyer à notre objet hérité. Démonstration :

class Capitale extends Ville {
 
  private String monument;
 
  //Constructeur par défaut
  public Capitale(){
    //Ce mot clé appelle le constructeur de la classe mère  
    super();
    monument = "aucun";
  }
}

Si vous essayez à nouveau le petit exemple que je vous avais montré un peu plus haut, vous vous apercevrez que le constructeur par défaut fonctionne toujours… Et pour cause : ici, super() appelle le constructeur par défaut de l'objet Ville dans le constructeur de Capitale. Nous avons ensuite ajouté un monument par défaut.

Cependant, la méthode decrisToi() ne prend pas en compte le nom d'un monument. Eh bien le mot clé super() fonctionne aussi pour les méthodes de classe, ce qui nous donne une méthode decrisToi() un peu différente, car nous allons lui ajouter le champ monument pour notre description :

class Capitale extends Ville {
  private String monument;
 
  public Capitale(){
    //Ce mot clé appelle le constructeur de la classe mère  
    super();
    monument = "aucun";
  } 

  public String decrisToi(){
    String str =  super.decrisToi() + "\n \t ==>>" + this.monument+ " en est un monument";
    System.out.println("Invocation de super.decrisToi()");
    
    return str;
   }
}

Si vous relancez les instructions présentes dans le main depuis le début, vous obtiendrez quelque chose comme sur la figure suivante.

J'ai ajouté les instructions System.out.println afin de bien vous montrer comment les choses se passent.

Bon, d'accord : nous n'avons toujours pas fait le constructeur d'initialisation de Capitale. Eh bien ? Qu'attendons-nous ?

public class Capitale extends Ville {
     
  private String monument;
    
  //Constructeur par défaut
  public Capitale(){
    //Ce mot clé appelle le constructeur de la classe mère
    super();
    monument = "aucun";
  }    
      
  //Constructeur d'initialisation de capitale
  public Capitale(String nom, int hab, String pays, String monument){
    super(nom, hab, pays);
    this.monument = monument;
  }    
     
  /**
    * Description d'une capitale
    * @return String retourne la description de l'objet
  */
  public String decrisToi(){
    String str = super.decrisToi() + "\n \t ==>>" + this.monument + "en est un monument";

    return str;
    } 

  /**
    * @return le nom du monument
  */
  public String getMonument() {
    return monument;
  } 

  //Définit le nom du monument
  public void setMonument(String monument) {
    this.monument = monument;
  }   
}

Dans le constructeur d'initialisation de notre Capitale, vous remarquez la présence de super(nom, hab, pays);. Cette ligne de code joue le même rôle que celui que nous avons précédemment vu avec le constructeur par défaut. Sauf qu'ici, le constructeur auquel super fait référence prend trois paramètres : ainsi, super doit prendre ces paramètres. Si vous ne lui mettez aucun paramètre, super() renverra le constructeur par défaut de la classe Ville.

Testez le code ci-dessous, il aura pour résultat la figure suivante.

Capitale cap = new Capitale("Paris", 654987, "France", "la tour Eiffel");
  System.out.println("\n"+cap.decrisToi());

Je vais vous interpeller une fois de plus : vous venez de faire de la méthode decrisToi() une méthode polymorphe, ce qui nous conduit sans détour à ce qui suit.

Le polymorphisme

Voici encore un des concepts fondamentaux de la programmation orientée objet : le polymorphisme. Ce concept complète parfaitement celui de l'héritage, et vous allez voir que le polymorphisme est plus simple qu'il n'y paraît. Pour faire court, nous pouvons le définir en disant qu'il permet de manipuler des objets sans vraiment connaître leur type.

Dans notre exemple, vous avez vu qu'il suffisait d'utiliser la méthode decrisToi() sur un objet Ville ou sur un objet Capitale. On pourrait construire un tableau d'objets et appeler decrisToi() sans se soucier de son contenu : villes, capitales, ou les deux.

D'ailleurs, nous allons le faire. Essayez ce code :

//Définition d'un tableau de villes null
Ville[] tableau = new Ville[6];
        
//Définition d'un tableau de noms de villes et un autre de nombres d'habitants
String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"};
int[] tab2 = {123456, 78456, 654987, 75832165, 1594, 213};
         
//Les trois premiers éléments 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", "la tour Eiffel");
    tableau[i] = C;
  }
}
                 
//Il ne nous reste plus qu'à décrire tout notre tableau !
for(Ville v : tableau){
  System.out.println(v.decrisToi()+"\n");
}

La figure suivante vous montre le résultat.

Nous créons un tableau de villes contenant des villes et des capitales (nous avons le droit de faire ça, car les objets Capitale sont aussi des objets Ville) grâce à notre première boucle for. Dans la seconde, nous affichons la description de ces objets… et vous voyez que la méthode polymorphe decrisToi() fait bien son travail !

Vous aurez sans doute remarqué que je n'utilise que des objets Ville dans ma boucle : on appelle ceci la covariance des variables ! Cela signifie qu'une variable objet peut contenir un objet qui hérite 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 superclasse de Capitale. La covariance est efficace dans le cas où la classe héritant redéfinit certaines méthodes de sa superclasse.

• Une méthode surchargée diffère de la méthode originale par le nombre ou le type des paramètres qu'elle prend en entrée.

• Une méthode polymorphe a un squelette identique à la méthode de base, mais traite les choses différemment. Cette méthode se trouve dans une autre classe et donc, par extension, dans une autre instance de cette autre classe.

Vous devez savoir encore une chose sur l'héritage. Lorsque vous créez une classe (Ville, par exemple), celle-ci hérite, de façon tacite, de la classe Object présente dans Java.

Toutes nos classes héritent donc des méthodes de la classe Object, comme equals() qui prend un objet en paramètre et qui permet de tester l'égalité d'objets. Vous vous en êtes d'ailleurs servis pour tester l'égalité de String() dans la première partie de ce livre.
Donc, en redéfinissant une méthode de la classe Object dans la classe Ville, nous pourrions utiliser la covariance.

La méthode de la classe Object la plus souvent redéfinie est toString() : elle retourne un String décrivant l'objet en question (comme notre méthode decrisToi()). Nous allons donc copier la procédure de la méthode decrisToi() dans une nouvelle méthode de la classe Ville : toString(). Voici son code :

public String toString(){
  return "\t"+this.nomVille+" est une ville de "+this.nomPays+", elle comporte : "+this.nbreHabitant+" => elle est donc de catégorie : "+this.categorie;
  }

Nous faisons de même dans la classe Capitale :

public String toString(){
  String str = super.toString() + "\n \t ==>>" + this.monument + " en est un monument";
  return str;
  }

Maintenant, testez ce code :

//Définition d'un tableau de villes null
Ville[] tableau = new Ville[6];
        
//Définition d'un tableau de noms de Villes et un autre de nombres d'habitants
String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"};
int[] tab2 = {123456, 78456, 654987, 75832165, 1594, 213};
         
//Les trois premiers éléments 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", "la tour Eiffel");
    tableau[i] = C;
  }
}
                 
//Il ne nous reste plus qu'à décrire tout notre tableau !
for(Object obj : tableau){
  System.out.println(obj.toString()+"\n");
}

Vous pouvez constater qu'il fait exactement la même chose que le code précédent ; nous n'avons pas à nous soucier du type d'objet pour afficher sa description. Je pense que vous commencez à entrevoir la puissance de Java !

Une précision s'impose : si vous avez un objet v de type Ville, par exemple, que vous n'avez pas redéfini la méthode toString() et que vous testez ce code :

System.out.println(v);

… vous appellerez automatiquement la méthode toString() de la classe Object ! Mais ici, comme vous avez redéfini la méthode toString() dans votre classe Ville, ces deux instructions sont équivalentes :

System.out.println(v.toString());
//Est équivalent à
System.out.println(v);

Pour plus de clarté, je conserverai la première syntaxe, mais il est utile de connaître cette alternative.

Pour clarifier un peu tout ça, vous avez accès aux méthodes public et protected de la classe Object dès que vous créez une classe objet (grâce à l'héritage tacite). Vous pouvez donc utiliser lesdites méthodes ; mais si vous ne les redéfinissez pas, l'invocation se fera sur la classe mère avec les traitements de la classe mère.

Si vous voulez un exemple concret de ce que je viens de vous dire, vous n'avez qu'à retirer la méthode toString() dans les classes Ville et Capitale : vous verrez que le code de la méthode main fonctionne toujours, mais que le résultat n'est plus du tout pareil, car à l'appel de la méthode toString(), la JVM va regarder si celle-ci existe dans la classe appelante et, comme elle ne la trouve pas, elle remonte dans la hiérarchie jusqu'à arriver à la classe Object…

Ainsi, ce code ne fonctionne pas :

public class Sdz1 {
   
  public static void main(String[] args){
                 
    Ville[] tableau = new Ville[6];
    String[] tab = {"Marseille", "lille", "caen", "lyon", "paris", "nantes"};
    int[] tab2 = {123456, 78456, 654987, 75832165, 1594, 213};

    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", "la tour Eiffel");
        tableau[i] = C;
      }
    }
                 
    //Il ne nous reste plus qu'à décrire tout notre tableau !
    for(Object v : tableau){
      System.out.println(v.decrisToi()+"\n");
    }
  }
}

Pour qu'il fonctionne, vous devez dire à la JVM que la référence de type Object est en fait une référence de type Ville, comme ceci : ((Ville)v).decrisToi();. Vous transtypez la référence v en Ville par cette syntaxe. Ici, l'ordre des opérations s'effectue comme ceci :

• vous transtypez la référence v en Ville ;

• vous appliquez la méthode decrisToi() à la référence appelante, c'est-à-dire, ici, une référence Object changée en Ville.

Vous voyez donc l'intérêt des méthodes polymorphes : grâce à elles, vous n'avez plus à vous soucier du type de variable appelante. Cependant, n'utilisez le type Object qu'avec parcimonie.

Il y a deux autres méthodes qui sont très souvent redéfinies :

• public boolean equals(Object o), qui permet de vérifier si un objet est égal à un autre ;

• public int hashCode(), qui attribue un code de hashage à un objet. En gros, elle donne un identifiant à un objet. Notez que cet identifiant sert plus à catégoriser votre objet qu'à l'identifier formellement.

La bonne nouvelle, c'est qu'Eclipse vous permet de générer automatiquement ces deux méthodes, via le menu Source/Generate hashcode and equals. Voilà à quoi pourraient ressembler ces deux méthodes pour notre objet Ville.

public int hashCode() {
  //On définit un multiplication impair, de préférence un nombre premier
  //Ceci afin de garantir l'unicité du résultat final
  final int prime = 31;
  //On définit un résultat qui sera renvoyé au final
  int result = 1;
  //On ajoute en eux la multiplication des attributs et du multiplicateur
  result = prime * result + categorie;
  result = prime * result + nbreHabitants;
  //Lorsque vous devez gérer des hashcodes avec des objets dans le mode de calcul
  //Vous devez vérifier si l'objet n'est pas null, sinon vous aurez une erreur
  result = prime * result + ((nomPays == null) ? 0 : nomPays.hashCode());
  result = prime * result + ((nomVille == null) ? 0 : nomVille.hashCode());
  return result;
}


public boolean equals(Object obj) {
  //On vérifie si les références d'objets sont identiques
  if (this == obj)
    return true;

  //On vérifie si l'objet passé en paramètre est null
  if (obj == null)
    return false;

  //On s'assure que les objets sont du même type, ici de type Ville
  //La méthode getClass retourne un objet Class qui représente la classe de votre objet
  //Nous verrons ça un peu plus tard...
  if (getClass() != obj.getClass())
    return false;

  //Maintenant, on compare les attributs de nos objets
  Ville other = (Ville) obj;
  if (categorie != other.categorie)
    return false;
  if (nbreHabitants != other.nbreHabitants)
    return false;
  if (nomPays == null) {
    if (other.nomPays != null)
      return false;
  }
  else if (!nomPays.equals(other.nomPays))
    return false;

  if (nomVille == null) {
    if (other.nomVille != null)
      return false;
  }
  else if (!nomVille.equals(other.nomVille))
    return false;
	
  return true;
}

Il existe encore un type de méthodes dont je ne vous ai pas encore parlé : le type final. Une méthode signée final est figée, vous ne pourrez jamais la redéfinir (la méthode getClass() de la classe Object est un exemple de ce type de méthode : vous ne pourrez pas la redéfinir).

public final int maMethode(){
  //Méthode ne pouvant pas être surchargée
}

Il en va de même pour les variables déclarées de la sorte. :)

Depuis Java 7 : la classe Objects

Nous avons vu précédemment que les méthode equals() et hashcode() sont souvent redéfinies afin de pouvoir gérer l'égalité de vos objets et de les catégoriser. Vous avez pu vous rendre compte que leur redéfinition n'est pas des plus simples (si nous le faisons avec nos petits doigts).

Avec Java 7, il existe une classe qui permet de mieux gérer la redéfinitions de ces méthodes : java.util.Objects. Attention, il ne s'agit pas de la classe java.lang.Object dont tous les objets héritent ! Ici il s'agit d'Objects avec un « s » ! Ce nouvel objet ajoute deux fonctionnalités qui permettent de simplifier la redéfinition des méthodes vues précédemment.

Nous allons commencer par la plus simple : hashcode(). La classe Objects propose une méthode hash(Object… values). Cette méthode s'occupe de faire tout le nécessaire au calcul d'un code de hashage en vérifiant si les attributs sont null ou non et tutti quanti. C'est tout de même sympa. Voici à quoi ressemblerait notre méthode hashcode() avec cette nouveauté :

public int hashCode() {
  return Objects.hash(categorie, nbreHabitants, nomPays, nomVille);
}

Ce nouvel objet intègre aussi une méthode equals() qui se charge de vérifier si les valeurs passées en paramètre sont null ou non. Du coup, nous aurons un code beaucoup plus clair et lisible. Voici à quoi ressemblerait notre méthode equals() de l'objet Ville :

public boolean equals(Object obj) {
  //On vérifie si les références d'objets sont identiques
  if (this == obj)
    return true;

  //On s'assure que les objets sont du même type, ici de type Ville
  if (getClass() != obj.getClass())
    return false;
	
  //Maintenant, on compare les attributs de nos objets
  Ville other = (Ville) obj;

  return Objects.equals(other.getCategorie(), this.getCategorie()) &&
	 Objects.equals(other.getNom(), this.getNom()) &&
	 Objects.equals(other.getNombreHabitants(), this.getNombreHabitants()) &&
	 Objects.equals(other.getNomPays(), this.getNomPays());
}

Avouez que c'est plus clair et plus pratique…

• Une classe hérite d'une autre classe par le biais du mot clé extends.

• Une classe ne peut hériter que d'une seule classe.

• Si aucun constructeur n'est défini dans une classe fille, la JVM en créera un et appellera automatiquement le constructeur de la classe mère.

• La classe fille hérite de toutes les propriétés et méthodes public et protected de la classe mère.

• Les méthodes et les propriétés private d'une classe mère ne sont pas accessibles dans la classe fille.

• On peut redéfinir une méthode héritée, c'est-à-dire qu'on peut changer tout son code.

• On peut utiliser le comportement d'une classe mère par le biais du mot clé super.

• Grâce à l'héritage et au polymorphisme, nous pouvons utiliser la covariance des variables.

• Si une méthode d'une classe mère n'est pas redéfinie ou « polymorphée », à l'appel de cette méthode par le biais d'un objet enfant, c'est la méthode de la classe mère qui sera utilisée.

• Vous ne pouvez pas hériter d'une classe déclarée final.

• Une méthode déclarée final n'est pas redéfinissable.

Présentation d'UML

Je sais que vous êtes des Zéros avertis en matière de programmation, ainsi qu'en informatique en général, mais mettez-vous dans la peau d'une personne totalement dénuée de connaissances dans le domaine. Il fallait trouver un langage commun aux commerciaux, aux responsables de projets informatiques et aux développeurs, afin que tout ce petit monde se comprenne. Avec UML, c'est le cas.

En fait, avec UML, vous pouvez modéliser toutes les étapes du développement d'une application informatique, de sa conception à la mise en route, grâce à des diagrammes. Il est vrai que certains de ces diagrammes sont plus adaptés pour les informaticiens, mais il en existe qui permettent de voir comment interagit l'application avec son contexte de fonctionnement… Et dans ce genre de cas, il est indispensable de bien connaître l'entreprise pour laquelle l'application est prévue. On recourt donc à un mode de communication compréhensible par tous : UML.

Il existe bien sûr des outils de modélisation pour créer de tels diagrammes. En ce qui me concerne, j'utilise argoUML. Il a le mérite d'être gratuit et écrit en Java, donc multi-plates-formes.

Cependant, il en existe d'autres, comme :

• boUML,

• Together,

• Poseidon,

• Pyut

• etc.

Avec ces outils, vous pouvez réaliser les différents diagrammes qu'UML vous propose :

• le diagramme de use case (cas d'utilisation) permet de déterminer les différents cas d'utilisation d'un programme informatique ;

• le diagramme de classes ; c'est de celui-là que nous allons nous servir. Il permet de modéliser des classes ainsi que les interactions entre elles ;

• les diagrammes de séquences, eux, permettent de visualiser le déroulement d'une application dans un contexte donné ;

• et d'autres encore…

La figure suivante représente un exemple de diagramme de classes.

Vous avez dû remarquer qu'il représente les classes que nous avons rencontrées dans les chapitres précédents. Je ne vous cache pas qu'il s'agit d'une version simplifiée. En effet, vous pouvez constater que je n'ai pas fait figurer les méthodes déclarées public de la classe Object, ni celles des classes que nous avons codées.

Je ne vais pas vous apprendre à utiliser argoUML, mais plutôt à lire un diagramme. En effet, dans certains cas, il est utile de modéliser les classes et l'interaction entre celles-ci, ne serait-ce que pour disposer de plus de recul sur son travail. Une autre raison à cela est que certains concepts de programmation sont plus faciles à expliquer avec un diagramme qu'avec de longs discours...

Modéliser ses objets

À présent, nous allons apprendre à lire un diagramme de classes. Vous avez deviné qu'une classe est modélisée sous la forme représentée sur la figure suivante.

Voici une classe nommée ObjetA qui a comme attributs :

• numero de type int ;

• nom de type String ;

• bool de type boolean.

Ses méthodes sont :

• getNom() qui retourne une chaîne de caractères ;

• setNom() qui ne renvoie rien ;

• afficher() qui renvoie également une chaîne de caractères.

La portée des attributs et des méthodes n'est pas représentée ici. Vous voyez, la modélisation d'un objet est toute simple et très compréhensible !

Maintenant, intéressons-nous aux interactions entre objets.

Modéliser les liens entre les objets

Vous allez voir : les interactions sont, elles aussi, très simples à modéliser.
En fait, comme vous l'avez vu avec l'exemple, les interactions sont modélisées par des flèches de plusieurs sortes. Nous aborderons ici celles dont nous pouvons nous servir dans l'état actuel de nos connaissances (au fur et à mesure de la progression, d'autres flèches apparaîtront).

Sur le diagramme représenté à la figure suivante, vous remarquez un deuxième objet qui dispose, lui aussi, de paramètres. Ne vous y trompez pas, ObjetB possède également les attributs et les méthodes de la classe ObjetA. D'après vous, pourquoi ? C'est parce que la flèche qui relie nos deux objets signifie « extends ». En gros, vous pouvez lire ce diagramme comme suit : l'ObjetBhérite de l'ObjetA, ou encore ObjetBest unObjetA.

Nous allons voir une autre flèche d'interaction. Je sais que nous n'avons pas encore rencontré ce cas de figure, mais il est simple à comprendre.

De la même façon que nous pouvons utiliser des objets de type String dans des classes que nous développons, nous pouvons aussi utiliser comme variable d'instance, ou de classe, un objet que nous avons codé. La figure suivante modélise ce cas.

Dans cet exemple simpliste, nous avons toujours notre héritage entre un objet A et un objet B, mais dans ce cas, l'ObjetA (et donc l'ObjetB) possède une variable de classe de type ObjetC, ainsi qu'une méthode dont le type de retour est ObjetC (car la méthode retourne un ObjetC). Vous pouvez lire ce diagramme comme suit : l'ObjetAa unObjetC (donc une seule instance d'ObjetC est présente dans ObjetA).

Voici le code Java correspondant à ce diagramme.

Fichier ObjetA.java

public class ObjetA{
  protected ObjetC obj = new ObjetC();
   
  public ObjetC getObject(){      
    return obj;    
  }
}

Fichier ObjetB.java

public class ObjetB extends ObjetA{ 

}

Fichier ObjetC.java

public class ObjetC{ 

}

Il reste une dernière flèche que nous pouvons mentionner, car elle ne diffère que légèrement de la première. Un diagramme la mettant en œuvre est représenté sur la figure suivante.

Ce diagramme est identique au précédent, à l'exception de l'ObjetD. Nous devons le lire comme ceci : l'ObjetAest composé de plusieurs instances d'ObjetD. Vous pouvez d'ailleurs remarquer que la variable d'instance correspondante est de type tableau…

Voici le code Java correspondant :

Fichier ObjetA.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

public class ObjetB extends ObjetA{

}

Fichier ObjetC.java

public class ObjetC{

}

Fichier ObjetD.java

public class ObjetD{

}

Voilà, c'en est fini pour le moment. Attendez-vous donc à rencontrer des diagrammes dans les prochains chapitres !

• UML vous permet de représenter les liens entre vos classes.

• Vous pouvez y modéliser leurs attributs et leurs méthodes.

• Vous pouvez représenter l'héritage avec une flèche signifiant « est un ».

• Vous pouvez représenter l'appartenance avec une flèche signifiant « a un ».

• Vous pouvez représenter la composition avec une flèche signifiant « est composé de ».

Création d'un package

L'un des avantages des packages est que nous allons y gagner en lisibilité dans notre package par défaut, mais aussi que les classes mises dans un package sont plus facilement transportables d'une application à l'autre. Pour cela, il vous suffit d'inclure le dossier de votre package dans un projet et d'y importer les classes qui vous intéressent !
Pour créer un nouveau package, cliquez simplement sur cette icône comme à la figure suivante (vous pouvez aussi effectuer un clic droit puis New > Package).

Une boîte de dialogue va s'ouvrir et vous demander le nom de votre package, comme à la figure suivante.

Il existe aussi une convention de nommage pour les packages :

• ceux-ci doivent être écrits entièrement en minuscules ;

• les caractères autorisés sont alphanumériques (de a à z, de 0 à 9) et peuvent contenir des points (.) ;

• tout package doit commencer par com, edu, gov, mil, net, org ou les deux lettres identifiant un pays (ISO Standard 3166, 1981) ; « fr » correspond à la France, « en » correspond à l'Angleterre (pour England)etc.

• aucun mot clé Java ne doit être présent dans le nom, sauf si vous le faites suivre d'un underscore (« _ »), comme ceci : com.sdz.package_.

Comme ce cours est issu du Site du Zéro, j'ai pris le nom à l'envers : « sdz.com » nous donne « com.sdz ». Pour le cas qui nous occupe, appelons-le com.sdz.test. Cliquez sur Finish pour créer le package. Et voilà : celui-ci est prêt à l'emploi.

Vous conviendrez que la création d'un package est très simple. Cependant, je ne peux pas vous laisser sans savoir que la portée de vos classes est affectée par les packages…

Droits d'accès entre les packages

Lorsque vous avez créé votre première classe, vous avez vu qu'Eclipse met systématiquement le mot clé public devant la déclaration de la classe. Je vous avais alors dit que public class Ville et class Ville étaient sensiblement différents et que le mot clé public influait sur la portée de notre classe. En fait, une classe déclarée avec le mot clé public sera visible même à l'extérieur de son package, les autres ne seront accessibles que depuis l'intérieur du package : on dit que leur portée est default.

Afin de vous prouver mes dires, je vous invite à créer un second package : je l'ai appelé « com.sdz.test2 ». Dans le premier package, com.sdz.test, créez une classe A de portée public et une classe B de portée default, comme ceci (j'ai volontairement déclaré les variables d'instance public afin d'alléger l'exemple) :

package com.sdz.test;

class B {
  public String str ="";
}

package com.sdz.test;

public class A {
  public B b = new B();
}

Maintenant que cela est fait, afin de faire le test, créez une classe contenant la méthode main, toujours dans le même package, comme ceci :

package com.sdz.test;

public class Main {
  public static void main(String[] args){
    A a = new A();
    B b = new B();
    //Aucun problème ici
  }
}

Ce code, bien qu'il ne fasse rien, fonctionne très bien : aucun problème de compilation, entre autres. Maintenant, faites un copier-coller de la classe ci-dessus dans le package com.sdz.test2. Vous devriez avoir le résultat représenté à la figure suivante.

Vous pouvez constater qu'Eclipse n'aime ni l'instruction import com.sdz.test.B, ni l'instruction B b = new B();. Cela est dû à la déclaration de notre classe. J'irai même plus loin : si vous essayez de modifier la variable d'instance de l'objet A, vous aurez le même problème. Donc, ceci : a.b.str = "toto"; n'est pas non plus autorisé dans ce package ! La seule façon de corriger le problème est de déclarer la classe Bpublic. Rappelez-vous que seule la classe A avait été déclarée ainsi.

• Un package est un ensemble de dossiers et de sous-dossiers.

• Le nom du package est soumis à une convention de nommage.

• Si vous voulez utiliser un mot clé Java dans le nom de votre package, vous devez le faire suivre d'un underscore (« _ »).

• Les classes déclarées public sont visibles depuis l'extérieur du package qui les contient.

• Les classes n'ayant pas été déclarées public ne sont pas visibles depuis l'extérieur du package qui les contient.

• Si une classe déclarée public dans son package a une variable d'un type ayant une portée default, cette dernière ne pourra pas être modifiée depuis l'extérieur de son package.

Les classes abstraites

Une classe abstraite est quasiment identique à une classe normale. Oui, identique aux classes que vous avez maintenant l'habitude de coder. Cela dit, elle a tout de même une particularité : vous ne pouvez pas l'instancier ! Vous avez bien lu. Imaginons que nous ayons une classe A déclarée abstraite. Voici un code qui ne compilera pas :

public class Test{
  public static void main(String[] args){
    A obj = new A(); //Erreur de compilation !  
  }
}

Pour bien en comprendre l'utilité, il vous faut un exemple de situation (de programme, en fait) qui le requiert. Imaginez que vous êtes en train de réaliser un programme qui gère différents types d'animaux (oui, je sais : l'exemple est bête, mais il a le mérite d'être simple à comprendre).

Dans ce programme, vous aurez des loups, des chiens, des chats, des lions et des tigres. Mais vous n'allez tout de même pas faire toutes vos classes bêtement : il va de soi que tous ces animaux ont des points communs ! Et qui dit points communs dit héritage. Que pouvons-nous définir de commun à tous ces animaux ? Le fait qu'ils aient une couleur, un poids, un cri, une façon de se déplacer, qu'ils mangent et boivent quelque chose.

Nous pouvons donc créer une classe mère : appelons-la Animal. Avec ce que nous avons dégagé de commun, nous pouvons lui définir des attributs et des méthodes. La figure suivante représente nos classes.

Nous avons bien notre classe mère Animal et nos animaux qui en héritent. À présent, laissez-moi vous poser une question. Vu que notre classe Animal est public, qu'est censé faire un objet Animal ? Quel est son poids, sa couleur, que mange-t-il ? Je sais, cela fait plus qu'une question. :p

Si nous avons un morceau de code qui ressemble à ceci :

public class Test{
  public static void main(String[] args){
    Animal ani = new Animal();
    ((Loup)ani).manger(); //Que doit-il faire ?
  }
}

Personnellement, je ne sais pas ce que mange un objet Animal. Vous conviendrez que toutes les classes ne sont pas bonnes à être instanciées !

C'est là qu'entrent en jeu nos classes abstraites. En fait, ces classes servent à définir une superclasse : par là, vous pouvez comprendre qu'elles servent essentiellement à créer un nouveau type d'objets. Voyons maintenant comment créer une telle classe.

Une classe Animal très abstraite

En fait, il existe une règle pour qu'une classe soit considérée comme abstraite. Elle doit être déclarée avec le mot clé abstract. Voici un exemple illustrant mes dires :

abstract class Animal{ }

Une telle classe peut contenir la même chose qu'une classe normale. Ses enfants pourront utiliser tous ses éléments déclarés (attributs et méthodes déclarés public ou protected, nous sommes d'accord). Cependant, ce type de classe permet de définir des méthodes abstraites qui présentent une particularité : elle n'ont pas de corps ! En voici un exemple :

abstract class Animal{
  abstract void manger(); //Une méthode abstraite
}

Vous voyez pourquoi on dit « méthode abstraite » : difficile de voir ce que cette méthode sait faire.

Il faut que vous sachiez qu'une méthode abstraite ne peut exister que dans une classe abstraite. Si, dans une classe, vous avez une méthode déclarée abstraite, vous devez déclarer cette classe comme étant abstraite.

Voyons à quoi cela peut servir. Vous avez vu les avantages de l'héritage et du polymorphisme. Eh bien nos classes enfants hériteront aussi des méthodes abstraites, mais étant donné que celles-ci n'ont pas de corps, nos classes enfants seront obligées de redéfinir ces méthodes ! Elles présentent donc des méthodes polymorphes, ce qui implique que la covariance des variables pointe à nouveau le bout de son nez :

public class Test{
  public static void main(String args[]){
    Animal loup = new Loup();
    Animal chien = new Chien();
    loup.manger();
    chien.crier(); 
  }
}

Et je maintiens mes dires : 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 même pour l'instanciation de la classe Chien). Vous devez vous rappeler que l'instance se crée avec le mot clé new. En aucun cas, le fait de déclarer une variable d'un type de classe donné – ici, Animal – n'est une instanciation ! Ici, nous instancions un Loup et un Chien.

Vous pouvez aussi utiliser une variable de type Object comme référence à un objet Loup, à un objet Chien etc. Vous saviez déjà que ce code fonctionne :

public class Test{
  public static void main(String[] args){
    Object obj = new Loup();
    ((Loup)obj).manger();
  }
}

En revanche, ceci pose problème :

public static void main(String[] args){
  Object obj = new Loup();
  Loup l = obj; //Problème de référence
}

Eh oui ! Nous essayons de mettre une référence de type Object dans une référence de type Loup : pour avertir la JVM que la référence que vous voulez affecter à votre objet de type Loup est un Loup, vous devez utiliser le transtypage ! Revoyons notre code :

public static void main(String[] args){
  Object obj = new Loup();
  Loup l = (Loup)obj;
  //Vous prévenez la JVM que la référence que vous passez est de type Loup.
}

Vous pouvez bien évidemment instancier directement un objet Loup, un objet Chien, etc.

Étoffons notre exemple

Nous allons donc ajouter des morceaux de code à nos classes. Tout d'abord, établissons un bilan de ce que nous savons :

• Nos objets seront probablement tous de couleur et de poids différents. Nos classes auront donc le droit de modifier ceux-ci.

• Ici, nous partons du principe que tous nos animaux mangent de la viande. La méthode manger() sera donc définie dans la classe Animal.

• Idem pour la méthode boire(). Ils boiront tous de l'eau (je vous voyais venir).

• Ils ne crieront pas et ne se déplaceront pas de la même manière. Nous emploierons donc des méthodes polymorphes et déclarerons les méthodes deplacement() et crier() abstraites dans la classe Animal.

La figure suivante représente le diagramme des classes de nos futurs objets. Ce diagramme permet de voir si une classe est abstraite : son nom est alors en italique.

Nous voyons bien que notre classe Animal est déclarée abstraite et que nos classes filles héritent de celle-ci. De plus, nos classes filles ne redéfinissent que deux méthodes sur quatre, on en conclut donc que ces deux méthodes doivent être abstraites. Nous ajouterons deux constructeurs à nos classes filles : un par défaut et un autre comprenant les deux paramètres d'initialisation. À cela, nous ajouterons aussi les accesseurs d'usage. Mais dites donc… nous pouvons améliorer un peu cette architecture, sans pour autant rentrer dans les détails !

Vu les animaux présents, nous aurions pu faire une sous-classe Carnivore, ou encore AnimalDomestique et AnimalSauvage… Ici, nous allons nous contenter de faire deux sous-classes : Canin et Felin, qui hériteront d'Animal et dont nos objets eux-mêmes hériteront !

Nous allons redéfinir la méthode deplacement() dans cette classe, car nous allons partir du principe que les félins se déplacent d'une certaine façon et les canins d'une autre. Avec cet exemple, nous réviserons le polymorphisme. La figure suivante correspond à notre diagramme mis à jour (vous avez remarqué ? J'ai ajouté une méthode toString()).

Voici les codes Java correspondants.

Animal.java

abstract class Animal {

  protected String couleur;
  protected int poids;

  protected void manger(){
    System.out.println("Je mange de la viande.");
  }
        
  protected void boire(){
    System.out.println("Je bois de l'eau !");
  }
        
  abstract void deplacement();
        
  abstract void crier();
        
  public String toString(){
    String str = "Je suis un objet de la " + this.getClass() + ", je suis " + this.couleur + ", je pèse " + this.poids;
    return str;
  }        
}

Felin.java

public abstract class Felin extends Animal {
  void deplacement() {
    System.out.println("Je me déplace seul !");
  } 
}

Canin.java

public abstract class Canin extends Animal {
  void deplacement() {
    System.out.println("Je me déplace en meute !");
  }
}

Chien.java

public class Chien extends Canin {
 
  public Chien(){

  }

  public Chien(String couleur, int poids){
    this.couleur = couleur;
    this.poids = poids;
  }       

  void crier() {
    System.out.println("J'aboie sans raison !");
  } 
}

Loup.java

public class Loup extends Canin {
 
  public Loup(){
                
  }

  public Loup(String couleur, int poids){
    this.couleur = couleur;
    this.poids = poids;
  }       
 
  void crier() {
    System.out.println("Je hurle à la Lune en faisant ouhouh !"); 
  }
}

Lion.java

public class Lion extends Felin {
 
  public Lion(){

  }

  public Lion(String couleur, int poids){
    this.couleur = couleur;
    this.poids = poids;
  }       
 
  void crier() {
    System.out.println("Je rugis dans la savane !");
  } 
}

Tigre.java

public class Tigre extends Felin {
 
  public Tigre(){

  }
  public Tigre(String couleur, int poids){
    this.couleur = couleur;
    this.poids = poids;
  }
        
  void crier() {
    System.out.println("Je grogne très fort !");
  } 
}

Chat.java

public class Chat extends Felin {
 
  public Chat(){

  }
  public Chat(String couleur, int poids){
    this.couleur = couleur;
    this.poids = poids;
  }
        
  void crier() {
    System.out.println("Je miaule sur les toits !");
  } 
}

Je n'ai jamais dit ça ! Une classe déclarée abstraite n'est pas « instanciable », mais rien ne l'oblige à comprendre des méthodes abstraites. En revanche, une classe contenant une méthode abstraite doit être déclarée abstraite ! Je vous invite maintenant à faire des tests :

public class Test { 
  public static void main(String[] args) {
    Loup l = new Loup("Gris bleuté", 20);
    l.boire();
    l.manger();
    l.deplacement();
    l.crier();
    System.out.println(l.toString());
  } 
}

Le jeu d'essai de ce code correspond à la figure suivante.

Dans cet exemple, nous pouvons constater que nous avons un objet Loup :

• À l'appel de la méthode boire() : l'objet appelle la méthode de la classe Animal.

• À l'appel de la méthode manger() : idem.

• À l'appel de la méthode toString() : idem.

• À l'appel de la méthode deplacement() : c'est la méthode de la classe Canin qui est invoquée ici.

• À l'appel de la méthode crier() : c'est la méthode de la classe Loup qui est appelée.

Remplacez le type de référence (ici, Loup) par Animal, essayez avec des objets Chien, etc. Vous verrez que tout fonctionne.

Les interfaces

L'un des atouts majeurs — pour ne pas dire l'atout majeur — de la programmation orientée objet est la réutilisabilité de vos objets. Il est très commode d'utiliser un objet (voire une architecture) que nous avons déjà créé pour une nouvelle application.

Admettons que l'architecture que nous avons développée dans les chapitres précédents forme une bonne base. Que se passerait-il si un autre développeur vous demandait d'utiliser vos objets dans un autre type d'application ? Ici, nous ne nous sommes occupés que de l'aspect générique des animaux que nous avons créés. Cependant, la personne qui vous a contacté, elle, développe une application pour un chenil.

La contrainte principale, c'est que vos chiens devront apprendre à faire de nouvelles choses telles que :

• faire le beau ;

• faire des câlins ;

• faire une « léchouille ».

Ouh là ! Vous vous rendez compte que vous obtiendrez des lions qui auront la possibilité de faire le beau ? Dans ce cas, on n'a qu'à mettre ces méthodes dans la classe Chien, mais j'y vois deux problèmes :

1. vous allez devoir mettre en place une convention de nommage entre le programmeur qui va utiliser vos objets et vous. Vous ne pourrez pas utiliser la méthode faireCalin(), alors que le programmeur oui ;

2. si vous faites cela, adieu au polymorphisme ! Vous ne pourrez pas appeler vos objets par le biais d'un supertype. Pour pouvoir accéder à ces méthodes, vous devrez obligatoirement passer par une référence à un objet Chien. Pas terrible, tout ça !

Oui, et je vous rappelle que l'héritage multiple est interdit en Java. Et quand je dis interdit, je veux dire que Java ne le gère pas ! Il faudrait pouvoir développer un nouveau supertype et s'en servir dans nos classes Chien. Eh bien nous pouvons faire cela avec des interfaces.

En fait, les interfaces permettent de créer un nouveau supertype ; on peut même en ajouter autant que l'on le veut dans une seule classe ! Quant à l'utilisation de nos objets, la convention est toute trouvée. Pourquoi ? Parce qu'une interface n'est rien d'autre qu'une classe 100 % abstraite ! Allez : venons-en aux faits !

Votre première interface

Pour définir une interface, au lieu d'écrire :

public class A{ }

… il vous suffit de faire :

public interface I{ }

Voilà : vous venez d'apprendre à déclarer une interface. Vu qu'une interface est une classe 100 % abstraite, il ne vous reste qu'à y ajouter des méthodes abstraites, mais sans le mot clé abstract.

Voici des exemples d'interfaces :

public interface I{ 
  public void A();
  public String B(); 
}

public interface I2{ 
  public void C();
  public String D(); 
}

Et pour faire en sorte qu'une classe utilise une interface, il suffit d'utiliser le mot clé implements. Ce qui nous donnerait :

public class X implements I{
  public void A(){
    //…
  } 
  public String B(){
    //…
  }
}

C'est tout. On dit que la classe X implémente l'interface I. Comme je vous le disais, vous pouvez implémenter plusieurs interfaces, et voilà comment ça se passe :

public class X implements I, I2{
  public void A(){
    //…
  } 
  public String B(){
    //…
  } 
  public void C(){
    //…
  } 
  public String D(){
    //…
  }
}

Par contre, lorsque vous implémentez une interface, vous devez obligatoirement redéfinir les méthodes de l'interface ! Ainsi, le polymorphisme vous permet de faire ceci :

public static void main(String[] args){
  //Avec cette référence, vous pouvez utiliser les méthodes de l'interface I
  I var = new X();
  //Avec cette référence, vous pouvez utiliser les méthodes de l'interface I2
  I2 var2 = new X();
  var.A();
  var2.C();   
}

Implémentation de l'interface Rintintin

Voilà où nous en sommes :

• nous voulons que nos chiens puissent être amicaux ;

• nous voulons définir un supertype pour utiliser le polymorphisme ;

• nous voulons pouvoir continuer à utiliser nos objets comme avant.

Comme le titre de cette sous-section le stipule, nous allons créer l'interface Rintintin pour ensuite l'implémenter dans notre objet Chien.

Sous Eclipse, vous pouvez faire File > New > Interface, ou simplement cliquer sur la flèche noire à côté du « C » pour la création de classe, et choisir interface, comme à la figure suivante. Voici son code :

public interface Rintintin{
  public void faireCalin();
  public void faireLechouille();
  public void faireLeBeau();
 
}

À présent, il ne nous reste plus qu'à implémenter l'interface dans notre classe Chien :

public class Chien extends Canin implements Rintintin {
 
  public Chien(){

  }
  public Chien(String couleur, int poids){
    this.couleur = couleur;
    this.poids = poids;
  }                

  void crier() {
    System.out.println("J'aboie sans raison !");
  }        

  public void faireCalin() {
    System.out.println("Je te fais un GROS CÂLIN");               
  }

  public void faireLeBeau() {
    System.out.println("Je fais le beau !");
  }

  public void faireLechouille() {
    System.out.println("Je fais de grosses léchouilles...");
  } 
}

Voici un code que vous pouvez utiliser pour tester le polymorphisme de notre implémentation :

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

    //Les méthodes d'un chien 
    Chien c = new Chien("Gris bleuté", 20);
    c.boire();
    c.manger();
    c.deplacement();
    c.crier();
    System.out.println(c.toString());
			
    System.out.println("--------------------------------------------");
    //Les méthodes de l'interface
    c.faireCalin();
    c.faireLeBeau();
    c.faireLechouille();
		
    System.out.println("--------------------------------------------");
    //Utilisons le polymorphisme de notre interface
    Rintintin r = new Chien();
    r.faireLeBeau();
    r.faireCalin();
    r.faireLechouille();
  } 
}

Objectif atteint ! Nous sommes parvenus à définir deux superclasses afin de les utiliser comme supertypes et de jouir pleinement du polymorphisme.

Dans la suite de ce chapitre, nous verrons qu'il existe une façon très intéressante d'utiliser les interfaces grâce à une technique de programmation appelée « pattern strategy ». Sa lecture n'est pas indispensable, mais cela vous permettra de découvrir à travers un cas concret comment on peut faire évoluer au mieux un programme Java.

Le pattern strategy

Nous allons partir du principe que vous avez un code qui fonctionne, c'est-à-dire un ensemble de classes liées par l'héritage, par exemple. Nous allons voir ici que, en dépit de la puissance de l'héritage, celui-ci atteint ses limites lorsque vous êtes amenés à modifier la hiérarchie de vos classes afin de répondre à une demande (de votre chef, d'un client etc.).

Le fait de toucher à votre hiérarchie peut amener des erreurs indésirables, voire des absurdités : tout cela parce que vous allez changer une structure qui fonctionne à cause de contraintes que l'on vous impose. Pour remédier à ce problème, il existe un concept simple (il s'agit même d'un des fondements de la programmation orientée objet) : l'encapsulation !

Nous allons parler de cette solution en utilisant un design pattern (ou « modèle de conception » en français). Un design pattern est un patron de conception, une façon de construire une hiérarchie des classes permettant de répondre à un problème. Nous aborderons le pattern strategy, qui va nous permettre de remédier à la limite de l'héritage. En effet, même si l'héritage offre beaucoup de possibilités, il a ses limites.

Posons le problème

Mettez-vous dans la peau de développeurs jeunes et ambitieux d'une toute nouvelle société qui crée des jeux vidéo. Le dernier titre en date, « Z-Army », un jeu de guerre très réaliste, a été un succès international ! Votre patron est content et vous aussi. Vous vous êtes basés sur une architecture vraiment simple afin de créer et utiliser des personnages, comme le montre la figure suivante.

Les guerriers savent se battre tandis que les médecins soignent les blessés sur le champ de bataille. Et c'est maintenant que commencent les ennuis !

Votre patron vous a confié le projet « Z-Army 2 : The return of the revenge », et vous vous dites : « Yes ! Mon architecture fonctionne à merveille, je la garde. » Un mois plus tard, votre patron vous convoque dans son bureau et vous dit : « Nous avons fait une étude de marché, et il semblerait que les joueurs aimeraient se battre aussi avec les médecins ! » Vous trouvez l'idée séduisante et avez déjà pensé à une solution : déplacer la méthode combattre() dans la superclasse Personnage, afin de la redéfinir dans la classe Medecin et jouir du polymorphisme ! La figure suivante schématise le tout.

À la seconde étude de marché, votre patron vous annonce que vous allez devoir créer des civils, des snipers, des chirurgiens etc. Toute une panoplie de personnages spécialisés dans leur domaine, comme le montre la figure suivante.

Le code source de ces classes

Personnage.java

public abstract class Personnage {

  //Méthode de déplacement de personnage
  public abstract void seDeplacer();

  //Méthode que les combattants utilisent
  public abstract void combattre();
}

Guerrier.java

public class Guerrier extends Personnage {

  public void combattre() {
    System.out.println("Fusil, pistolet, couteau ! Tout ce que tu veux !");
  }

  public void seDeplacer() {
    System.out.println("Je me déplace à pied.");
  }
}

Medecin.java

public class Medecin extends Personnage{
  public void combattre() {
    System.out.println("Vive le scalpel !");
  }

  public void seDeplacer() {
    System.out.println("Je me déplace à pied.");
  }

  public void soigner(){
    System.out.println("Je soigne les blessures.");
  }
}

Civil.java

public class Civil extends Personnage{
  public void combattre() {
    System.out.println("Je ne combats PAS !");
  }

  public void seDeplacer() {
    System.out.println("Je me déplace à pied.");
  }
}

Chirurgien.java

public class Chirurgien extends Personnage{
  public void combattre() {
    System.out.println("Je ne combats PAS !");
  }

  public void seDeplacer() {
    System.out.println("Je me déplace à pied.");
  }

  public void soigner(){
    System.out.println("Je fais des opérations.");
  }
}

Sniper.java

public class Sniper extends Personnage{
  public void combattre() {
    System.out.println("Je me sers de mon fusil à lunette !");
  }

  public void seDeplacer() {
    System.out.println("Je me déplace à pied.");
  }
}

À ce stade, vous devriez remarquer que :

• le code contenu dans la méthode seDeplacer() est dupliqué dans toutes les classes ; il est identique dans toutes celles citées ci-dessus ;

• le code de la méthode combattre() des classes Chirurgien et Civil est lui aussi dupliqué !

La duplication de code est une chose qui peut générer des problèmes dans le futur. Je m'explique.

Pour le moment, votre chef ne vous a demandé que de créer quelques classes supplémentaires. Qu'en serait-il si beaucoup de classes avaient ce même code dupliqué ? Il ne manquerait plus que votre chef vous demande de modifier à nouveau la façon de se déplacer de ces objets, et vous courrez le risque d'oublier d'en modifier un. Et voilà les incohérences qui pointeront le bout de leur nez !

Effectivement, votre idée se tient. Donc, cela nous donne ce qui suit :

Personnage.java

public abstract class Personnage {
  public void seDeplacer(){
    System.out.println("Je me déplace à pied.");
  }

  public void combattre(){
    System.out.println("Je ne combats PAS !");
  }
}

Guerrier.java

public class Guerrier extends Personnage {
  public void combattre() {
    System.out.println("Fusil, pistolet, couteau ! Tout ce que tuveux !");
  }
}

Medecin.java

public class Medecin extends Personnage{
  public void combattre() {
    System.out.println("Vive le scalpel !");
  }

  public void soigner(){
    System.out.println("Je soigne les blessures.");
  }
}

Civil.java

public class Civil extends Personnage{   }

Chirurgien.java

public class Chirurgien extends Personnage{
  public void soigner(){
    System.out.println("Je fais des opérations.");
  }
}

Sniper.java

public class Sniper extends Personnage{
  public void combattre() {
    System.out.println("Je me sers de mon fusil à lunette !");
  }
}

Voici une classe contenant un petit programme afin de tester nos classes :

public static void main(String[] args) {
  Personnage[] tPers = {new Guerrier(), new Chirurgien(), new Civil(), new Sniper(), new Medecin()};

  for(Personnage p : tPers){
    System.out.println("\nInstance de " + p.getClass().getName());
    System.out.println("***************************************");
    p.combattre();
    p.seDeplacer();
  }		
}

Le résultat correspond à la figure suivante.

Apparemment, ce code vous donne ce que vous voulez ! Mais une chose me chiffonne : vous ne pouvez pas utiliser les classes Medecin et Chirurgien de façon polymorphe, vu que la méthode soigner() leur est propre ! On pourrait définir un comportement par défaut (ne pas soigner) dans la superclasse Personnage et le tour serait joué.

public abstract class Personnage {
  public void seDeplacer(){
    System.out.println("Je me déplace à pied.");
  }
  public void combattre(){
    System.out.println("Je ne combats PAS !");
  }
  public void soigner(){
    System.out.println("Je ne soigne pas.");
  }
}

Au même moment, votre chef rentre dans votre bureau et vous dit : « Nous avons bien réfléchi, et il serait de bon ton que nos guerriers puissent administrer les premiers soins. » À ce moment précis, vous vous délectez de votre capacité d'anticipation ! Vous savez que, maintenant, il vous suffit de redéfinir la méthode soigner() dans la classe concernée, et tout le monde sera content !

Seulement voilà ! Votre chef n'avait pas fini son speech : « Au fait, il faudrait affecter un comportement à nos personnages en fonction de leurs armes, leurs habits, leurs trousses de soin… Enfin, vous voyez ! Les comportements figés pour des personnages de jeux, de nos jours, c'est un peu ringard ! »

Vous commencez à voir ce dont il retourne : vous devrez apporter des modifications à votre code, encore et encore. Bon : pour des programmeurs, cela est le train-train quotidien, j'en conviens. Cependant, si nous suivons les consignes de notre chef et que nous continuons sur notre lancée, les choses vont se compliquer.

Un problème supplémentaire

Attelons-nous à appliquer les modifications dans notre programme. Selon les directives de notre chef, nous devons gérer des comportements différents selon les accessoires de nos personnages : il faut utiliser des variables d'instance pour appliquer l'un ou l'autre comportement.

La figure suivante correspond au diagramme des classes de notre programme.

Vous avez remarqué que nos personnages posséderont des accessoires. Selon ceux-ci, nos personnages feront des choses différentes. Voici les recommandations de notre chef bien-aimé :

• le guerrier peut utiliser un couteau, un pistolet ou un fusil de sniper ;

• le sniper peut utiliser son fusil de sniper ainsi qu'un fusil à pompe ;

• le médecin a une trousse simple pour soigner, mais peut utiliser un pistolet ;

• le chirurgien a une grosse trousse médicale, mais ne peut pas utiliser d'arme ;

• le civil, quant à lui, peut utiliser un couteau seulement quand il en a un ;

• tous les personnages hormis le chirurgien peuvent avoir des baskets pour courir;

Il va nous falloir des mutateurs (inutile de mettre les méthodes de renvoi (getXXX), nous ne nous servirons que des mutateurs !) pour ces variables, insérons-les dans la superclasse ! Bon ! Les modifications sont faites, les caprices de notre cher et tendre chef sont satisfaits ? Voyons cela tout de suite.

Personnage.java

public abstract class Personnage {

  protected String armes = "", chaussure = "", sacDeSoin = "";

  public void seDeplacer(){
    System.out.println("Je me déplace à pied.");
  }

  public void combattre(){
    System.out.println("Je ne combats PAS !");
  }

  public void soigner(){
    System.out.println("Je ne soigne pas.");
  }
	
  protected void setArmes(String armes) {
    this.armes = armes;
  }

  protected void setChaussure(String chaussure) {
    this.chaussure = chaussure;
  }

  protected void setSacDeSoin(String sacDeSoin) {
    this.sacDeSoin = sacDeSoin;
  }
}

Guerrier.java

public class Guerrier extends Personnage {

  public void combattre() {
    if(this.armes.equals("pistolet"))
      System.out.println("Attaque au pistolet !");
    else if(this.armes.equals("fusil de sniper"))
      System.out.println("Attaque au fusil de sniper !");
    else
      System.out.println("Attaque au couteau !");
  }
}

Sniper.java

public class Sniper extends Personnage{
  public void combattre() {
    if(this.armes.equals("fusil à pompe"))
      System.out.println("Attaque au fusil à pompe !");
    else
      System.out.println("Je me sers de mon fusil à lunette !");
  }
}

Civil.java

public class Civil extends Personnage{
  public void combattre(){
    if(this.armes.equals("couteau"))
      System.out.println("Attaque au couteau !");
    else
      System.out.println("Je ne combats PAS !");
  }
}

Medecin.java

public class Medecin extends Personnage{
  public void combattre() {
    if(this.armes.equals("pistolet"))
      System.out.println("Attaque au pistolet !");
    else
      System.out.println("Vive le scalpel !");
  }
	
  public void soigner(){
    if(this.sacDeSoin.equals("petit sac"))
      System.out.println("Je peux recoudre des blessures.");
    else
      System.out.println("Je soigne les blessures.");
  }
}

Chirurgien.java

public class Chirurgien extends Personnage{
  public void soigner(){
    if(this.sacDeSoin.equals("gros sac"))
      System.out.println("Je fais des merveilles.");
    else
      System.out.println("Je fais des opérations.");
  }
}

Voici un programme de test :

public static void main(String[] args) {
  Personnage[] tPers = {new Guerrier(), new Chirurgien(), new Civil(), new Sniper(), new Medecin()};
  String[] tArmes = {"pistolet", "pistolet", "couteau", "fusil à pompe", "couteau"}; 

  for(int i = 0; i < tPers.length; i++){
    System.out.println("\nInstance de " + tPers[i].getClass().getName());
    System.out.println("*****************************************");
    tPers[i].combattre();
    tPers[i].setArmes(tArmes[i]);
    tPers[i].combattre();
    tPers[i].seDeplacer();
    tPers[i].soigner();
  }		
}

Le résultat de ce test se trouve à la figure suivante.

Vous constatez avec émerveillement que votre code fonctionne très bien. Les actions par défaut sont respectées, les affectations d'actions aussi. Tout est parfait !

Vraiment ? Vous êtes sûrs de cela ? Pourtant, je vois du code dupliqué dans certaines classes ! En plus, nous n'arrêtons pas de modifier nos classes. Dans le premier opus de « Z-Army », celles-ci fonctionnaient pourtant très bien ! Qu'est-ce qui ne va pas ?

Là-dessus, votre patron rentre dans votre bureau pour vous dire : « Les actions de vos personnages doivent être utilisables à la volée et, en fait, les personnages peuvent très bien apprendre au fil du jeu. » Les changements s'accumulent, votre code devient de moins en moins lisible et réutilisable, bref c'est l'enfer sur Terre.

Faisons un point de la situation :

• du code dupliqué s'insinue dans votre code ;

• à chaque modification du comportement de vos personnages, vous êtes obligés de retoucher le code source de la (ou des) classe(s) concernée(s) ;

• votre code perd en « réutilisabilité » et du coup, il n'est pas extensible du tout !

Une solution simple et robuste : le « pattern strategy »

Après toutes ces émotions, vous allez enfin disposer d'une solution à ce problème de modification du code source ! Si vous vous souvenez de ce que j'ai dit, un des fondements de la programmation orientée objet est l'encapsulation.

Le pattern strategy est basé sur ce principe simple. Bon, vous avez compris que le pattern strategy consiste à créer des objets avec des données, des méthodes (voire les deux) : c'est justement ce qui change dans votre programme !

Le principe de base de ce pattern est le suivant : « isolez ce qui varie dans votre programme et encapsulez-le ! »

Déjà, quels sont les éléments qui ne cessent de varier dans notre programme ?

• La méthode combattre().

• La méthode seDeplacer().

• La méthode soigner().

Là, je vous arrête un moment : vous venez de fournir la solution. Vous avez dit : « ce qui serait vraiment grandiose, ce serait d'avoir la possibilité de ne modifier que les comportements et non les objets qui ont ces comportements ».

Lorsque je vous ai présenté les diagrammes UML, je vous ai fourni une astuce pour bien différencier les liens entre les objets. Dans notre cas, nos classes héritant de Personnage héritent aussi de ses comportements et, par conséquent, on peut dire que nos classes filles sont des Personnage.

Les comportements de la classe mère semblent ne pas être au bon endroit dans la hiérarchie. Vous ne savez plus quoi en faire et vous vous demandez s'ils ont vraiment leur place dans cette classe ? Il vous suffit de sortir ces comportements de la classe mère, de créer une classe abstraite ou une interface symbolisant ce comportement et d'ordonner à votre classe Personnage d'avoir ces comportements. Le nouveau diagramme des classes se trouve sur la figure suivante.

Vous apercevez une nouvelle entité sur ce diagramme, l'interface, facilement reconnaissable, ainsi qu'une nouvelle flèche symbolisant l'implémentation d'interface entre une classe concrète et une interface. N'oubliez pas que votre code doit être souple et robuste et que — même si ce chapitre vous montre les limites de l'héritage — le polymorphisme est inhérent à l'héritage (ainsi qu'aux implémentations d'interfaces).

Il faut vous rendre compte qu'utiliser une interface de cette manière revient à créer un supertype de variable ; du coup, nous pourrons utiliser les classes héritant de ces interfaces de façon polymorphe sans nous soucier de savoir la classe dont sont issus nos objets ! Dans notre cas, notre classe Personnage comprendra des objets de type EspritCombatif, Soin et Deplacement !

Avant de nous lancer dans le codage de nos nouvelles classes, vous devez observer que leur nombre a considérablement augmenté depuis le début. Afin de pouvoir gagner en clarté, nous allons gérer nos différentes classes avec différents packages.

Comme nous l'avons remarqué tout au long de ce chapitre, les comportements de nos personnages sont trop épars pour être définis dans notre superclasse Personnage. Vous l'avez dit vous-mêmes : il faudrait que l'on ne puisse modifier que les comportements et non les classes héritant de notre superclasse !
Les interfaces nous servent à créer un supertype d'objet ; grâce à elles, nous utiliserons des objets de type :

• EspritCombatif qui présentent une méthode combat() ;

• Soin qui présentent une méthode soigne() ;

• Deplacement qui présentent une méthode deplace().

Dans notre classe Personnage, nous avons ajouté une instance de chaque type de comportement, vous avez dû les remarquer : il y a ces attributs dans notre schéma ! Nous allons développer un comportement par défaut pour chacun d'entre eux et affecter cet objet dans notre superclasse. Les classes filles, elles, comprendront des instances différentes correspondant à leurs besoins.

Nous les gardons, mais plutôt que de redéfinir ces dernières, la superclasse va invoquer la méthode de comportement de chaque objet. Ainsi, nous n'avons plus à redéfinir ou à modifier nos classes ! La seule chose qu'il nous reste à faire, c'est d'affecter une instance de comportement à nos objets. Vous comprendrez mieux avec un exemple. Voici quelques implémentations de comportements.

Implémentations de l'interface EspritCombatif

package com.sdz.comportement;

public class Pacifiste implements EspritCombatif {
  public void combat() {
    System.out.println("Je ne combats pas !");
  }
}

package com.sdz.comportement;

public class CombatPistolet implements EspritCombatif{
  public void combat() {
    System.out.println("Je combats au pitolet !");
  }
}

package com.sdz.comportement;

public class CombatCouteau implements EspritCombatif {	
  public void combat() {
    System.out.println("Je me bats au couteau !");
  }
}

Implémentations de l'interface Deplacement

package com.sdz.comportement;

public class Marcher implements Deplacement {
  public void deplacer() {
    System.out.println("Je me déplace en marchant.");
  }
}

package com.sdz.comportement;

public class Courir implements Deplacement {
  public void deplacer() {
    System.out.println("Je me déplace en courant.");
  }
}

Implémentations de l'interface Soin

package com.sdz.comportement;

public class PremierSoin implements Soin {
  public void soigne() {
    System.out.println("Je donne les premiers soins.");
  }
}

package com.sdz.comportement;

public class Operation implements Soin {
  public void soigne() {
    System.out.println("Je pratique des opérations !");
  }
}

package com.sdz.comportement;

public class AucunSoin implements Soin {
  public void soigne() {
    System.out.println("Je ne donne AUCUN soin !");
  }
}

La figure suivante représente ce que vous devriez avoir dans votre nouveau package.

Maintenant que nous avons défini des objets de comportements, nous allons pouvoir remanier notre classe Personnage. Ajoutons les variables d'instance, les mutateurs et les constructeurs permettant d'initialiser nos objets :

import com.sdz.comportement.*;

public abstract class Personnage {

  //Nos instances de comportement
  protected EspritCombatif espritCombatif = new Pacifiste();
  protected Soin soin = new AucunSoin();
  protected Deplacement deplacement = new Marcher();	
	
  //Constructeur par défaut
  public Personnage(){}
	
  //Constructeur avec paramètres
  public Personnage(EspritCombatif espritCombatif, Soin soin, Deplacement deplacement) {
    this.espritCombatif = espritCombatif;
    this.soin = soin;
    this.deplacement = deplacement;
  }
	
  //Méthode de déplacement de personnage
  public void seDeplacer(){
    //On utilise les objets de déplacement de façon polymorphe
    deplacement.deplacer();
  }

  // Méthode que les combattants utilisent
  public void combattre(){
    //On utilise les objets de déplacement de façon polymorphe
    espritCombatif.combat();
  }
	
  //Méthode de soin
  public void soigner(){
    //On utilise les objets de déplacement de façon polymorphe
    soin.soigne();
  }

  //Redéfinit le comportement au combat
  public void setEspritCombatif(EspritCombatif espritCombatif) {
    this.espritCombatif = espritCombatif;
  }

  //Redéfinit le comportement de Soin
  public void setSoin(Soin soin) {
    this.soin = soin;
  }

  //Redéfinit le comportement de déplacement
  public void setDeplacement(Deplacement deplacement) {
    this.deplacement = deplacement;
  }	
}

Que de changements depuis le début ! Maintenant, nous n'utilisons plus de méthodes définies dans notre hiérarchie de classes, mais des implémentations concrètes d'interfaces ! Les méthodes que nos objets appellent utilisent chacune un objet de comportement. Nous pouvons donc définir des guerriers, des civils, des médecins… tous personnalisables, puisqu'il suffit de modifier l'instance de leur comportement pour que ceux-ci changent instantanément. La preuve par l'exemple.

Je ne vais pas vous donner les codes de toutes les classes. En voici seulement quelques-unes.

Guerrier.java

import com.sdz.comportement.*;

public class Guerrier extends Personnage {	
  public Guerrier(){
    this.espritCombatif = new CombatPistolet();
  }
  public Guerrier(EspritCombatif esprit, Soin soin, Deplacement dep) {
    super(esprit, soin, dep);
  }
}

Civil.java

import com.sdz.comportement.*;

public class Civil extends Personnage{
  public Civil() {}

  public Civil(EspritCombatif esprit, Soin soin, Deplacement dep) {
    super(esprit, soin, dep);
  }	
}

Medecin.java

import com.sdz.comportement.*;

public class Medecin extends Personnage{
  public Medecin() {
    this.soin = new PremierSoin();
  }
  public Medecin(EspritCombatif esprit, Soin soin, Deplacement dep) {
    super(esprit, soin, dep);
  }	
}

Maintenant, voici un exemple d'utilisation :

class Test{
  public static void main(String[] args) {
    Personnage[] tPers = {new Guerrier(), new Civil(), new Medecin()};
		
    for(int i = 0; i < tPers.length; i++){
      System.out.println("\nInstance de " + tPers[i].getClass().getName());
      System.out.println("*****************************************");
      tPers[i].combattre();
      tPers[i].seDeplacer();
      tPers[i].soigner();
    }		
  }
}

Le résultat de ce code nous donne la figure suivante.

Vous pouvez voir que nos personnages ont tous un comportement par défaut qui leur convient bien ! Nous avons spécifié, dans le cas où cela s'avère nécessaire, le comportement par défaut d'un personnage dans son constructeur par défaut :

• le guerrier se bat avec un pistolet ;

• le médecin soigne.

Voyons maintenant comment indiquer à nos personnages de faire autre chose. Eh oui, la façon dont nous avons arrangé tout cela va nous permettre de changer dynamiquement le comportement de chaque Personnage. Que diriez-vous de faire faire une petite opération chirurgicale à notre objet Guerrier ?

Pour ce faire, vous pouvez redéfinir son comportement de soin avec son mutateur présent dans la superclasse en lui passant une implémentation correspondante !

import com.sdz.comportement.*;

class Test{
  public static void main(String[] args) {
    Personnage pers = new Guerrier();
    pers.soigner();		
    pers.setSoin(new Operation());
    pers.soigner();		
  }
}

En testant ce code, vous constaterez que le comportement de soin de notre objet a changé dynamiquement sans que nous ayons besoin de changer la moindre ligne de son code source ! Le plus beau dans le fait de travailler comme cela, c'est qu'il est tout à fait possible d'instancier des objets Guerrier avec des comportements différents.

• Une classe est définie comme abstraite avec le mot clé abstract.

• Les classes abstraites sont à utiliser lorsqu'une classe mère ne doit pas être instanciée.

• Une classe abstraite ne peut donc pas être instanciée.

• Une classe abstraite n'est pas obligée de contenir de méthode abstraite.

• Si une classe contient une méthode abstraite, cette classe doit alors être déclarée abstraite.

• Une méthode abstraite n'a pas de corps.

• Une interface est une classe 100 % abstraite.

• Aucune méthode d'une interface n'a de corps.

• Une interface sert à définir un supertype et à utiliser le polymorphisme.

• Une interface s'implémente dans une classe en utilisant le mot clé implements.

• Vous pouvez implémenter autant d'interfaces que vous voulez dans vos classes.

• Vous devez redéfinir toutes les méthodes de l'interface (ou des interfaces) dans votre classe.

• Le pattern strategy vous permet de rendre une hiérarchie de classes plus souple.

• Préférez encapsuler des comportements plutôt que de les mettre d'office dans l'objet concerné.

Le bloc try{...} catch{...}

Pour vous faire comprendre le principe des exceptions, je dois tout d'abord vous informer que Java contient une classe nommée Exception dans laquelle sont répertoriés différents cas d'erreur. La division par zéro dont je vous parlais plus haut en fait partie ! Si vous créez un nouveau projet avec seulement la classe main et y mettez le code suivant :

int j = 20, i = 0;
System.out.println(j/i);
System.out.println("coucou toi !");

… vous verrez apparaître un joli message d'erreur Java (en rouge) comme celui de la figure suivante.

Mais surtout, vous devez avoir constaté que lorsque l'exception a été levée, le programme s'est arrêté ! D'après le message affiché dans la console, le nom de l'exception qui a été déclenchée est ArithmeticException. Nous savons donc maintenant qu'une division par zéro est une ArithmeticException. Nous allons pouvoir la capturer, avec un bloc try{…}catch{…}, puis réaliser un traitement en conséquence. Ce que je vous propose maintenant, c'est d'afficher un message personnalisé lors d'une division par 0. Pour ce faire, tapez le code suivant dans votre main :

public static void main(String[] args) {
                
  int j = 20, i = 0;
  try {
    System.out.println(j/i);
  } catch (ArithmeticException e) {
    System.out.println("Division par zéro !");
  }
  System.out.println("coucou toi !");
}

En exécutant ce code, vous obtiendrez le résultat visible à la figure suivante.

Voyons un peu ce qui se passe :

• Nous initialisons deux variables de type int, l'une à 0 et l'autre à un nombre quelconque.

• Nous isolons le code susceptible de lever une exception : System.out.println(j/i);.

• Une exception de type ArithmeticException est levée lorsque le programme atteint cette ligne.

• Notre bloc catch contient justement un objet de type ArithmeticException en paramètre. Nous l'avons appelé e.

• L'exception étant capturée, l'instruction du bloc catch s'exécute !

• Notre message d'erreur personnalisé s'affiche alors à l'écran.

Vous vous demandez sûrement à quoi sert le paramètre de la clause catch. Il permet de connaître le type d'exception qui doit être capturé. Et l'objet — ici, e — peut servir à préciser notre message grâce à l'appel de la méthode getMessage(). Faites à nouveau ce test, en remplaçant l'instruction du catch par celle-ci :

System.out.println("Division par zéro !" + e.getMessage());

Vous verrez que la fonction getMessage() de notre objet ArithmeticException nous précise la nature de l'erreur.

Je vous disais aussi que le principe de capture d'exception permettait de ne pas interrompre l'exécution du programme. En effet, lorsque nous capturons une exception, le code présent dans le bloc catch(){…} est exécuté, mais le programme suit son cours !

Avant de voir comment créer nos propres exceptions, sachez que le bloc permettant de capturer ces dernières offre une fonctionnalité importante. En fait, vous avez sans doute compris que lorsqu'une ligne de code lève une exception, l'instruction dans le bloc try est interrompue et le programme se rend dans le bloc catch correspondant à l'exception levée.

Prenons un cas de figure très simple : imaginons que vous souhaitez effectuer une action, qu'une exception soit levée ou non (nous verrons lorsque nous travaillerons avec les fichiers qu'il faut systématiquement fermer ceux-ci). Java vous permet d'utiliser une clause via le mot clé finally. Voyons ce que donne ce code :

public static void main(String[] args){
  try {
    System.out.println(" =>" + (1/0));
  } catch (ClassCastException e) {
    e.printStackTrace();
  }
  finally{
    System.out.println("action faite systématiquement");
  }
}

Lorsque vous l'exécutez, vous pouvez constater que, même si nous tentons d'intercepter une ArithmeticException (celle-ci se déclenche lors d'un problème de cast), grâce à la clause finally, un morceau de code est exécuté quoi qu'il arrive. Cela est surtout utilisé lorsque vous devez vous assurer d'avoir fermé un fichier, clos votre connexion à une base de données ou un socket (une connexion réseau). Maintenant que nous avons vu cela, nous pouvons aller un peu plus loin dans la gestion de nos exceptions.

Les exceptions personnalisées

Nous allons perfectionner un peu la gestion de nos objets Ville et Capitale. Je vous propose de mettre en œuvre une exception de notre cru afin d'interdire l'instanciation d'un objet Ville ou Capitale présentant un nombre négatif d'habitants.

La procédure pour faire ce tour de force est un peu particulière. En effet, nous devons :

1. créer une classe héritant de la classe Exception : NombreHabitantException (par convention, les exceptions ont un nom se terminant par « Exception ») ;

2. renvoyer l'exception levée à notre classe NombreHabitantException ;

3. ensuite, gérer celle-ci dans notre classe NombreHabitantException.

Pour faire tout cela, je vais encore vous apprendre deux mots clés :

• throws : ce mot clé permet de signaler à la JVM qu'un morceau de code, une méthode, une classe… est potentiellement dangereux et qu'il faut utiliser un bloc try{…}catch{…}. Il est suivi du nom de la classe qui va gérer l'exception.

• throw : celui-ci permet tout simplement de lever une exception manuellement en instanciant un objet de type Exception (ou un objet hérité). Dans l'exemple de notre ArithmeticException, il y a quelque part dans les méandres de Java un throw new ArithmeticException().

Pour mettre en pratique ce système, commençons par créer une classe qui va gérer nos exceptions. Celle-ci, je vous le rappelle, doit hériter d'Exception :

class NombreHabitantException extends Exception{ 
  public NombreHabitantException(){
    System.out.println("Vous essayez d'instancier une classe Ville avec un nombre d'habitants négatif !");
  }  
}

Reprenez votre projet avec vos classes Ville et Capitale et créez ensuite une classe NombreHabitantException, comme je viens de le faire. Maintenant, c'est dans le constructeur de nos objets que nous allons ajouter une condition qui, si elle est remplie, lèvera une exception de type NombreHabitantException. En gros, nous devons dire à notre constructeur de Ville : « si l'utilisateur crée une instance de Ville avec un nombre d'habitants négatif, créer un objet de type NombreHabitantException ».

Voilà à quoi ressemble le constructeur de notre objet Ville à présent :

public Ville(String pNom, int pNbre, String pPays) 
  throws  NombreHabitantException
  {  
    if(pNbre < 0)
      throw new NombreHabitantException();
    else
    {
      nbreInstance++;  
      nbreInstanceBis++;

      nomVille = pNom;
      nomPays = pPays;
      nbreHabitant = pNbre;
      this.setCategorie();
    }
  }

throws NombreHabitantException nous indique que si une erreur est capturée, celle-ci sera traitée en tant qu'objet de la classe NombreHabitantException, ce qui nous renseigne sur le type de l'erreur en question. Elle indique aussi à la JVM que le constructeur de notre objet Ville est potentiellement dangereux et qu'il faudra gérer les exceptions possibles.

Si la condition if(nbre < 0) est remplie, throw new NombreHabitantException(); instancie la classe NombreHabitantException. Par conséquent, si un nombre d'habitants est négatif, l'exception est levée.

Maintenant que vous avez apporté cette petite modification, retournez dans votre classe main, effacez son contenu, puis créez un objet Ville de votre choix. Vous devez tomber sur une erreur persistante, comme à la figure suivante ; c'est tout à fait normal et dû à l'instruction throws.

Cela signifie qu'à partir de maintenant, vu les changements dans le constructeur, il vous faudra gérer les exceptions qui pourraient survenir dans cette instruction avec un bloc try{…}catch{}.

Ainsi, pour que l'erreur disparaisse, il nous faut entourer notre instanciation avec un bloc try{…}catch{…}, comme à la figure suivante.

Vous pouvez constater que l'erreur a disparu, que notre code peut être compilé et qu'il s'exécute correctement.

Attention, il faut que vous soyez préparés à une chose : le code que j'ai utilisé fonctionne très bien, mais il y a un autre risque, l'instance de mon objet Ville a été déclarée dans le bloc try{…}catch{…} et cela peut causer beaucoup de problèmes.

Ce code :

public static void main(String[] args)
{
  try {                   
    Ville v = new Ville("Rennes", 12000, "France");         
  } catch (NombreHabitantException e) {   }   

  System.out.println(v.toString());
}

… ne fonctionnera pas, tout simplement parce que la déclaration de l'objet Ville est faite dans un sous-bloc d'instructions, celui du bloc try{…}. Et rappelez-vous : une variable déclarée dans un bloc d'instructions n'existe que dans celui-ci ! Ici, la variable v n'existe pas en dehors de l'instruction try{…}. Pour pallier ce problème, il nous suffit de déclarer notre objet en dehors du bloc try{…} et de l'instancier à l'intérieur :

public static void main(String[] args)
{
  Ville v = null;
  try {                   
    v = new Ville("Rennes", 12000, "France");         
  } catch (NombreHabitantException e) {   }   

  System.out.println(v.toString());
}

Mais que se passera-t-il si nous déclarons une Ville avec un nombre d'habitants négatif pour tester notre exception ? En remplaçant « 12000 » par « -12000 » dans l'instanciation de notre objet ? C'est simple : en plus d'une exception levée pour le nombre d'habitants négatif, vous obtiendrez aussi une NullPointerException.

Voyons ce qu'il s'est passé :

• Nous avons bien déclaré notre objet en dehors du bloc d'instructions.

• Au moment d'instancier celui-ci, une exception est levée et l'instanciation échoue !

• La clause catch{} est exécutée : un objet NombreHabitantException est instancié.

• Lorsque nous arrivons sur l'instruction « System.out.println(v.toString()); », notre objet est null !

• Une NullPointerException est donc levée !

Ce qui signifie que si l'instanciation échoue dans notre bloc try{}, le programme plante ! Pour résoudre ce problème, on peut utiliser une simple clause finally avec, à l'intérieur, l'instanciation d'un objet Ville par défaut si celui-ci est null :

public static void main(String[] args)
{
  Ville v = null;
  try {                   
    v = new Ville("Rennes", 12000, "France");         
  } catch (NombreHabitantException e) {   }   
  finally{
    if(v == null)
      v = new Ville();
  }
  System.out.println(v.toString());
}

Pas besoin de capturer une exception sur l'instanciation de notre objet ici : le code n'est considéré comme dangereux que sur le constructeur avec paramètres.

Maintenant que nous avons vu la création d'une exception, il serait de bon ton de pouvoir récolter plus de renseignements la concernant. Par exemple, il serait peut-être intéressant de réafficher le nombre d'habitants que l'objet a reçu. Pour ce faire, nous n'avons qu'à créer un deuxième constructeur dans notre classe NombreHabitantException qui prend un nombre d'habitants en paramètre :

public NombreHabitantException(int nbre)
{
  System.out.println("Instanciation avec un nombre d'habitants négatif.");
  System.out.println("\t => " + nbre);
}

Il suffit maintenant de modifier le constructeur de la classe Ville en conséquence :

public Ville(String pNom, int pNbre, String pPays) 
  throws  NombreHabitantException
  {  
    if(pNbre < 0)
      throw new NombreHabitantException(pNbre); 
    else
    {
      //Le code est identique à précédemment
    }
  }

Et si vous exécutez le même code que précédemment, vous pourrez voir le nouveau message de notre exception s'afficher.

Ce n'est pas mal, avouez-le ! Sachez également que l'objet passé en paramètre de la clause catch a des méthodes héritées de la classe Exception : vous pouvez les utiliser si vous le voulez et surtout, si vous en avez l'utilité. Nous utiliserons certaines de ces méthodes dans les prochains chapitres. Je vais vous faire peur : ici, nous avons capturé une exception, mais nous pouvons en capturer plusieurs !

La gestion de plusieurs exceptions

Bien entendu, ceci est valable pour toutes sortes d'exceptions, qu'elles soient personnalisées ou inhérentes à Java ! Supposons que nous voulons lever une exception si le nom de la ville fait moins de 3 caractères. Nous allons répéter les premières étapes vues précédemment, c'est-à-dire créer une classe NomVilleException:

public class NomVilleException extends Exception { 
  public NomVilleException(String message){
    super(message);
  }        
}

Vous avez remarqué que nous avons utilisé super ? Avec cette redéfinition, nous pourrons afficher notre message d'erreur en utilisant la méthode getMessage().

Dans le code suivant, nous ajoutons une condition dans le constructeur Ville :

public Ville(String pNom, int pNbre, String pPays) throws  NombreHabitantException, NomVilleException
{  
  if(pNbre < 0)
    throw new NombreHabitantException(pNbre);
          
  if(pNom.length() < 3)
    throw new NomVilleException("le nom de la ville est inférieur à 3 caractères ! nom = " + pNom);
  else
  {
    nbreInstance++;  
    nbreInstanceBis++;

    nomVille = pNom;
    nomPays = pPays;
    nbreHabitant = pNbre;
    this.setCategorie();
  }          
}

Vous remarquez que les différentes erreurs dans l'instruction throws sont séparées par une virgule. Nous sommes maintenant parés pour la capture de deux exceptions personnalisées. Regardez comment on gère deux exceptions sur une instruction :

Ville v = null;

try {
  v = new Ville("Re", 12000, "France");
}

//Gestion de l'exception sur le nombre d'habitants
catch (NombreHabitantException e) {
  e.printStackTrace();
}

//Gestion de l'exception sur le nom de la ville
catch(NomVilleException e2){
  System.out.println(e2.getMessage());
}
finally{
  if(v == null)
    v = new Ville();
}
      
System.out.println(v.toString());

Constatez qu'un deuxième bloc catch{} s'est glissé… Eh bien, c'est comme cela que nous gérerons plusieurs exceptions !

Si vous mettez un nom de ville de moins de 3 caractères et un nombre d'habitants négatif, c'est l'exception du nombre d'habitants qui sera levée en premier, et pour cause : il s'agit de la première condition dans notre constructeur. Lorsque plusieurs exceptions sont gérées par une portion de code, pensez bien à mettre les blocs catch dans un ordre pertinent.

Depuis Java 7 : le multi-catch

Encore une fois, Java 7 apporte une nouveauté : il est possible de catcher plusieurs exceptions dans l'instruction catch. Ceci se fait grâce à l'opérateur « | » qui permet d'informer la JVM que le bloc de code est susceptible d'engendrer plusieurs types d'exception. C'est vraiment simple à utiliser et cela vous permet d'avoir un code plus compact. Voici à quoi ressemble l'exemple vu plus haut avec un catch multiple :

public static void main(String[] args){
  Ville v = null;
  try {                   
    v = new Ville("Re", 12000, "France");           
  }
  //Gestion de plusieurs exceptions différentes
  catch (NombreHabitantException | NomVilleException e2){ 
    System.out.println(e2.getMessage());		     
  }
  finally{
    if(v == null)
      v = new Ville();
  }        
  System.out.println(v.toString());
}

Ce morceau de code nous remonte donc une erreur impliquant le nom de la ville (celui-ci fait moins de 3 caractères). Je vous invite à modifier le nombre d'habitants en le passant en négatif et vous verrez que l'exception concernant le nombre d'habitants est bien capturée. :magicien:

• Lorsqu'un événement que la JVM ne sait pas gérer apparaît, une exception est levée (exemple : division par zéro). Une exception correspond donc à une erreur.

• La superclasse qui gère les exceptions s'appelle Exception.

• Vous pouvez créer une classe d'exception personnalisée : faites-lui hériter de la classe Exception.

• L'instruction qui permet de capturer des exceptions est le bloc try{…}catch{}.

• Si une exception est levée dans le bloc try, les instructions figurant dans le bloc catch seront exécutées pour autant que celui-ci capture la bonne exception levée.

• Vous pouvez ajouter autant de blocs catch que vous le voulez à la suite d'un bloc try, mais respectez l'ordre : du plus pertinent au moins pertinent.

• Dans une classe objet, vous pouvez prévenir la JVM qu'une méthode est dite « à risque » grâce au mot clé throws.

• Vous pouvez définir plusieurs risques d'exceptions sur une même méthode. Il suffit de séparer les déclarations par une virgule.

• Dans cette méthode, vous pouvez définir les conditions d'instanciation d'une exception et lancer cette dernière grâce au mot clé throw suivi de l'instanciation.

• Une instanciation lancée par le biais de l'instruction throw doit être déclarée avec throws au préalable !

Avant les énumérations

Vous aurez sans doute besoin, un jour ou l'autre, de données permettant de savoir ce que vous devez faire. Beaucoup de variables statiques dans Java servent à cela, vous le verrez bientôt dans une prochaine partie.

Voici le cas qui nous intéresse :

public class AvantEnumeration {

  public static final int PARAM1 = 1;
  public static final int PARAM2 = 2;
   
  public void fait(int param){
    if(param == PARAM1)
      System.out.println("Fait à la façon N°1");
    if(param == PARAM2)
      System.out.println("Fait à la façon N°2");
  }
   
  public static void main(String args[]){
    AvantEnumeration ae = new AvantEnumeration();
    ae.fait(AvantEnumeration.PARAM1);
    ae.fait(AvantEnumeration.PARAM2);
    ae.fait(4);
  }
}

Voyons le rendu de ce test en figure suivante.

Je viens de vous montrer non seulement le principe dont je vous parlais, mais aussi sa faiblesse. Vous voyez que rien ne vous empêche de passer un paramètre inattendu à une méthode : c'est ce qui s'est passé à la dernière ligne de notre test. Ici, rien de méchant, mais vous conviendrez tout de même que le comportement de notre méthode est faussé !

Bien sûr, vous pourriez créer un objet qui vous sert de paramètre de la méthode. Eh bien c'est à cela que servent les enum : fabriquer ce genre d'objet de façon plus simple et plus rapide.

Une solution : les enum

Une énumération se déclare comme une classe, mais en remplaçant le mot-clé class par enum. Autre différence : les énumérations héritent de la classe java.lang.Enum.

Voici à quoi ressemble une énumération :

public enum Langage {
  JAVA,
  C,
  CPlus,
  PHP;	
}

Rien de difficile ! Avec cela, vous obtenez une structure de données qui encapsule quatre « objets ». En fait, c'est comme si vous aviez un objet JAVA, un objet C, un objet CPlus et un objet PHP partageant tous les mêmes méthodes issues de la classe java.lang.Object comme n'importe quel autre objet : equals(), toString(), etc.

Vous constatez aussi qu'il n'y a pas de déclaration de portée, ni de type : les énumérations s'utilisent comme des variables statiques déclarées public : on écrira par exemple Langage.JAVA. De plus, vous pouvez recourir à la méthode values() retournant la liste des déclarations de l'énumération dont vous trouverez un exemple à la figure suivante et sur son code :

public class Main {
  public static void main(String args[]){
    for(Langage lang : Langage.values()){
      if(Langage.JAVA.equals(lang))
        System.out.println("J'aime le : " + lang);
      else
        System.out.println(lang);
    }
  }
}

Vous disposez ainsi d'un petit aperçu de l'utilisation des énumérations. Vous aurez pu constater que la méthode toString() retourne le nom de l'objet défini dans l'énumération.

À présent, étoffons tout cela en redéfinissant justement cette méthode. Pour ce faire, nous allons ajouter un paramètre dans notre énumération, un constructeur et ladite méthode redéfinie. Voici notre nouvelle énumération (résultat en figure suivante) :

public enum Langage {
  //Objets directement construits
  JAVA ("Langage JAVA"),
  C ("Langage C"),
  CPlus ("Langage C++"),
  PHP ("Langage PHP");
   
  private String name = "";
   
  //Constructeur
  Langage(String name){
    this.name = name;
  }
   
  public String toString(){
    return name;
  }
}

Même remarque pour le constructeur : pas de déclaration de portée, pour une raison simple ; il est toujours considéré comme private afin de préserver les valeurs définies dans l'enum. Vous noterez par ailleurs que les données formant notre énumération sont directement construites dans la classe.

Voici le code du début de chapitre, revu pour préférer les énumérations aux variables statiques :

public class AvantEnumeration {

  public void fait(Langage param){
    if(param.equals(Langage.JAVA))
      System.out.println("Fait à la façon N°1");
    if(param.equals(Langage.PHP))
      System.out.println("Fait à la façon N°2");
  }
   
  public static void main(String args[]){
    AvantEnumeration ae = new AvantEnumeration();
    ae.fait(Langage.JAVA);
    ae.fait(Langage.PHP);
    ae.fait(4);
  }
}

La figure suivante nous montre ce que cela donne.

Une belle exception ! Normal, puisque la méthode attend un certain type d'argument, et que vous lui en passez un autre : supprimez la dernière ligne, le code fonctionnera très bien.
Maintenant, nous avons un mécanisme protégé : seuls des arguments valides peuvent être passés en paramètres de la méthode.

Voici un exemple plus complet :

public enum Langage {
  //Objets directement construits
  JAVA("Langage JAVA", "Eclipse"),
  C ("Lanage C", "Code Block"),
  CPlus ("Langage C++", "Visual studio"),
  PHP ("Langage PHP", "PS Pad");

  private String name = "";
  private String editor = "";
   
  //Constructeur
  Langage(String name, String editor){
    this.name = name;
    this.editor = editor;
  }
   
  public void getEditor(){
    System.out.println("Editeur : " + editor);
  }
   
  public String toString(){
    return name;
  }
   
  public static void main(String args[]){
    Langage l1 = Langage.JAVA;
    Langage l2 = Langage.PHP;
      
    l1.getEditor();
    l2.getEditor();
  }
}

Voyons le résultat de cet exemple à la figure suivante.

Vous voyez ce que je vous disais : les énumérations ne sont pas très difficiles à utiliser et nos programmes y gagnent en rigueur et en clarté.

• Une énumération est une classe contenant une liste de sous-objets.

• Une énumération se construit grâce au mot clé enum.

• Les enum héritent de la classe java.lang.Enum.

• Chaque élément d'une énumération est un objet à part entière.

• Vous pouvez compléter les comportements des objets d'une énumération en ajoutant des méthodes.

Les différents types de collections

Avant de vous présenter certains objets, je me propose de vous présenter la hiérarchie d'interfaces composant ce qu'on appelle les collections. Oui, vous avez bien lu, il s'agit bien d'interfaces : celles-ci encapsulent la majeure partie des méthodes utilisables avec toutes les implémentations concrètes. Voici un petit diagramme de classes sur la figure suivante schématisant cette hiérarchie.

Vous pouvez voir qu'il existe plusieurs types de collections, que les interfaces List et Set implémentent directement l'interface Collection et que l'interface Map gravite autour de cette hiérarchie, tout en faisant partie des collections Java.

En lisant la suite de ce chapitre, vous constaterez que ces interfaces ont des particularités correspondant à des besoins spécifiques. Les objets de type List servent à stocker des objets sans condition particulière sur la façon de les stocker. Ils acceptent toutes les valeurs, même les valeurs null. Les types Set sont un peu plus restrictifs, car ils n'autorisent pas deux fois la même valeur (le même objet), ce qui est pratique pour une liste d'éléments uniques, par exemple. Les Map sont particulières, car elles fonctionnent avec un système clé - valeur pour ranger et retrouver les objets qu'elles contiennent.

Maintenant que je vous ai brièvement expliqué les différences entre ces types, voyons comment utiliser ces objets.

Les objets List

Les objets appartenant à la catégorie List sont, pour simplifier, des tableaux extensibles à volonté. On y trouve les objets Vector, LinkedList et ArrayList. Vous pouvez y insérer autant d'éléments que vous le souhaitez sans craindre de dépasser la taille de votre tableau. Ils fonctionnent tous de la même manière : vous pouvez récupérer les éléments de la liste via leurs indices. De plus, les List contiennent des objets. Je vous propose de voir deux objets de ce type qui, je pense, vous seront très utiles.

L'objet LinkedList

Une liste chaînée (LinkedList en anglais) est une liste dont chaque élément est lié aux éléments adjacents par une référence à ces derniers. Chaque élément contient une référence à l'élément précédent et à l'élément suivant, exceptés le premier, dont l'élément précédent vaut null, et le dernier, dont l'élément suivant vaut également null.

La figure suivante représente un un schéma qui vous permettra de mieux vous représenter le fonctionnement de cet objet :

Voici un code pour appuyer mes dires :

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
 
public class Test {
 
  public static void main(String[] args) {
    List l = new LinkedList();
    l.add(12);
    l.add("toto ! !");
    l.add(12.20f);

    for(int i = 0; i < l.size(); i++)
      System.out.println("Élément à l'index " + i + " = " + l.get(i));
  }
}

Si vous essayez ce code, vous constaterez que tous les éléments s'affichent !

Il y a autre chose que vous devez savoir sur ce genre d'objet : ceux-ci implémentent l'interface Iterator. Ainsi, nous pouvons utiliser cette interface pour lister notre LinkedList.

Un itérateur est un objet qui a pour rôle de parcourir une collection. C'est d'ailleurs son unique raison d'être. Pour être tout à fait précis, l'utilisation des itérateurs dans Java fonctionne de la même manière que le pattern du même nom. Tout comme nous avons pu le voir avec la pattern strategy, les design patterns sont en fait des modèles de conception d'objets permettant une meilleure stabilité et une réutilisabilité accrue. Les itérateurs en font partie.

Dans le code suivant, j'ai ajouté le parcours avec un itérateur :

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
 
public class Test {
 
  public static void main(String[] args) {
    List l = new LinkedList();
    l.add(12);
    l.add("toto ! !");
    l.add(12.20f);

    for(int i = 0; i < l.size(); i++)
      System.out.println("Élément à l'index " + i + " = " + l.get(i));

      System.out.println("\n \tParcours avec un itérateur ");
      System.out.println("-----------------------------------");
      ListIterator li = l.listIterator();

      while(li.hasNext())
        System.out.println(li.next());
  }
}

Les deux manières de procéder sont analogues !

Attention, je dois vous dire quelque chose sur les listes chaînées : vu que tous les éléments contiennent une référence à l'élément suivant, de telles listes risquent de devenir particulièrement lourdes en grandissant ! Cependant, elles sont adaptées lorsqu'il faut beaucoup manipuler une collection en supprimant ou en ajoutant des objets en milieu de liste. Elles sont donc à utiliser avec précaution.

L'objet ArrayList

Voici un objet bien pratique. ArrayList est un de ces objets qui n'ont pas de taille limite et qui, en plus, acceptent n'importe quel type de données, y compris null ! Nous pouvons mettre tout ce que nous voulons dans un ArrayList, voici un morceau de code qui le prouve :

import java.util.ArrayList;
 
public class Test {
 
  public static void main(String[] args) {
         
    ArrayList al = new ArrayList();
    al.add(12);
    al.add("Une chaîne de caractères !");
    al.add(12.20f);
    al.add('d');
                
    for(int i = 0; i < al.size(); i++)
    {
      System.out.println("donnée à l'indice " + i + " = " + al.get(i));
    }               
  }
}

Si vous exécutez ce code, vous obtiendrez la figure suivante.

Je pense que vous voyez déjà les avantages des ArrayList.
Sachez aussi qu'il existe tout un panel de méthodes fournies avec cet objet :

• add() permet d'ajouter un élément ;

• get(int index) retourne l'élément à l'indice demandé ;

• remove(int index) efface l'entrée à l'indice demandé ;

• isEmpty() renvoie « vrai » si l'objet est vide ;

• removeAll() efface tout le contenu de l'objet ;

• contains(Object element) retourne « vrai » si l'élément passé en paramètre est dans l'ArrayList.

Contrairement aux LinkedList, les ArrayList sont rapides en lecture, même avec un gros volume d'objets. Elles sont cependant plus lentes si vous devez ajouter ou supprimer des données en milieu de liste. Pour résumer à l'extrême, si vous effectuez beaucoup de lectures sans vous soucier de l'ordre des éléments, optez pour une ArrayList ; en revanche, si vous insérez beaucoup de données au milieu de la liste, optez pour une Linkedlist.

Les objets Map

Une collection de type Map est une collection qui fonctionne avec un couple clé - valeur. On y trouve les objets Hashtable, HashMap, TreeMap, WeakHashMap… La clé, qui sert à identifier une entrée dans notre collection, est unique. La valeur, au contraire, peut être associée à plusieurs clés.

Ces objets ont comme point faible majeur leur rapport conflictuel avec la taille des données à stocker. En effet, plus vous aurez de valeurs à mettre dans un objet Map, plus celles-ci seront lentes et lourdes : logique, puisque par rapport aux autres collections, il stocke une donnée supplémentaire par enregistrement. Une donnée c'est de la mémoire en plus et, même si les ordinateurs actuels en ont énormément, gardez en tête que « la mémoire, c'est sacré » (je vous rappelle que les applications Java ne sont pas forcément destinées aux appareils bénéficiant de beaucoup de mémoire).

L'objet Hashtable

Vous pouvez également dire « table de hachage », si vous traduisez mot à mot… On parcourt cet objet grâce aux clés qu'il contient en recourant à la classe Enumeration. L'objet Enumeration contient notre Hashtable et permet de le parcourir très simplement. Regardez, le code suivant insère les quatre saisons avec des clés qui ne se suivent pas, et notre énumération récupère seulement les valeurs :

import java.util.Enumeration;
import java.util.Hashtable;

public class Test {

  public static void main(String[] args) {

    Hashtable ht = new Hashtable();
    ht.put(1, "printemps");
    ht.put(10, "été");
    ht.put(12, "automne");
    ht.put(45, "hiver");

    Enumeration e = ht.elements();

    while(e.hasMoreElements())
      System.out.println(e.nextElement());

  }
}

Cet objet nous offre lui aussi tout un panel de méthodes utiles :

• isEmpty() retourne « vrai » si l'objet est vide ;

• contains(Object value) retourne « vrai » si la valeur est présente. Identique à containsValue(Object value) ;

• containsKey(Object key) retourne « vrai » si la clé passée en paramètre est présente dans la Hashtable ;

• put(Object key, Object value) ajoute le couple key - value dans l'objet ;

• elements() retourne une énumération des éléments de l'objet ;

• keys() retourne la liste des clés sous forme d'énumération.

De plus, il faut savoir qu'un objet Hashtable n'accepte pas la valeur null et qu'il est Thread Safe, c'est-à-dire qu'il est utilisable dans plusieurs threads (cela signifie que plusieurs éléments de votre programme peuvent l'utiliser simultanément ; nous y reviendrons) simultanément sans qu'il y ait un risque de conflit de données.

L'objet HashMap

Cet objet ne diffère que très peu de la Hashtable:

• il accepte la valeur null ;

• il n'est pas Thread Safe.

En fait, les deux objets de type Map sont, à peu de choses près, équivalents.

Les objets Set

Un Set est une collection qui n'accepte pas les doublons. Par exemple, elle n'accepte qu'une seule fois null, car deux valeurs null sont considérées comme un doublon. On trouve parmi les Set les objets HashSet, TreeSet, LinkedHashSet… Certains Set sont plus restrictifs que d'autres : il en existe qui n'acceptent pas null, certains types d'objets, etc.

Les Set sont particulièrement adaptés pour manipuler une grande quantité de données. Cependant, les performances de ceux-ci peuvent être amoindries en insertion. Généralement, on opte pour un HashSet, car il est plus performant en temps d'accès, mais si vous avez besoin que votre collection soit constamment triée, optez pour un TreeSet.

L'objet HashSet

C'est sans nul doute la plus utilisée des implémentations de l'interface Set. On peut parcourir ce type de collection avec un objet Iterator ou extraire de cet objet un tableau d'Object :

import java.util.HashSet;
import java.util.Iterator;
 
public class Test { 
  public static void main(String[] args) {         
    HashSet hs = new HashSet();
    hs.add("toto");
    hs.add(12);
    hs.add('d');

    Iterator it = hs.iterator();
    while(it.hasNext())
      System.out.println(it.next());
 
    System.out.println("\nParcours avec un tableau d'objet");
    System.out.println("-----------------------------------");
                
    Object[] obj = hs.toArray();
    for(Object o : obj)
      System.out.println(o);                
  }
}

Voici une liste des méthodes que l'on trouve dans cet objet :

• add() ajoute un élément ;

• contains(Object value) retourne « vrai » si l'objet contient value ;

• isEmpty() retourne « vrai » si l'objet est vide ;

• iterator() renvoie un objet de type Iterator ;

• remove(Object o) retire l'objet o de la collection ;

• toArray() retourne un tableau d'Object.

Voilà ! Nous avons vu quelque chose d'assez intéressant que nous pourrons utiliser dans peu de temps, mais avant, nous avons encore du pain sur la planche. Dans le chapitre suivant nous verrons d'autres aspects de nos collections.

• Une collection permet de stocker un nombre variable d'objets.

• Il y a principalement trois types de collection : les List, les Set et les Map.

• Chaque type a ses avantages et ses inconvénients.

• Les Collection stockent des objets alors que les Map stockent un couple clé - valeur.

• Si vous insérez fréquemment des données en milieu de liste, utilisez une LinkedList.

• Si vous voulez rechercher ou accéder à une valeur via une clé de recherche, optez pour une collection de type Map.

• Si vous avez une grande quantité de données à traiter, tournez-vous vers une liste de type Set.

Principe de base

Bon, pour vous montrer la puissance de la généricité, nous allons tout de suite voir un cas de classe qui ne l'utilise pas.

Il existe un exemple très simple que vous pourrez retrouver aisément sur Internet, car il s'agit d'un des cas les plus faciles permettant d'illustrer les bases de la généricité. Nous allons coder une classe Solo. Celle-ci va travailler avec des références de type String. Voici le diagramme de classe de cette dernière en figure suivante.

Vous pouvez voir que le code de cette classe est très rudimentaire. On affecte une valeur, on peut la mettre à jour et la récupérer… Maintenant, si je vous demande de me faire une classe qui permet de travailler avec n'importe quel type de données, j'ai une vague idée de ce que vous allez faire. Ne serait-ce pas quelque chose s'approchant de la figure suivante ?

J'en étais sûr. Créez la classe Solo, ainsi qu'une classe avec une méthode main. Si vous voulez utiliser les données de l'objet Solo, vous allez devoir faire un cast. Testez ce code dans votre main :

public class Test { 
  public static void main(String[] args) {                
    Solo val = new Solo(12);
    int nbre = val.getValeur();             
  } 
}

Vous constatez que vous essayez vainement de mettre un objet de type Object dans un objet de type Integer : c'est interdit ! La classe Object est plus globale que la classe Integer, vous ne pouvez donc pas effectuer cette opération, sauf si vous castez votre objet en Integer comme ceci :

Solo val = new Solo(12);
int nbre = (Integer)val.getValeur();

Pour le moment, on peut dire que votre classe peut travailler avec tous les types de données, mais les choses se corsent un peu à l'utilisation. Vous serez donc sans doute tentés d'écrire une classe par type de donnée (SoloInt, SoloString, etc.). Et c'est là que la généricité s'avère utile, car avec cette dernière, vous pourrez savoir ce que contient votre objet Solo et n'aurez qu'une seule classe à développer ! Voilà le diagramme de classe de cet objet en figure suivante.

Et voici son code :

public class Solo<T> {
 
  //Variable d'instance
  private T valeur;
        
  //Constructeur par défaut
  public Solo(){
    this.valeur = null;
  }

  //Constructeur avec paramètre inconnu pour l'instant
  public Solo(T val){
    this.valeur = val;
  }
        
  //Définit la valeur avec le paramètre
  public void setValeur(T val){
    this.valeur = val;
  }
        
  //Retourne la valeur déjà « castée » par la signature de la méthode !
  public T getValeur(){
    return this.valeur;
  }       
}

Impressionnant, n'est-ce pas ? Dans cette classe, le T n'est pas encore défini. Vous vous en occuperez à l'instanciation de la classe. Par contre, une fois instancié avec un type, l'objet ne pourra travailler qu'avec le type de données que vous lui avez spécifié ! Exemple de code :

public static void main(String[] args) {
  Solo<Integer> val = new Solo<Integer>(12);
  int nbre = val.getValeur();             
}

Ce code fonctionne très bien, mais si vous essayez de faire ceci :

public static void main(String[] args) {
  Solo<Integer> val = new Solo<Integer>("toto"); 
  //Ici, on essaie de mettre une chaîne de caractères à la place d'un entier
  int nbre = val.getValeur();             
}

… ou encore ceci :

public static void main(String[] args) {
  Solo<Integer> val = new Solo<Integer>(12);
  val.setValeur(12.2f);   
  //Ici, on essaie de mettre un nombre à virgule flottante à la place d'un entier        
}

… vous obtiendrez une erreur dans la zone de saisie. Ceci vous indique que votre objet ne reçoit pas le bon type d'argument, il y a donc un conflit entre le type de données que vous avez passé à votre instance lors de sa création et le type de données que vous essayez d'utiliser dans celle-ci ! Par contre, vous devez savoir que cette classe ne fonctionne pas seulement avec des Integer. Vous pouvez utiliser tous les types que vous souhaitez ! Voici une démonstration de ce que j'avance :

public static void main(String[] args) {
  Solo<Integer> val = new Solo<Integer>();
  Solo<String> valS = new Solo<String>("TOTOTOTO");
  Solo<Float> valF = new Solo<Float>(12.2f);
  Solo<Double> valD = new Solo<Double>(12.202568);                
}

Vous avez certainement remarqué que je n'ai pas utilisé ici les types de données que vous employez pour déclarer des variables de type primitif ! Ce sont les classes de ces types primitifs.

En effet, lorsque vous déclarez une variable de type primitif, vous pouvez utiliser ses classes enveloppes (on parle aussi de classe wrapper) ; elles ajoutent les méthodes de la classe Object à vos types primitifs ainsi que des méthodes permettant de caster leurs valeurs, etc. À ceci, je dois ajouter que depuis Java 5, est géré ce qu'on appelle l'autoboxing, une fonctionnalité du langage permettant de transformer automatiquement un type primitif en classe wrapper (on appelle ça le boxing) et inversement, c'est-à-dire une classe wrapper en type primitif (ceci s'appelle l'unboxing). Ces deux fonctionnalités forment l'autoboxing. Par exemple :

public static void main(String[] args){ 
  int i = new Integer(12);         //Est équivalent à int i = 12
  double d = new Double(12.2586);  //Est équivalent à double d = 12.2586
  Double d = 12.0;
  Character c = 'C';
  al = new ArrayList();
  //Avant Java 5 il fallait faire al.add(new Integer(12))
  //Depuis Java 5 il suffit de faire
  al.add(12); 
  //…
}

Plus loin dans la généricité !

Vous devez savoir que la généricité peut être multiple ! Nous avons créé une classe Solo, mais rien ne vous empêche de créer une classe Duo, qui elle prend deux paramètres génériques ! Voilà le code source de cette classe :

public class Duo<T, S> { 
  //Variable d'instance de type T
  private T valeur1;

  //Variable d'instance de type S
  private S valeur2;
        
  //Constructeur par défaut
  public Duo(){
    this.valeur1 = null;
    this.valeur2 = null;
  }        

  //Constructeur avec paramètres
  public Duo(T val1, S val2){
    this.valeur1 = val1;
    this.valeur2 = val2;
  }
        
  //Méthodes d'initialisation des deux valeurs
  public void setValeur(T val1, S val2){
    this.valeur1 = val1;
    this.valeur2 = val2;
  }
 
  //Retourne la valeur T
  public T getValeur1() {
    return valeur1;
  }
 
  //Définit la valeur T
  public void setValeur1(T valeur1) {
    this.valeur1 = valeur1;
  }
 
  //Retourne la valeur S
  public S getValeur2() {
    return valeur2;
  }
 
  //Définit la valeur S
  public void setValeur2(S valeur2) {
    this.valeur2 = valeur2;
  }        
}

Vous voyez que cette classe prend deux types de références qui ne sont pas encore définis.
Afin de mieux comprendre son fonctionnement, voici un code que vous pouvez tester :

public static void main(String[] args) {
  Duo<String, Boolean> dual = new Duo<String, Boolean>("toto", true);
  System.out.println("Valeur de l'objet dual : val1 = " + dual.getValeur1() + ", val2 = " + dual.getValeur2());
                
  Duo<Double, Character> dual2 = new Duo<Double, Character>(12.2585, 'C');
  System.out.println("Valeur de l'objet dual2 : val1 = " + dual2.getValeur1() + ", val2 = " + dual2.getValeur2()); 
}

Le résultat est visible sur la figure suivante.

Vous voyez qu'il n'y a rien de bien méchant ici. Ce principe fonctionne exactement comme dans l'exemple précédent. La seule différence réside dans le fait qu'il n'y a pas un, mais deux paramètres génériques !

En fait, non. Si vous faites :

public static void main(String[] args) {                
  Duo<String, Boolean> dual = new Duo<String, Boolean>("toto", true);
  System.out.println("Valeur de l'objet dual: val1 = " + dual.getValeur1() + ", val2 = " + dual.getValeur2());
  dual = new Duo<Double, Character>();
}

… vous violez la contrainte que vous avez émise lors de la déclaration du type de référence ! Vous ne pourrez donc pas modifier la déclaration générique d'un objet. Donc si vous suivez bien, on va pouvoir encore corser la chose !

Généricité et collections

Vous pouvez aussi utiliser la généricité sur les objets servant à gérer des collections. C'est même l'un des points les plus utiles de la généricité !

En effet, lorsque vous listiez le contenu d'un ArrayList par exemple, vous n'étiez jamais sûrs à 100 % du type de référence sur lequel vous alliez tomber (normal, puisqu'un ArrayList accepte tous les types d'objets)… Eh bien ce calvaire est terminé et le polymorphisme va pouvoir réapparaître, plus puissant que jamais !

Voyez comment utiliser la généricité avec les collections :

public static void main(String[] args) {

  System.out.println("Liste de String");
  System.out.println("------------------------------");
  List<String> listeString= new ArrayList<String>();
  listeString.add("Une chaîne");
  listeString.add("Une autre");
  listeString.add("Encore une autre");
  listeString.add("Allez, une dernière");

  for(String str : listeString)
    System.out.println(str);

  System.out.println("\nListe de float");
  System.out.println("------------------------------");
                
  List<Float> listeFloat = new ArrayList<Float>();
  listeFloat.add(12.25f);
  listeFloat.add(15.25f);
  listeFloat.add(2.25f);
  listeFloat.add(128764.25f);
                
  for(float f : listeFloat)
    System.out.println(f);
}

Voyez le résultat de ce code sur la figure suivante.

Vu qu'on y va crescendo, on pimente à nouveau le tout !

Héritage et généricité

Là où les choses sont pernicieuses, c'est quand vous employez des classes usant de la généricité avec des objets comprenant la notion d'héritage ! L'héritage dans la généricité est l'un des concepts les plus complexes en Java. Pourquoi ? Tout simplement parce qu'il va à l'encontre de ce que vous avez appris jusqu'à présent…

Acceptons le postulat suivant

Nous avons une classe Voiture dont hérite une autre classe VoitureSansPermis, ce qui nous donnerait le diagramme représenté à la figure suivante.

Jusque-là, c'est simplissime. Maintenant, ça se complique :

public static void main(String[] args) {                
  List<Voiture> listVoiture = new ArrayList<Voiture>();
  List<VoitureSansPermis> listVoitureSP = new ArrayList<VoitureSansPermis>();
                
  listVoiture = listVoitureSP;   //Interdit ! 
}

Si vous avez l'habitude de la covariance des variables, sachez que cela n'existe pas avec la généricité ! En tout cas, pas sous la même forme.

Imaginez deux secondes que l'instruction interdite soit permise ! Dans listVoiture, vous avez le contenu de la liste des voitures sans permis, et rien ne vous empêche d'y ajouter une voiture. Là où le problème prend toute son envergure, c'est lorsque vous voudrez sortir toutes les voitures sans permis de votre variable listVoiture. Eh oui ! Vous y avez ajouté une voiture ! Lors du balayage de la liste, vous aurez, à un moment, une référence de type VoitureSansPermis à laquelle vous tentez d'affecter une référence de type Voiture. Voilà pourquoi ceci est interdit.

Une des solutions consiste à utiliser le wildcard : « ? ». Le fait de déclarer une collection avec le wildcard, comme ceci :

ArrayList<?> list;

… revient à indiquer que notre collection accepte n'importe quel type d'objet. Cependant, nous allons voir un peu plus loin qu'il y a une restriction.

Je vais maintenant vous indiquer quelque chose d'important. Avec la généricité, vous pouvez aller encore plus loin. Nous avons vu comment restreindre le contenu d'une de nos listes, mais nous pouvons aussi l’élargir ! Si je veux par exemple qu'un ArrayList puisse avoir toutes les instances de Voiture et de ses classes filles… comment faire ?

Attention les yeux, ça pique :

public static void main(String[] args) {
  //List n'acceptant que des instances de Voiture ou de ses sous-classes
  List<? extends Voiture> listVoitureSP = new ArrayList<VoitureSansPermis>();           
}

Une application de ceci consiste à écrire des méthodes génériques, par exemple une méthode qui permet de lister toutes les valeurs de notre ArrayList cité précédemment :

public static void main(String[] args) {
                
  List<? extends Voiture> listVoitureSP = new ArrayList<VoitureSansPermis>(); 
  afficher(listVoitureSP);          
}
        
//Méthode générique !
static void afficher(ArrayList<? extends Voiture> list){
  for(Voiture v : list)
    System.out.println(v.toString());
}

Oui… Ce que je ne vous avais pas dit, c'est que dès que vous utilisez le wildcard, vos listes sont verrouillées en insertion : elles se transforment en collections en lecture seule..

En fait, il faut savoir que c'est à la compilation du programme que Java ne vous laisse pas faire : le wildcard signifie « tout objet », et dès l'utilisation de celui-ci, la JVM verrouillera la compilation du programme afin de prévenir les risques d'erreurs. Dans notre exemple, il est combiné avec extends (signifiant héritant), mais cela n'a pas d'incidence directe : c'est le wildcard la cause du verrou (un objet générique comme notre objet Solo déclaré Solo<?> solo; sera également bloqué en écriture).

Par contre, ce type d'utilisation fonctionne à merveille pour la lecture :

public static void main(String[] args){

  //Liste de voiture
  List<Voiture> listVoiture = new ArrayList<Voiture>();
  listVoiture.add(new Voiture());
  listVoiture.add(new Voiture());

  List<VoitureSansPermis> listVoitureSP = new ArrayList<VoitureSansPermis>();
  listVoitureSP.add(new VoitureSansPermis());
  listVoitureSP.add(new VoitureSansPermis());

  affiche(listVoiture);
  affiche(listVoitureSP);
}

//Avec cette méthode, on accepte aussi bien les collections de Voiture que les collection de VoitureSansPermis
static void affiche(List<? extends Voiture> list){

  for(Voiture v : list)
    System.out.print(v.toString());
}

Avant que vous ne posiez la question, non, déclarer la méthode affiche(List<Voiture> list) {…} ne vous permet pas de parcourir des listes de VoitureSansPermis, même si celle-ci hérite de la classe Voiture.

Les méthodes déclarées avec un type générique sont verrouillées afin de n'être utilisées qu'avec ce type bien précis, toujours pour les mêmes raisons ! Attendez : ce n'est pas encore tout. Nous avons vu comment élargir le contenu de nos collections (pour la lecture), nous allons voir comment restreindre les collections acceptées par nos méthodes.

La méthode :

static void affiche(List<? extends Voiture> list){
  for(Voiture v : list)
    System.out.print(v.toString());
}

… autorise n'importe quel objet de type List dont Voiture est la superclasse.

La signification de l'instruction suivante est donc que la méthode autorise un objet de type List de n'importe quelle superclasse de la classe Voiture (y compris Voiture elle-même).

static void affiche(List<? super Voiture> list){
  for(Object v : list)
    System.out.print(v.toString());
}

Ce code fonctionne donc parfaitement :

public static void main(String[] args){
  //Liste de voiture
  List<Voiture> listVoiture = new ArrayList<Voiture>();
  listVoiture.add(new Voiture());
  listVoiture.add(new Voiture());

  List<Object> listVoitureSP = new ArrayList<Object>();
  listVoitureSP.add(new Object());
  listVoitureSP.add(new Object());

  affiche(listVoiture);		
}

//Avec cette méthode, on accepte aussi bien les collections de Voiture que les collections d'Object : superclasse de toutes les classes

static void affiche(List<? super Voiture> list){
  for(Object v : list)
    System.out.print(v.toString());
}

L'utilité du wildcard est surtout de permettre de retrouver le polymorphisme avec les collections. Afin de mieux cerner l'intérêt de tout cela, voici un petit exemple de code :

import java.util.ArrayList;
import java.util.List;

public class Garage {
  List<Voiture> list = new ArrayList<Voiture>();

  public void add(List<? extends Voiture> listVoiture){
    for(Voiture v : listVoiture)
      list.add(v); 

    System.out.println("Contenu de notre garage :");
    for(Voiture v : list)
      System.out.print(v.toString());		
   }
}

Un petit test rapide :

public static void main(String[] args){
  List<Voiture> listVoiture = new ArrayList<Voiture>();
  listVoiture.add(new Voiture());
		
  List<VoitureSansPermis> listVoitureSP = new ArrayList<VoitureSansPermis>();
  listVoitureSP.add(new VoitureSansPermis());
		
  Garage garage = new Garage();
  garage.add(listVoiture);
  System.out.println("--------------------------");
  garage.add(listVoitureSP);		
}

Essayez donc : ce code fonctionne parfaitement et vous permettra de constater que le polymorphisme est possible avec les collections. Je conçois bien que ceci est un peu difficile à comprendre, mais vous en aurez sûrement besoin dans une de vos prochaines applications !

• La généricité est un concept très utile pour développer des objets travaillant avec plusieurs types de données.

• Vous passerez donc moins de temps à développer des classes traitant de façon identique des données différentes.

• La généricité permet de réutiliser sans risque le polymorphisme avec les collections.

• Cela confère plus de robustesse à votre code.

• Vous pouvez coupler les collections avec la généricité !

• Le wildcard (?) permet d'indiquer que n'importe quel type peut être traité et donc accepté !

• Dès que le wildcard (?) est utilisé, cela revient à rendre ladite collection en lecture seule !

• Vous pouvez élargir le champ d'acceptation d'une collection générique grâce au mot-clé extends.

• L'instruction ? extends MaClasse autorise toutes les collections de classes ayant pour supertype MaClasse.

• L'instruction ? super MaClasse autorise toutes les collections de classes ayant pour type MaClasse et tous ses supertypes !

• Pour ce genre de cas, les méthodes génériques sont particulièrement adaptées et permettent d'utiliser le polymorphisme dans toute sa splendeur !

Utilisation de java.io

L'objet File

Avant de commencer, créez un fichier avec l'extension que vous voulez et enregistrez-le à la racine de votre projet Eclipse. Personnellement, je me suis fait un fichier test.txt dont voici le contenu :

Voici une ligne de test.
Voici une autre ligne de test.
Et comme je suis motivé, en voici une troisième !

Dans votre projet Eclipse, faites un clic droit sur le dossier de votre projet, puis New > File. Vous pouvez nommer votre fichier ainsi qu'y taper du texte !
Le nom du dossier contenant mon projet s'appelle « IO » et mon fichier texte est à cette adresse : D:\Mes documents\Codage\SDZ\Java-SDZ\IO est.txt. Nous allons maintenant voir ce dont l'objet File est capable. Vous remarquerez que cet objet est très simple à utiliser et que ses méthodes sont très explicites.

//Package à importer afin d'utiliser l'objet File
import java.io.File;

public class Main {
  public static void main(String[] args) {
    //Création de l'objet File
    File f = new File("test.txt");
    System.out.println("Chemin absolu du fichier : " + f.getAbsolutePath());
    System.out.println("Nom du fichier : " + f.getName());
    System.out.println("Est-ce qu'il existe ? " + f.exists());
    System.out.println("Est-ce un répertoire ? " + f.isDirectory());
    System.out.println("Est-ce un fichier ? " + f.isFile());
	
    System.out.println("Affichage des lecteurs à la racine du PC : ");
    for(File file : f.listRoots())
    {
      System.out.println(file.getAbsolutePath());
      try {
        int i = 1;	
        //On parcourt la liste des fichiers et répertoires
        for(File nom : file.listFiles()){
          //S'il s'agit d'un dossier, on ajoute un "/"
          System.out.print("\t\t" + ((nom.isDirectory()) ? nom.getName()+"/" : nom.getName()));
					
          if((i%4) == 0){
            System.out.print("\n");
          }
          i++;
        }
        System.out.println("\n");
      } catch (NullPointerException e) {
        //L'instruction peut générer une NullPointerException
        //s'il n'y a pas de sous-fichier !
      }
    }		
  }
}

Le résultat est bluffant (voir figure suivante) !

Vous conviendrez que les méthodes de cet objet peuvent s'avérer très utiles ! Nous venons d'en essayer quelques-unes et nous avons même listé les sous-fichiers et sous-dossiers de nos lecteurs à la racine du PC.

Vous pouvez aussi effacer le fichier grâce la méthode delete(), créer des répertoires avec la méthode mkdir() (le nom donné à ce répertoire ne pourra cependant pas contenir de point (« . »)) etc.

Maintenant que vous en savez un peu plus sur cet objet, nous pouvons commencer à travailler avec notre fichier !

Les objets FileInputStream et FileOutputStream

C'est par le biais des objets FileInputStream et FileOutputStream que nous allons pouvoir :

• lire dans un fichier ;

• écrire dans un fichier.

Ces classes héritent des classes abstraites InputStream et OutputStream, présentes dans le package java.io.

Comme vous l'avez sans doute deviné, il existe une hiérarchie de classes pour les traitements in et une autre pour les traitements out. Ne vous y trompez pas, les classes héritant d'InputStream sont destinées à la lecture et les classes héritant d'OutputStream se chargent de l'écriture !

Vous auriez dit le contraire ? Comme beaucoup de gens au début. Mais c'est uniquement parce que vous situez les flux par rapport à vous, et non à votre programme ! Lorsque ce dernier va lire des informations dans un fichier, ce sont des informations qu'il reçoit, et par conséquent, elles s'apparentent à une entrée : in (sachez tout de même que lorsque vous tapez au clavier, cette action est considérée comme un flux d'entrée !).

Au contraire, lorsqu'il va écrire dans un fichier (ou à l'écran, souvenez-vous de System.out.println), par exemple, il va faire sortir des informations ; donc, pour lui, ce flux de données correspond à une sortie : out.

Nous allons enfin commencer à travailler avec notre fichier. Le but est d'aller en lire le contenu et de le copier dans un autre, dont nous spécifierons le nom dans notre programme, par le biais d'un programme Java.

Ce code est assez compliqué, donc accrochez-vous à vos claviers !

//Packages à importer afin d'utiliser les objets
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
   public static void main(String[] args) {
      // Nous déclarons nos objets en dehors du bloc try/catch
      FileInputStream fis = null;
      FileOutputStream fos = null;

      try {
         // On instancie nos objets :
         // fis va lire le fichier
         // fos va écrire dans le nouveau !
         fis = new FileInputStream(new File("test.txt"));
         fos = new FileOutputStream(new File("test2.txt"));

         // On crée un tableau de byte pour indiquer le nombre de bytes lus à
         // chaque tour de boucle
         byte[] buf = new byte[8];

         // On crée une variable de type int pour y affecter le résultat de
         // la lecture
         // Vaut -1 quand c'est fini
         int n = 0;

         // Tant que l'affectation dans la variable est possible, on boucle
         // Lorsque la lecture du fichier est terminée l'affectation n'est
         // plus possible !
         // On sort donc de la boucle
         while ((n = fis.read(buf)) >= 0) {
            // On écrit dans notre deuxième fichier avec l'objet adéquat
            fos.write(buf);
            // On affiche ce qu'a lu notre boucle au format byte et au
            // format char
            for (byte bit : buf) {
               System.out.print("\t" + bit + "(" + (char) bit + ")");
               System.out.println("");
            }
         }
         System.out.println("Copie terminée !");

      } catch (FileNotFoundException e) {
         // Cette exception est levée si l'objet FileInputStream ne trouve
         // aucun fichier
         e.printStackTrace();
      } catch (IOException e) {
         // Celle-ci se produit lors d'une erreur d'écriture ou de lecture
         e.printStackTrace();
      } finally {
         // On ferme nos flux de données dans un bloc finally pour s'assurer
         // que ces instructions seront exécutées dans tous les cas même si
         // une exception est levée !
         try {
            if (fis != null)
               fis.close();
         } catch (IOException e) {
            e.printStackTrace();
         }

         try {
            if (fos != null)
               fos.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }
}

Notez bien les imports pour pouvoir utiliser ces objets. Mais comme vous le savez déjà, vous pouvez taper votre code et faire ensuite CTRL + SHIFT + O pour que les imports soient automatiques.

À l'exécution de ce code, vous pouvez voir que le fichier test2.txt a bien été créé et qu'il contient exactement la même chose que test.txt ! De plus, j'ai ajouté dans la console les données que votre programme va utiliser (lecture et écriture).

La figure suivante représente le résultat de ce code.

Le bloc finally permet de s'assurer que nos objets ont bien fermé leurs liens avec leurs fichiers respectifs, ceci afin de permette à Java de détruire ces objets pour ainsi libérer un peu de mémoire à votre ordinateur.

Les objets FileInputStream et FileOutputStream sont assez rudimentaires, car ils travaillent avec un nombre déterminé d'octets à lire. Cela explique pourquoi ma condition de boucle était si tordue…

Lorsque vous voyez des caractères dans un fichier ou sur votre écran, ils ne veulent pas dire grand-chose pour votre PC, car il ne comprend que le binaire (vous savez, les suites de 0 et de 1). Ainsi, afin de pouvoir afficher et travailler avec des caractères, un système d'encodage (qui a d'ailleurs fort évolué) a été mis au point.

Sachez que chaque caractère que vous saisissez ou que vous lisez dans un fichier correspond à un code binaire, et ce code binaire correspond à un code décimal. Voyez la table de correspondance (on parle de la table ASCII).

Cependant, au début, seuls les caractères de a à z, de A à Z et les chiffres de 0 à 9 (les 127 premiers caractères de la table ASCII) étaient codés (UNICODE 1), correspondant aux caractères se trouvant dans la langue anglaise. Mais ce codage s'est rapidement avéré trop limité pour des langues comportant des caractères accentués (français, espagnol…). Un jeu de codage de caractères étendu a donc été mis en place afin de pallier ce problème.

Chaque code binaire UNICODE 1 est codé sur 8 bits, soit 1 octet. Une variable de type byte, en Java, correspond en fait à 1 octet et non à 1 bit !

Les objets que nous venons d'utiliser emploient la première version d'UNICODE 1 qui ne comprend pas les caractères accentués, c'est pourquoi ces caractères ont un code décimal négatif dans notre fichier. Lorsque nous définissons un tableau de byte à 8 entrées, cela signifie que nous allons lire 8 octets à la fois.

Vous pouvez voir qu'à chaque tour de boucle, notre tableau de byte contient huit valeurs correspondant chacune à un code décimal qui, lui, correspond à un caractère (valeur entre parenthèses à côté du code décimal).

Vous pouvez voir que les codes décimaux négatifs sont inconnus, car ils sont représentés par des « ? » ; de plus, il y a des caractères invisibles (les 32 premiers caractères de la table ASCII sont invisibles !) dans notre fichier :

• les espaces : SP pour « SPace », code décimal 32 ;

• les sauts de lignes : LF pour « Line Feed », code décimal 13 ;

• les retours chariot : CR pour « Carriage Return », code décimal 10.

Vous voyez que les traitements des flux suivent une logique et une syntaxe précises ! Lorsque nous avons copié notre fichier, nous avons récupéré un certain nombre d'octets dans un flux entrant que nous avons passé à un flux sortant. À chaque tour de boucle, les données lues dans le fichier source sont écrites dans le fichier défini comme copie.

Il existe à présent des objets beaucoup plus faciles à utiliser, mais qui travaillent néanmoins avec les deux objets que nous venons d'étudier. Ces objets font également partie de la hiérarchie citée précédemment. Seulement, il existe une superclasse qui les définit.

Les objets FilterInputStream et FilterOutputStream

Ces deux classes sont en fait des classes abstraites. Elles définissent un comportement global pour leurs classes filles qui, elles, permettent d'ajouter des fonctionnalités aux flux d'entrée/sortie !

La figure suivante représente un diagramme de classes schématisant leur hiérarchie.

Vous pouvez voir qu'il existe quatre classes filles héritant de FilterInputStream (de même pour FilterOutputStream (les classes dérivant de FilterOutputStream ont les mêmes fonctionnalités, mais en écriture)):

• DataInputStream : offre la possibilité de lire directement des types primitifs (double, char, int) grâce à des méthodes comme readDouble(), readInt()…

• BufferedInputStream : cette classe permet d'avoir un tampon à disposition dans la lecture du flux. En gros, les données vont tout d'abord remplir le tampon, et dès que celui-ci est plein, le programme accède aux données.

• PushbackInputStream : permet de remettre un octet déjà lu dans le flux entrant.

• LineNumberInputStream : cette classe offre la possibilité de récupérer le numéro de la ligne lue à un instant T.

Ces classes prennent en paramètre une instance dérivant des classes InputStream(pour les classes héritant de FilterInputStream) ou de OutputStream (pour les classes héritant de FilterOutputStream).

Puisque ces classes acceptent une instance de leur superclasse en paramètre, vous pouvez cumuler les filtres et obtenir des choses de ce genre :

FileInputStream fis = new FileInputStream(new File("toto.txt"));
DataInputStream dis = new DataInputStream(fis);
BufferedInputStream bis = new BufferedInputStream(dis);
//Ou en condensé : 
BufferedInputStream  bis = new BufferredInputStream(
                             new DataInputStream(
                               new FileInputStream(
                                 new File("toto.txt"))));

Afin de vous rendre compte des améliorations apportées par ces classes, nous allons lire un énorme fichier texte (3,6 Mo) de façon conventionnelle avec l'objet vu précédemment, puis grâce à un buffer.

Télécharger le fichier

Récupérez le fichier compressé grâce à un logiciel de compression/décompression et remplacez le contenu de votre fichier test.txt par le contenu de ce fichier. Maintenant, voici un code qui permet de tester le temps d'exécution de la lecture :

//Packages à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    //Nous déclarons nos objets en dehors du bloc try/catch
    FileInputStream fis;
    BufferedInputStream bis;        
    try {
      fis = new FileInputStream(new File("test.txt"));
      bis = new BufferedInputStream(new FileInputStream(new File("test.txt")));
      byte[] buf = new byte[8];

      //On récupère le temps du système
      long startTime = System.currentTimeMillis();
      //Inutile d'effectuer des traitements dans notre boucle
      while(fis.read(buf) != -1);
      //On affiche le temps d'exécution
      System.out.println("Temps de lecture avec FileInputStream : " + (System.currentTimeMillis() - startTime));
                
      //On réinitialise                
      startTime = System.currentTimeMillis();
      //Inutile d'effectuer des traitements dans notre boucle
      while(bis.read(buf) != -1);
      //On réaffiche
      System.out.println("Temps de lecture avec BufferedInputStream : " + System.currentTimeMillis() - startTime));
                
      //On ferme nos flux de données
      fis.close();
      bis.close();
                
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }     	
  }
}

Et le résultat, visible à la figure suivante, est encore une fois bluffant.

La différence de temps est vraiment énorme : 1,578 seconde pour la première méthode et 0,094 seconde pour la deuxième ! Vous conviendrez que l'utilisation d'un buffer permet une nette amélioration des performances de votre code. Faisons donc sans plus tarder le test avec l’écriture :

//Packages à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    //Nous déclarons nos objets en dehors du bloc try/catch
    FileInputStream fis;
    FileOutputStream fos;
    BufferedInputStream bis;
    BufferedOutputStream bos; 
        
    try {
      fis = new FileInputStream(new File("test.txt"));
      fos = new FileOutputStream(new File("test2.txt"));
      bis = new BufferedInputStream(new FileInputStream(new File("test.txt")));
      bos = new BufferedOutputStream(new FileOutputStream(new File("test3.txt")));
      byte[] buf = new byte[8];

      //On récupère le temps du système
      long startTime = System.currentTimeMillis();
                
      while(fis.read(buf) != -1){
        fos.write(buf);
      }
      //On affiche le temps d'exécution
      System.out.println("Temps de lecture + écriture avec FileInputStream et FileOutputStream : " + (System.currentTimeMillis() - startTime));
                
      //On réinitialise                
      startTime = System.currentTimeMillis();

      while(bis.read(buf) != -1){
        bos.write(buf);
      }
      //On réaffiche
      System.out.println("Temps de lecture + écriture avec BufferedInputStream et BufferedOutputStream : " + (System.currentTimeMillis() - startTime));
                
      //On ferme nos flux de données
      fis.close();
      bis.close();
                
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }     	
  }
}

Là, la différence est encore plus nette, comme le montre la figure suivante.

Si avec ça, vous n'êtes pas convaincus de l'utilité des buffers…

Je ne vais pas passer en revue tous les objets cités un peu plus haut, mais vu que vous risquez d’avoir besoin des objets Data(Input/Output)Stream, nous allons les aborder rapidement, puisqu'ils s'utilisent comme les objets BufferedInputStream. Je vous ai dit plus haut que ceux-ci ont des méthodes de lecture pour chaque type primitif : il faut cependant que le fichier soit généré par le biais d'un DataOutputStream pour que les méthodes fonctionnent correctement.

Nous allons donc créer un fichier de toutes pièces pour le lire par la suite.

//Packages à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    //Nous déclarons nos objets en dehors du bloc try/catch
    DataInputStream dis;
    DataOutputStream dos;
    try {
      dos = new DataOutputStream(
              new BufferedOutputStream(
                new FileOutputStream(
                  new File("sdz.txt"))));

      //Nous allons écrire chaque type primitif
      dos.writeBoolean(true);
      dos.writeByte(100);
      dos.writeChar('C');
      dos.writeDouble(12.05);
      dos.writeFloat(100.52f);
      dos.writeInt(1024);
      dos.writeLong(123456789654321L);
      dos.writeShort(2);
      dos.close();
        	
      //On récupère maintenant les données !
      dis = new DataInputStream(
              new BufferedInputStream(
                new FileInputStream(
                  new File("sdz.txt"))));
            
      System.out.println(dis.readBoolean());
      System.out.println(dis.readByte());
      System.out.println(dis.readChar());
      System.out.println(dis.readDouble());
      System.out.println(dis.readFloat());
      System.out.println(dis.readInt());
      System.out.println(dis.readLong());
      System.out.println(dis.readShort());
        	
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }     	
  }
}

La figure suivante correspond au résultat de ce code.

Le code est simple, clair et concis. Vous avez pu constater que ce type d'objet ne manque pas de fonctionnalités ! Jusqu'ici, nous ne travaillions qu'avec des types primitifs, mais il est également possible de travailler avec des objets !

Les objets ObjectInputStream et ObjectOutputStream

Vous devez savoir que lorsqu'on veut écrire des objets dans des fichiers, on appelle ça la « sérialisation » : c'est le nom que porte l'action de sauvegarder des objets ! Cela fait quelque temps déjà que vous utilisez des objets et, j'en suis sûr, vous avez déjà souhaité que certains d'entre eux soient réutilisables. Le moment est venu de sauver vos objets d'une mort certaine ! Pour commencer, nous allons voir comment sérialiser un objet de notre composition.

Voici la classe avec laquelle nous allons travailler :

//Package à importer
import java.io.Serializable;

public class Game implements Serializable{
  private String nom, style;
  private double prix;
	
  public Game(String nom, String style, double prix) {
    this.nom = nom;
    this.style = style;
    this.prix = prix;
  }
	
  public String toString(){
    return "Nom du jeu : " + this.nom + "\n
            Style de jeu : " + this.style + "\n
            Prix du jeu : " + this.prix + "\n";
  }	
}

En fait, cette interface n'a pas de méthode à redéfinir : l'interface Serializable est ce qu'on appelle une « interface marqueur ». Rien qu'en implémentant cette interface dans un objet, Java sait que cet objet peut être sérialisé. Et j'irai même plus loin : si vous n'implémentez pas cette interface dans vos objets, ceux-ci ne pourront pas être sérialisés ! En revanche, si une superclasse implémente l'interface Serializable, ses enfants seront considérés comme sérialisables.

Voici ce que nous allons faire :

• nous allons créer deux ou trois objets Game ;

• nous allons les sérialiser dans un fichier de notre choix ;

• nous allons ensuite les désérialiser afin de pouvoir les réutiliser.

Vous avez sûrement déjà senti comment vous allez vous servir de ces objets, mais travaillons tout de même sur l’exemple que voici :

//Packages à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Main {
  public static void main(String[] args) {
    //Nous déclarons nos objets en dehors du bloc try/catch
    ObjectInputStream ois;
    ObjectOutputStream oos;
    try {
      oos = new ObjectOutputStream(
              new BufferedOutputStream(
                new FileOutputStream(
                  new File("game.txt"))));
        	
      //Nous allons écrire chaque objet Game dans le fichier
      oos.writeObject(new Game("Assassin Creed", "Aventure", 45.69));
      oos.writeObject(new Game("Tomb Raider", "Plateforme", 23.45));
      oos.writeObject(new Game("Tetris", "Stratégie", 2.50));
      //Ne pas oublier de fermer le flux !
      oos.close();
        	
      //On récupère maintenant les données !
      ois = new ObjectInputStream(
              new BufferedInputStream(
                new FileInputStream(
                  new File("game.txt"))));
            
      try {
        System.out.println("Affichage des jeux :");
        System.out.println("*************************\n");
        System.out.println(((Game)ois.readObject()).toString());
        System.out.println(((Game)ois.readObject()).toString());
        System.out.println(((Game)ois.readObject()).toString());
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
      }
	
      ois.close();
        	
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }     	
  }
}

Et voyez le résultat en figure suivante.

Ce qu'il se passe est simple : les données de vos objets sont enregistrées dans le fichier. Mais que se passerait-il si notre objet Game avait un autre objet de votre composition en son sein ? Voyons ça tout de suite. Créez la classe Notice comme suit :

public class Notice {
  private String langue ;
  public Notice(){
    this.langue = "Français";
  }
  public Notice(String lang){
    this.langue = lang;
  }
  public String toString() {
    return "\t Langue de la notice : " + this.langue + "\n";
  }
}

Nous allons maintenant implémenter une notice par défaut dans notre objet Game. Voici notre classe modifiée :

import java.io.Serializable;

public class Game implements Serializable{
  private String nom, style;
  private double prix;
  private Notice notice;
	
  public Game(String nom, String style, double prix) {
    this.nom = nom;
    this.style = style;
    this.prix = prix;
    this.notice = new Notice();
  }

  public String toString(){
    return "Nom du jeu : " + this.nom + "\n
            Style de jeu : " + this.style + "\n
            Prix du jeu : " + this.prix + "\n";
  }	
}

Réessayez votre code sauvegardant vos objets Game. La figure suivante nous montre le résultat obtenu.

Eh non, votre code ne compile plus ! Il y a une bonne raison à cela : votre objet Notice n'est pas sérialisable, une erreur de compilation est donc levée. Maintenant, deux choix s'offrent à vous :

1. soit vous faites en sorte de rendre votre objet sérialisable ;

2. soit vous spécifiez dans votre classe Game que la variable notice n'a pas à être sérialisée.

Pour la première option, c'est simple, il suffit d'implémenter l'interface sérialisable dans notre classe Notice. Pour la seconde, il suffit de déclarer votre variable : transient ; comme ceci :

import java.io.Serializable;

public class Game implements Serializable{
  private String nom, style;
  private double prix;
  //Maintenant, cette variable ne sera pas sérialisée
  //Elle sera tout bonnement ignorée !
  private transient Notice notice;
	
  public Game(String nom, String style, double prix) {
    this.nom = nom;
    this.style = style;
    this.prix = prix;
    this.notice = new Notice();
  }
	
  public String toString(){
    return "Nom du jeu : " + this.nom + "\n
            Style de jeu : " + this.style + "\n
            Prix du jeu : " + this.prix + "\n";
  }	
}

Les objets CharArray(Writer/Reader) et String(Writer/Reader)

Nous allons utiliser des objets :

• CharArray(Writer/Reader) ;

• String(Writer/Reader).

Ces deux types jouent quasiment le même rôle. De plus, ils ont les mêmes méthodes que leur classe mère. Ces deux objets n'ajoutent donc aucune nouvelle fonctionnalité à leur objet mère.

Leur principale fonction est de permettre d'écrire un flux de caractères dans un buffer adaptatif : un emplacement en mémoire qui peut changer de taille selon les besoins (nous n'en avons pas parlé dans le chapitre précédent afin de ne pas l'alourdir, mais il existe des classes remplissant le même rôle que ces classes-ci : ByteArray(Input/Output)Stream).

Commençons par un exemple commenté des objets CharArray(Writer/Reader) :

//Packages à importer afin d'utiliser l'objet File
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    CharArrayWriter caw = new CharArrayWriter();
    CharArrayReader car;
		
    try {
      caw.write("Coucou les Zéros");
      //Appel à la méthode toString de notre objet de manière tacite
      System.out.println(caw);
			
      //caw.close() n'a aucun effet sur le flux
      //Seul caw.reset() peut tout effacer
      caw.close();
			
      //On passe un tableau de caractères à l'objet qui va lire le tampon
      car = new CharArrayReader(caw.toCharArray());
      int i;
      //On remet tous les caractères lus dans un String
      String str = "";
      while(( i = car.read()) != -1)
        str += (char) i;
			
      System.out.println(str);

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Je vous laisse le soin d'examiner ce code ainsi que son effet. Il est assez commenté pour que vous en compreniez toutes les subtilités. L'objet String(Writer/Reader) fonctionne de la même façon :

//Packages à importer afin d'utiliser l'objet File
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

public class Main {
  public static void main(String[] args) {
    StringWriter sw = new StringWriter();
    StringReader sr;
		
    try {
      sw.write("Coucou les Zéros");
      //Appel à la méthode toString de notre objet de manière tacite
      System.out.println(sw);
			
      //caw.close() n'a aucun effet sur le flux
      //Seul caw.reset() peut tout effacer
      sw.close();
			
      //On passe un tableau de caractères à l'objet qui va lire le tampon
      sr = new StringReader(sw.toString());			
      int i ;
      //On remet tous les caractères lus dans un String
      String str = "";
      while(( i = sr.read()) != -1)
        str += (char) i;

      System.out.println(str);

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

En fait, il s'agit du même code, mais avec des objets différents ! Vous savez à présent comment écrire un flux de texte dans un tampon de mémoire. Je vous propose maintenant de voir comment traiter les fichiers de texte avec des flux de caractères.

Les classes File(Writer/Reader) et Print(Writer/Reader)

Comme nous l'avons vu, les objets travaillant avec des flux utilisent des flux binaires.
La conséquence est que même si vous ne mettez que des caractères dans un fichier et que vous le sauvegardez, les objets étudiés précédemment traiteront votre fichier de la même façon que s’il contenait des données binaires ! Ces deux objets, présents dans le package java.io, servent à lire et écrire des données dans un fichier texte.

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {		
    File file = new File("testFileWriter.txt");
    FileWriter fw;
    FileReader fr;
		
    try {
      //Création de l'objet
      fw = new FileWriter(file);
      String str = "Bonjour à tous, amis Zéros !\n";
      str += "\tComment allez-vous ? \n";
      //On écrit la chaîne
      fw.write(str);
      //On ferme le flux
      fw.close();
			
      //Création de l'objet de lecture
      fr = new FileReader(file);
      str = "";
      int i = 0;
      //Lecture des données
      while((i = fr.read()) != -1)
        str += (char)i;

      //Affichage
      System.out.println(str);

    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Vous pouvez voir que l'affichage est bon et qu'un nouveau fichier (la lecture d'un fichier inexistant entraîne l’exception FileNotFoundException, et l'écriture peut entraîner une IOException) vient de faire son apparition dans le dossier contenant votre projet Eclipse !

Depuis le JDK 1.4, un nouveau package a vu le jour, visant à améliorer les performances des flux, buffers, etc. traités par java.io. En effet, vous ignorez probablement que le package que nous explorons depuis le début existe depuis la version 1.1 du JDK. Il était temps d'avoir une remise à niveau afin d'améliorer les résultats obtenus avec les objets traitant les flux. C'est là que le package java.nio a vu le jour !

Utilisation de java.nio

Vous l'avez sûrement deviné, nio signifie « New I/O ». Comme je vous l'ai dit précédemment, ce package a été créé afin d'améliorer les performances sur le traitement des fichiers, du réseau et des buffers. Il permet de lire les données (nous nous intéresserons uniquement à l'aspect fichier) d'une façon différente. Vous avez constaté que les objets du package java.io traitaient les données par octets. Les objets du package java.nio, eux, les traitent par blocs de données : la lecture est donc accélérée !

Tout repose sur deux objets de ce nouveau package : les channels et les buffers. Les channels sont en fait des flux, tout comme dans l'ancien package, mais ils sont amenés à travailler avec un buffer dont vous définissez la taille. Pour simplifier au maximum, lorsque vous ouvrez un flux vers un fichier avec un objet FileInputStream, vous pouvez récupérer un canal vers ce fichier. Celui-ci, combiné à un buffer, vous permettra de lire votre fichier encore plus vite qu'avec un BufferedInputStream !

Reprenez le gros fichier que je vous ai fait créer dans la sous-section précédente : nous allons maintenant le relire avec ce nouveau package en comparant le buffer conventionnel et la nouvelle façon de faire.

//Packages à importer afin d'utiliser l'objet File
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;

public class Main {
  public static void main(String[] args) {
    FileInputStream fis;
    BufferedInputStream bis;
    FileChannel fc;

    try {
      //Création des objets
      fis = new FileInputStream(new File("test.txt"));
      bis = new BufferedInputStream(fis);
      //Démarrage du chrono
      long time = System.currentTimeMillis();
      //Lecture
      while(bis.read() != -1);
      //Temps d'exécution
      System.out.println("Temps d'exécution avec un buffer conventionnel : " + (System.currentTimeMillis() - time));
			
      //Création d'un nouveau flux de fichier
      fis = new FileInputStream(new File("test.txt"));
      //On récupère le canal
      fc = fis.getChannel();
      //On en déduit la taille
      int size = (int)fc.size();
      //On crée un buffer correspondant à la taille du fichier
      ByteBuffer bBuff = ByteBuffer.allocate(size);
			
      //Démarrage du chrono
      time = System.currentTimeMillis();
      //Démarrage de la lecture
      fc.read(bBuff);
      //On prépare à la lecture avec l'appel à flip
      bBuff.flip();
      //Affichage du temps d'exécution
      System.out.println("Temps d'exécution avec un nouveau buffer : " + (System.currentTimeMillis() - time));
			
      //Puisque nous avons utilisé un buffer de byte afin de récupérer les données
      //Nous pouvons utiliser un tableau de byte
      //La méthode array retourne un tableau de byte
      byte[] tabByte = bBuff.array();
			
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

La figure suivante vous montre le résultat.

Vous constatez que les gains en performance ne sont pas négligeables. Sachez aussi que ce nouveau package est le plus souvent utilisé pour traiter les flux circulant sur les réseaux. Je ne m'attarderai pas sur le sujet, mais une petite présentation est de mise. Ce package offre un buffer par type primitif pour la lecture sur le channel, vous trouverez donc ces classes :

• IntBuffer ;

• CharBuffer ;

• ShortBuffer ;

• ByteBuffer ;

• DoubleBuffer ;

• FloatBuffer ;

• LongBuffer.

Je ne l'ai pas fait durant tout le chapitre afin d'alléger un peu les codes, mais si vous voulez être sûrs que votre flux est bien fermé, utilisez la clause finally. Par exemple, faites comme ceci :

//Packages à importer afin d'utiliser l'objet File
//…
public class Main {
  public static void main(String[] args) {

    //Nous déclarons nos objets en dehors du bloc try / catch
    ObjectInputStream ois;
    ObjectOutputStream oos;

    try {
      //On travaille avec nos objets
    } catch (FileNotFoundException e) {
      //Gestion des exceptions
    } catch (IOException e) {
      //Gestion des exceptions
    }     	
    finally{
      if(ois != null)ois.close();
      if(oos != null)oos.close(); 
    }
  }
}

Avec l'arrivée de Java 7, quelques nouveautés ont vu le jour pour la gestion des exceptions sur les flux. Contrairement à la gestion de la mémoire (vos variables, vos classes, etc.) qui est déléguée au garbage collector (ramasse miette), plusieurs types de ressources doivent être gérées manuellement. Les flux sur des fichiers en font parti mais, d'un point de vue plus général, toutes les ressources que vous devez fermer manuellement (les flux réseaux, les connexions à une base de données…). Pour ce genre de flux, vous avez vu qu'il vous faut déclarer une variable en dehors d'un bloc try{…}catch{…} afin qu'elle soit accessible dans les autres blocs d'instructions, le bloc finally par exemple.

Java 7 initie ce qu'on appelle vulgairement le « try-with-resources ». Ceci vous permet de déclarer les ressources utilisées directement dans le bloc try(…), ces dernières seront automatiquement fermées à la fin du bloc d'instructions ! Ainsi, si nous reprenons notre code de début de chapitre qui copie notre fichier test.txt vers test2.txt, nous aurons ceci :

try(FileInputStream fis = new FileInputStream("test.txt"); 
FileOutputStream fos = new FileOutputStream("test2.txt")) {
  byte[] buf = new byte[8];
  int n = 0;
  while((n = fis.read(buf)) >= 0){
    fos.write(buf);       
    for(byte bit : buf)
      System.out.print("\t" + bit + "(" + (char)bit + ")");         
   
    System.out.println("");
  }

  System.out.println("Copie terminée !");
        
} catch (IOException e) {
  e.printStackTrace();
}

C'est tout de même beaucoup plus clair et plus lisible qu'avant, surtout que vous n'avez plus à vous soucier de la fermeture dans le bloc finally. Il faut cependant prendre quelques précautions notamment pour ce genre de déclaration :

try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.txt"))) {
  //…
}

Le fait d'avoir des ressources encapsulées dans d'autres ne rend pas « visible » les ressources encapsulées. Dans le cas précédent, si une exception est levée, le flux correspondant à l'objet FileInputStream ne sera pas fermé. Pour pallier ce problème il suffit de bien découper toutes les ressources à utiliser, comme ceci :

try (FileInputStream fis = new FileInputStream("test.txt");
  ObjectInputStream ois = new ObjectInputStream(fis)) {
    //…
}

Rien ne vous échappe ! Si j'ai changé de façon de faire c'est parce qu'il y a une restriction sur ce mode de fonctionnement. Pour rendre la fermeture automatique possible, les développeurs de la plateforme Java 7 ont créé une nouvelle interface : java.lang.AutoCloseable. Seuls les objets implémentant cette interface peuvent être utilisés de la sorte ! Vous pouvez voir la liste des classes autorisées à cette adresse (et vous constaterez que la classe File n'en fait pas parti).

Depuis Java 7 : nio II

L'une des grandes nouveautés de Java 7 réside dans NIO.2 avec un nouveau package java.nio.file en remplacement de la classe java.io.File. Voici un bref listing de quelques nouveautés :

• une meilleure gestion des exceptions : la plupart des méthodes de la classe File se contentent de renvoyer une valeur nulle en cas de problème, avec ce nouveau package, des exceptions seront levées permettant de mieux cibler la cause du (ou des) problème(s) ;

• un accès complet au système de fichiers (support des liens/liens symboliques, etc.) ;

• l'ajout de méthodes utilitaires tels que le déplacement/la copie de fichier, la lecture/écriture binaire ou texte…

• récupérer la liste des fichiers d'un répertoire via un flux ;

• remplacement de la classe java.io.File par l'interface java.nio.file.Path.

Je vous propose maintenant de jouer avec quelques nouveautés. Commençons par le commencement : ce qui finira par remplacer la classe File. Afin d'être le plus souple et complet possible, les développeurs de la plateforme ont créé une interface java.nio.file.Path dont le rôle est de récupérer et manipuler des chemins de fichiers de dossier et une une classe java.nio.file.Files qui contient tout un tas de méthodes qui simplifient certaines actions (copie, déplacement, etc.) et permet aussi de récupérer tout un tas d'informations sur un chemin.

Afin d'illustrer ce nouveau mode de fonctionnement, je vous propose de reprendre le premier exemple de ce chapitre, celui qui affichait différentes informations sur notre fichier de test.

Path path = Paths.get("test.txt");
System.out.println("Chemin absolu du fichier : " + path.toAbsolutePath());
System.out.println("Est-ce qu'il existe ? " + Files.exists(path));
System.out.println("Nom du fichier : " + path.getFileName());
System.out.println("Est-ce un répertoire ? " + Files.isDirectory(path));

La classe Files vous permet aussi de lister le contenu d'un répertoire mais via un objet DirectoryStream qui est un itérateur. Ceci évite de charger tous les fichiers en mémoire pour récupérer leurs informations. Voici comment procéder :

//On récupère maintenant la liste des répertoires dans une collection typée
//Via l'objet FileSystem qui représente le système de fichier de l'OS hébergeant la JVM
Iterable<Path> roots = FileSystems.getDefault().getRootDirectories();

//Maintenant, il ne nous reste plus qu'à parcourir
for(Path chemin : roots){
  System.out.println(chemin);
  //Pour lister un répertoire, il faut utiliser l'objet DirectoryStream
  //L'objet Files permet de créer ce type d'objet afin de pouvoir l'utiliser
  try(DirectoryStream<Path> listing = Files.newDirectoryStream(chemin)){
	
    int i = 0;
    for(Path nom : listing){
      System.out.print("\t\t" + ((Files.isDirectory(nom)) ? nom+"/" : nom));
      i++;
      if(i%4 == 0)System.out.println("\n");
    }
		
  } catch (IOException e) {
    e.printStackTrace();
  }
}

Vous avez également la possibilité d'ajouter un filtre à votre listing de répertoire afin qu'il ne liste que certains fichiers :

try(DirectoryStream<Path> listing = Files.newDirectoryStream(chemin, "*.txt")){ … }
//Ne prendra en compte que les fichier ayant l'extension .txt

C'est vrai que cela change grandement la façon de faire et elle peut paraître plus complexe. Mais l'objet Files simplifie aussi beaucoup de choses. Voici quelques exemple de méthodes utilitaires qui, je pense, vont vous séduire.

La copie de fichier

Pour copier le fichier test.txt vers un fichier test2.txt, il suffit de faire :

Path source = Paths.get("test.txt");
Path cible = Paths.get("test2.txt");
try {
  Files.copy(source, cible, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) { e.printStackTrace();	}

Le troisième argument permet de spécifier les options de copie. Voici celles qui sont disponibles :

• StandardCopyOption.REPLACE_EXISTING : remplace le fichier cible même s'il existe déjà ;

• StandardCopyOption.COPY_ATTRIBUTES : copie les attributs du fichier source sur le fichier cible (droits en lecture etc.) ;

• StandardCopyOption.ATOMIC_MOVE : copie atomique ;

• LinkOption.NOFOLLOW_LINKS : ne prendra pas en compte les liens.

Le déplacement de fichier

Pour déplacer le fichier test2.txt vers un fichier test3.txt, il suffit de faire :

Path source = Paths.get("test2.txt");
Path cible = Paths.get("test3.txt");
try {
  Files.move(source, cible, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) { e.printStackTrace();	}

Dans le même genre vous avez aussi :

• une méthode Files.delete(path) qui supprime un fichier ;

• une méthode Files.createFile(path) qui permet de créer un fichier vide.

Ouvrir des flux

Ceci est très pratique pour lire ou écrire dans un fichier. Voici comment ça se traduit :

Path source = Paths.get("test.txt");
//Ouverture en lecture :
try ( InputStream input = Files.newInputStream(source) ) { … }

//Ouverture en écriture :
try ( OutputStream output = Files.newOutputStream(source) )  { … }

//Ouverture d'un Reader en lecture :
try ( BufferedReader reader = Files.newBufferedReader(source, StandardCharsets.UTF_8) )  { … }

//Ouverture d'un Writer en écriture :
try ( BufferedWriter writer = Files.newBufferedWriter(source, StandardCharsets.UTF_8) )  { … }

Pour en savoir plus sur ce que permet la nouvelle classe java.nio.file.Files, je vous invite à regarder la documentation Java.

Java 7 vous permet également de gérer les fichier ZIP grâce à l'objet FileSystem :

// Création d'un système de fichiers en fonction d'un fichier ZIP
try (FileSystem zipFS = FileSystems.newFileSystem(Paths.get("monFichier.zip"), null)) {

  //Suppression d'un fichier à l'intérieur du ZIP :
  Files.deleteIfExists( zipFS.getPath("test.txt") );

  //Création d'un fichier à l'intérieur du ZIP :
  Path path = zipFS.getPath("nouveau.txt");
  String message = "Hello World !!!";
  Files.write(path, message.getBytes());

  //Parcours des éléments à l'intérieur du ZIP :
  try (DirectoryStream<Path> stream = Files.newDirectoryStream(zipFS.getPath("/"))) {
    for (Path entry : stream) {
      System.out.println(entry);
    }
  }

  //Copie d'un fichier du disque vers l'archive ZIP :
    Files.copy(Paths.get("fichierSurDisque.txt"), zipFS.getPath("fichierDansZIP.txt"));
}

Il est également possible d'être averti via l'objet WatchService lorsqu'un un fichier est modifié, de gérer des entrées/sorties asynchrones via les objets AsynchronousFileChannel, AsynchronousSocketChannel ou AsynchronousServerSocketChannel. Ceci permet de faire les actions en tâche de fond, sans bloquer le code pendant l'exécution. Il est aussi possible d'avoir accès aux attributs grâce à 6 vues permettant de voir plus ou moins d'informations, à savoir :

• BasicFileAttributeView permet un accès aux propriétés généralement communes à tous les systèmes de fichiers ;

• DosFileAttributeViewajoute le support des attributs MS-DOS (readonly, hidden, system, archive) à l'objet ci-dessus ;

• PosixFileAttributeView ajoute les permissions POSIX du monde Unix au premier objet cité ;

• FileOwnerAttributeView permet de manipuler le propriétaire du fichier ;

• AclFileAttributeView permet de manipuler les droits d'accès au fichier ;

• UserDefinedFileAttributeView : permet de définir des attributs personnalisés.

Le pattern decorator

Vous avez pu remarquer que les objets de ce chapitre utilisent des instances d'objets de même supertype dans leur constructeur. Rappelez-vous cette syntaxe :

DataInputStream dis = new DataInputStream(
                        new BufferedInputStream(
                          new FileInputStream(
                            new File("sdz.txt"))));

La raison d'agir de la sorte est simple : c'est pour ajouter de façon dynamique des fonctionnalités à un objet. En fait, dites-vous qu'au moment de récupérer les données de notre objet DataInputStream, celles-ci vont d'abord transiter par les objets passés en paramètre. Ce mode de fonctionnement suit une certaine structure et une certaine hiérarchie de classes : c'est le pattern decorator.

Ce pattern de conception permet d'ajouter des fonctionnalités à un objet sans avoir à modifier son code source. Afin de ne pas trop vous embrouiller avec les objets étudiés dans ce chapitre, je vais vous fournir un autre exemple, plus simple, mais gardez bien en tête que les objets du package java.io utilisent ce pattern. Le but du jeu est d'obtenir un objet auquel nous pourrons ajouter des choses afin de le « décorer »… Vous allez travailler avec un objet Gateau qui héritera d'une classe abstraite Patisserie. Le but du jeu est de pouvoir ajouter des couches à notre gâteau sans avoir à modifier son code source.

Vous avez vu avec le pattern strategy que la composition (« A un ») est souvent préférable à l'héritage (« Est un ») : vous aviez défini de nouveaux comportements pour vos objets en créant un supertype d'objet par comportement. Ce pattern aussi utilise la composition comme principe de base : vous allez voir que nos objets seront composés d'autres objets. La différence réside dans le fait que nos nouvelles fonctionnalités ne seront pas obtenues uniquement en créant de nouveaux objets, mais en associant ceux-ci à des objets existants. Ce sera cette association qui créera de nouvelles fonctionnalités !

Nous allons procéder de la façon suivante :

• nous allons créer un objet Gateau ;

• nous allons lui ajouter une CoucheChocolat ;

• nous allons aussi lui ajouter une CoucheCaramel;

• nous appellerons la méthode qui confectionnera notre gâteau.

Tout cela démarre avec un concept fondamental : l'objet de base et les objets qui le décorent doivent être du même type, et ce, toujours pour la même raison, le polymorphisme, le polymorphisme, et le polymorphisme !

Vous allez comprendre. En fait, les objets qui vont décorer notre gâteau posséderont la même méthode preparer() que notre objet principal, et nous allons faire fondre cet objet dans les autres. Cela signifie que nos objets qui vont servir de décorateurs comporteront une instance de type Patisserie ; ils vont englober les instances les unes après les autres et du coup, nous pourrons appeler la méthode preparer() de manière récursive !

Vous pouvez voir les décorateurs comme des poupées russes : il est possible de mettre une poupée dans une autre. Cela signifie que si nous décorons notre gateau avec un objet CoucheChocolat et un objet CoucheCaramel, la situation pourrait être symbolisée par la figure suivante.

L'objet CoucheCaramel contient l'instance de la classe CoucheChocolat qui, elle, contient l'instance de Gateau : en fait, on va passer notre instance d'objet en objet ! Nous allons ajouter les fonctionnalités des objets « décorants » en appelant la méthode preparer() de l'instance se trouvant dans l'objet avant d'effectuer les traitements de la même méthode de l'objet courant, comme à la figure suivante.

Nous verrons, lorsque nous parlerons de la classe Thread, que ce système ressemble fortement à la pile d'invocations de méthodes. La figure suivante montre à quoi ressemble le diagramme de classes de notre exemple.

Vous remarquez sur ce diagramme que notre classe mère Patisserie est en fait la strategy (une classe encapsulant un comportement fait référence au pattern strategy : on peut dire qu'elle est la strategy de notre hiérarchie) de notre structure, c'est pour cela que nous pourrons appeler la méthode preparer() de façon récursive afin d'ajouter des fonctionnalités à nos objets. Voici les différentes classes que j'ai utilisées (je n'ai utilisé que des String afin de ne pas surcharger les sources, et pour que vous vous focalisiez plus sur la logique que sur le code).

Patisserie.java

public abstract class Patisserie {
  public abstract String preparer();	
}

Gateau.java

public class Gateau extends Patisserie{
  public String preparer() {
    return "Je suis un gâteau et je suis constitué des éléments suivants. \n";
  }
}

Couche.java

public abstract class Couche extends Patisserie{
  protected Patisserie pat;
  protected String nom;

  public Couche(Patisserie p){
    pat = p;
  }

  public String preparer() {
    String str = pat.preparer();
    return str + nom;
  }
}

CoucheChocolat.java

public class CoucheChocolat extends Couche{
  public CoucheChocolat(Patisserie p) {
    super(p);
    this.nom = "\t- Une couche de chocolat.\n";
  }
}

CoucheCaramel.java

public class CoucheCaramel extends Couche{
  public CoucheCaramel(Patisserie p) {
    super(p);
    this.nom = "\t- Une couche de caramel.\n";
  }
}

CoucheBiscuit.java

public class CoucheBiscuit extends Couche {
  public CoucheBiscuit(Patisserie p) {
    super(p);
    this.nom = "\t- Une couche de biscuit.\n";
  }
}

Et voici un code de test ainsi que son résultat, représenté à la figure suivante.

public class Main{
  public static void main(String[] args){
    Patisserie pat = new CoucheChocolat(
                       new CoucheCaramel(
                         new CoucheBiscuit(
                           new CoucheChocolat(
                             new Gateau()))));
    System.out.println(pat.preparer());
  }
}

J'ai agrémenté l'exemple d'une couche de biscuit, mais je pense que tout cela est assez représentatif de la façon dont fonctionnent des flux d'entrée/sortie en Java. Vous devriez réussir à saisir tout cela sans souci. Le fait est que vous commencez maintenant à avoir en main des outils intéressants pour programmer, et c'est sans compter les outils du langage : vous venez de mettre votre deuxième pattern de conception dans votre mallette du programmeur.

Vous avez pu voir que l'invocation des méthodes se faisait en allant jusqu'au dernier élément pour remonter ensuite la pile d'invocations. Pour inverser ce fonctionnement, il vous suffit d'inverser les appels dans la méthode preparer() : affecter d'abord le nom de la couche et ensuite le nom du décorateur.

• Les classes traitant des entrées/sorties se trouvent dans le package java.io.

• Les classes que nous avons étudiées dans ce chapitre sont héritées des classes suivantes :

  • InputStream, pour les classes gérant les flux d'entrée ;

  • OutputStream, pour les classes gérant les flux de sortie.

• La façon dont on travaille avec des flux doit respecter la logique suivante :

  • ouverture de flux ;

  • lecture/écriture de flux ;

  • fermeture de flux.

• La gestion des flux peut engendrer la levée d'exceptions : FileNotFoundException, IOException etc.

• L'action de sauvegarder des objets s'appelle la « sérialisation ».

• Pour qu'un objet soit sérialisable, il doit implémenter l'interface Serializable.

• Si un objet sérialisable comporte un objet d'instance non sérialisable, une exception sera levée lorsque vous voudrez sauvegarder votre objet.

• L'une des solutions consiste à rendre l'objet d'instance sérialisable, l'autre à le déclarer transient afin qu'il soit ignoré à la sérialisation.

• L'utilisation de buffers permet une nette amélioration des performances en lecture et en écriture de fichiers.

• Afin de pouvoir ajouter des fonctionnalités aux objets gérant les flux, Java utilise le pattern « decorator ».

• Ce pattern permet d'encapsuler une fonctionnalité et de l'invoquer de façon récursive sur les objets étant composés de décorateurs.

L'objet Class

Concrètement, que se passe-t-il ? Au chargement d'une classe Java, votre JVM crée automatiquement un objet. Celui-ci récupère toutes les caractéristiques de votre classe ! Il s'agit d'un objet Class.

Exemple : vous avez créé trois nouvelles classes Java. À l'exécution de votre programme, la JVM va créer un objet Class pour chacune d'elles. Comme vous devez vous en douter, cet objet possède une multitude de méthodes permettant d'obtenir tous les renseignements possibles et imaginables sur une classe.

Dans ce chapitre, nous allons visiter la classe String. Créez un nouveau projet ainsi qu'une classe contenant la méthode main. Voici deux façons de récupérer un objet Class :

public static void main(String[] args) { 
  Class c = String.class;
  Class c2 = new String().getClass();
  //La fameuse méthode finale dont je vous parlais dans le chapitre sur l'héritage
  //Cette méthode vient de la classe Object
}

Maintenant que vous savez récupérer un objet Class, nous allons voir ce dont il est capable. Nous n'allons examiner qu'une partie des fonctionnalités de l'objet Class : je ne vais pas tout vous montrer, je pense que vous êtes dorénavant à même de chercher et de trouver tout seuls. Vous avez l'habitude de manipuler des objets, à présent.

Connaître la superclasse d'une classe

Voici un petit code qui va répondre à la question de la superclasse :

System.out.println("La superclasse de la classe " + String.class.getName() + " est : " + String.class.getSuperclass());

Ce qui nous donne :

La superclasse de la classe java.lang.String est : class java.lang.Object

Notez que la classe Object n'a pas de superclasse. Normal, puisqu'elle se trouve au sommet de la hiérarchie. Donc si vous remplacez la classe String de l'exemple précédent par la classe Object, vous devriez obtenir :

La superclasse de la classe java.lang.Object est : null

En plus de ça, l'objet Class permet de connaître la façon dont votre objet est constitué : interfaces, classe mère, variables…

Connaître la liste des interfaces d'une classe

Vous pouvez tester ce code :

public static void main(String[] args) {                        
  //On récupère un objet Class
  Class c = new String().getClass();
  //Class c = String.class; est équivalent

  //La méthode getInterfaces retourne un tableau de Class
  Class[] faces = c.getInterfaces();
  //Pour voir le nombre d'interfaces
  System.out.println("Il y a " + faces.length + " interfaces implémentées");
  //On parcourt le tableau d'interfaces
  for(int i = 0; i < faces.length; i++)
    System.out.println(faces[i]);
}

Ce qui nous donne la figure suivante.

Connaître la liste des méthodes de la classe

La méthode getMethods() de l'objet Class nous retourne un tableau d'objets Method présents dans le package java.lang.reflect. Vous pouvez soit faire l'import à la main, soit déclarer un tableau d'objets Method et utiliser le raccourci Ctrl + Shift + O.

Voici un code qui retourne la liste des méthodes de la classe String :

public static void main(String[] args) {                                
  Class c = new String().getClass();
  Method[] m = c.getMethods();
                
  System.out.println("Il y a " + m.length + " méthodes dans cette classe");
  //On parcourt le tableau de méthodes
  for(int i = 0; i < m.length; i++)
    System.out.println(m[i]);
}

la figure suivante vous montre un morceau du résultat. Comme vous pouvez le constater, il y a beaucoup de méthodes dans la classe String.

Vous pouvez constater que l'objet Method regorge lui aussi de méthodes intéressantes. Voici un code qui affiche la liste des méthodes, ainsi que celle de leurs arguments respectifs :

public static void main(String[] args) {                                
  Class c = new String().getClass();
  Method[] m = c.getMethods();
                
  System.out.println("Il y a " + m.length + " méthodes dans cette classe");
  //On parcourt le tableau de méthodes
  for(int i = 0; i < m.length; i++)
  {
    System.out.println(m[i]);

    Class[] p = m[i].getParameterTypes();
    for(int j = 0; j < p.length; j++)
      System.out.println(p[j].getName());

    System.out.println("----------------------------------\n");
  }
}

Le résultat est visible sur la figure suivante. Il est intéressant de voir que vous obtenez toutes sortes d'informations sur les méthodes, leurs paramètres, les exceptions levées, leur type de retour, etc.

Connaître la liste des champs (variable de classe ou d'instance)

Ici, nous allons procéder de la même façon qu'avec la liste des méthodes sauf que cette fois, la méthode invoquée retournera un tableau d'objets Field. Voici un code qui affiche la liste des champs de la classe String.

public static void main(String[] args) {                
  Class c = new String().getClass();
  Field[] m = c.getDeclaredFields();

  System.out.println("Il y a " + m.length + " champs dans cette classe");
  //On parcourt le tableau de méthodes
  for(int i = 0; i < m.length; i++)
    System.out.println(m[i].getName());
}

Ce qui nous donne :

Il y a 7 champs dans cette classe
value
offset
count
hash
serialVersionUID
serialPersistentFields
CASE_INSENSITIVE_ORDER

Connaître la liste des constructeurs de la classe

Ici, nous utiliserons un objet Constructor pour lister les constructeurs de la classe :

public static void main(String[] args) {                                
  Class c = new String().getClass();
  Constructor[] construc = c.getConstructors();   
  System.out.println("Il y a " + construc.length + " constructeurs dans cette classe");
  //On parcourt le tableau des constructeurs
  for(int i = 0; i < construc.length; i++){
    System.out.println(construc[i].getName());

  Class[] param = construc[i].getParameterTypes();                        
  for(int j = 0; j < param.length; j++)
    System.out.println(param[j]);

  System.out.println("-----------------------------\n");
  }
}

Vous constatez que l'objet Class regorge de méthodes en tout genre !
Et si nous essayions d'exploiter un peu plus celles-ci ?

Instanciation dynamique

Nous allons voir une petite partie de la puissance de cette classe (pour l'instant). Dans un premier temps, créez un nouveau projet avec une méthode main ainsi qu'une classe correspondant au diagramme en figure suivante.

Voici son code Java :

public class Paire {
  private String valeur1, valeur2;

  public Paire(){
    this.valeur1 = null;
    this.valeur2 = null;
    System.out.println("Instanciation !");
  }

  public Paire(String val1, String val2){
    this.valeur1 = val1;
    this.valeur2 = val2;
    System.out.println("Instanciation avec des paramètres !");
  }

  public String toString(){
    return  "Je suis un objet qui a pour valeur : " + this.valeur1 +  " - " + this.valeur2;
  }

  public String getValeur1() {
    return valeur1;
  }
 
  public void setValeur1(String valeur1) {
    this.valeur1 = valeur1;
  }

  public String getValeur2() {
    return valeur2;
  }

  public void setValeur2(String valeur2) {
    this.valeur2 = valeur2;
  }
}

Le but du jeu consiste à créer un objet Paire sans utiliser l'opérateur new.

Pour instancier un nouvel objet Paire, commençons par récupérer ses constructeurs. Ensuite, nous préparons un tableau contenant les données à insérer, puis invoquons la méthode toString().

Regardez comment procéder ; attention, il y a moult exceptions :

public static void main(String[] args) {                                
  String nom = Paire.class.getName();                
  try {
    //On crée un objet Class
    Class cl = Class.forName(nom);
    //Nouvelle instance de la classe Paire
    Object o = cl.newInstance();

    //On crée les paramètres du constructeur
    Class[] types = new Class[]{String.class, String.class};
    //On récupère le constructeur avec les deux paramètres
    Constructor ct = cl.getConstructor(types);

    //On instancie l'objet avec le constructeur surchargé !
    Object o2 = ct.newInstance(new String[]{"valeur 1 ", "valeur 2"} );

  } catch (SecurityException e) {
    e.printStackTrace();
  } catch (IllegalArgumentException e) {
    e.printStackTrace();
  } catch (ClassNotFoundException e) {
    e.printStackTrace();
  } catch (InstantiationException e) {
    e.printStackTrace();
  } catch (IllegalAccessException e) {
    e.printStackTrace();
  } catch (NoSuchMethodException e) {
    e.printStackTrace();
  } catch (InvocationTargetException e) {
    e.printStackTrace();
  }
}

Et le résultat donne la figure suivante.

Nous pouvons maintenant appeler la méthode toString() du deuxième objet… Oh et puis soyons fous, appelons-la sur les deux :

public static void main(String[] args) {                                
  String nom = Paire.class.getName();
  try {
    //On crée un objet Class
    Class cl = Class.forName(nom);
    //Nouvelle instance de la classe Paire
    Object o = cl.newInstance();
                                
    //On crée les paramètres du constructeur
    Class[] types = new Class[]{String.class, String.class};
    //On récupère le constructeur avec les deux paramètres
    Constructor ct = cl.getConstructor(types);      
    //On instancie l'objet avec le constructeur surchargé !
    Object o2 = ct.newInstance(new String[]{"valeur 1 ", "valeur 2"} );

    //On va chercher la méthode toString, elle n'a aucun paramètre
    Method m = cl.getMethod("toString", null);
    //La méthode invoke exécute la méthode sur l'objet passé en paramètre
    //Pas de paramètre, donc null en deuxième paramètre de la méthode invoke !
                                
    System.out.println("----------------------------------------");
    System.out.println("Méthode " + m.getName() + " sur o2: " +m.invoke(o2, null));
    System.out.println("Méthode " + m.getName() + " sur o: " +m.invoke(o, null));
                                
  } catch (SecurityException e) {
    e.printStackTrace();
  } catch (IllegalArgumentException e) {
    e.printStackTrace();
  } catch (ClassNotFoundException e) {
    e.printStackTrace();
  } catch (InstantiationException e) {
    e.printStackTrace();
  } catch (IllegalAccessException e) {
    e.printStackTrace();
  } catch (NoSuchMethodException e) {
    e.printStackTrace();
  } catch (InvocationTargetException e) {
    e.printStackTrace();
  }
}

Et le résultat en figure suivante.

Voilà : nous venons de créer deux instances d'une classe sans passer par l'opérateur new. Mieux encore, nous avons pu appeler une méthode de nos instances ! Je ne vais pas m'attarder sur ce sujet, mais gardez en tête que cette façon de faire, quoique très lourde, pourrait vous être utile.

Sachez que certains frameworks (ensemble d'objets offrant des fonctionnalités pour développer) utilisent la réflexivité afin d'instancier leurs objets (je pense notamment à des frameworks basés sur des fichiers de configuration XML tels que Hibernate, Struts, Spring…). L'utilité de ceci vous semble-t-elle évidente ? Même si vous ne savez pas les utiliser, peut-être avez-vous déjà entendu parler de ces frameworks Java.

Maintenant, vous n'allez pas utiliser ce genre de technique tous les jours. Cependant, il est possible que vous ayez besoin, pour une raison quelconque, de stocker le nom d'une classe Java dans une base de données afin, justement, de pouvoir l'utiliser plus tard. Dans ce cas, lorsque votre base de données vous fournira le nom de la classe en question, vous pourrez la manipuler dynamiquement.

• Lorsque votre JVM interprète votre programme, elle crée automatiquement un objet Class pour chaque classe chargée.

• Avec un tel objet, vous pouvez connaître absolument tout sur votre classe.

• L'objet Class utilise des sous-objets tels que Method, Field et Constructor qui permettent de travailler avec vos différents objets ainsi qu'avec ceux présents dans Java.

• Grâce à cet objet, vous pouvez créer des instances de vos classes Java sans utiliser new.

J'espère que cette partie vous a plu et que vous avez appris plein de bonne choses !
J'ai volontairement omis de parler des flux et des threads dans cette partie. Je préfère avoir des cas bien concrets à vous soumettre pour ça...

Bon : je sais que beaucoup d'entre vous l'attendent avec impatience, alors voici la partie sur la programmation événementielle !

L'objet JFrame

Avant de nous lancer à corps perdu dans cette partie, vous devez savoir de quoi nous allons nous servir. Dans ce cours, nous traiterons de javax.swing et de java.awt. Nous n'utiliserons pas de composants awt, nous travaillerons uniquement avec des composants swing ; en revanche, des objets issus du package awt seront utilisés afin d'interagir et de communiquer avec les composants swing. Par exemple, un composant peut être représenté par un bouton, une zone de texte, une case à cocher, etc.

Afin de mieux comprendre comment tout cela fonctionne, vous devez savoir que lorsque le langage Java a vu le jour, dans sa version 1.0, seul awt était utilisable ; swing n'existait pas, il est apparu dans la version 1.2 de Java (appelée aussi Java 2). Les composants awt sont considérés comme lourds (on dit aussi HeavyWeight) car ils sont fortement liés au système d'exploitation, c'est ce dernier qui les gère. Les composants swing, eux, sont comme dessinés dans un conteneur, ils sont dit légers (on dit aussi LightWeight) ; ils n'ont pas le même rendu à l'affichage, car ce n'est plus le système d'exploitation qui les gère. Il existe également d'autres différences, comme le nombre de composants utilisables, la gestion des bordures...

Pour toutes ces raisons, il est très fortement recommandé de ne pas mélanger les composants swing et awt dans une même fenêtre ; cela pourrait occasionner des conflits ! Si vous associez les deux, vous aurez de très grandes difficultés à développer une IHM stable et valide. En effet, swing et awt ont les mêmes fondements mais diffèrent dans leur utilisation.

Cette parenthèse fermée, nous pouvons entrer dans le vif du sujet. Je ne vous demande pas de créer un projet contenant une classe main, celui-ci doit être prêt depuis des lustres ! Pour utiliser une fenêtre de type JFrame, vous devez l'instancier, comme ceci :

import javax.swing.JFrame;
 
public class Test {
  public static void main(String[] args){       
    JFrame fenetre = new JFrame();
  }       
}

Lorsque vous exécutez ce code, vous n'obtenez rien, car par défaut, votre JFrame n'est pas visible. Vous devez donc lui dire « sois visible » de cette manière :

import javax.swing.JFrame;
 
public class Test {
  public static void main(String[] args){
    JFrame fenetre = new JFrame();
    fenetre.setVisible(true);
  }       
}

Ainsi, lorsque vous exécutez ce code, vous obtenez la figure suivante.

À toutes celles et ceux qui se disent que cette fenêtre est toute petite, je réponds : « Bienvenue dans le monde de la programmation événementielle ! » Il faut que vous vous y fassiez, vos composants ne sont pas intelligents : il va falloir leur dire tout ce qu'ils doivent faire.

Pour obtenir une fenêtre plus conséquente, il faudrait donc :

• qu'elle soit plus grande ;

• qu'elle comporte un titre (ce ne serait pas du luxe !) ;

• qu'elle figure au centre de l'écran, ce serait parfait ;

• que notre programme s'arrête réellement lorsqu'on clique sur la croix rouge, car, pour ceux qui ne l'auraient pas remarqué, le processus Eclipse tourne encore même après la fermeture de la fenêtre.

Pour chacun des éléments que je viens d'énumérer, il y a aura une méthode à appeler afin que notre JFrame sache à quoi s'en tenir. Voici d'ailleurs un code répondant à toutes nos exigences :

import javax.swing.JFrame;
 
public class Test {
  public static void main(String[] args){

    JFrame fenetre = new JFrame();
                
    //Définit un titre pour notre fenêtre
    fenetre.setTitle("Ma première fenêtre Java");
    //Définit sa taille : 400 pixels de large et 100 pixels de haut
    fenetre.setSize(400, 100);
    //Nous demandons maintenant à notre objet de se positionner au centre
    fenetre.setLocationRelativeTo(null);
    //Termine le processus lorsqu'on clique sur la croix rouge
    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    //Et enfin, la rendre visible        
    fenetre.setVisible(true);
  }       
}

Voyez le rendu de ce code en figure suivante.

Afin de ne pas avoir à redéfinir les attributs à chaque fois, je pense qu'il serait utile que nous possédions notre propre objet. Comme ça, nous aurons notre propre classe !

Pour commencer, effaçons tout le code que nous avons écrit dans notre méthode main. Créons ensuite une classe que nous allons appeler Fenetre et faisons-la hériter de JFrame. Nous allons maintenant créer notre constructeur, dans lequel nous placerons nos instructions.
Cela nous donne :

import javax.swing.JFrame;
 
public class Fenetre extends JFrame {
  public Fenetre(){
    this.setTitle("Ma première fenêtre Java");
    this.setSize(400, 500);
    this.setLocationRelativeTo(null);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);             
    this.setVisible(true);
  }
}

Ensuite, vous avez le choix : soit vous conservez votre classe contenant la méthode main et vous créez une instance de Fenetre, soit vous effacez cette classe et vous placez votre méthode main dans votre classe Fenetre. Mais dans tous les cas, vous devez créer une instance de votre Fenetre. Personnellement, je préfère placer ma méthode main dans une classe à part… Mais je ne vous oblige pas à faire comme moi ! Quel que soit l'emplacement de votre main, la ligne de code suivante doit y figurer :

Fenetre fen = new Fenetre();

Exécutez votre nouveau code, et… vous obtenez exactement la même chose que précédemment. Vous conviendrez que c'est tout de même plus pratique de ne plus écrire les mêmes instructions à chaque fois. Ainsi, vous possédez une classe qui va se charger de l'affichage de votre futur programme. Et voici une petite liste de méthodes que vous serez susceptibles d'utiliser.

Positionner la fenêtre à l'écran

Nous avons déjà centré notre fenêtre, mais vous voudriez peut-être la positionner ailleurs. Pour cela, vous pouvez utiliser la méthode setLocation(int x, int y). Grâce à cette méthode, vous pouvez spécifier où doit se situer votre fenêtre sur l'écran. Les coordonnées, exprimées en pixels, sont basées sur un repère dont l'origine est représentée par le coin supérieur gauche (figure suivante).

La première valeur de la méthode vous positionne sur l'axe x, 0 correspondant à l'origine ; les valeurs positives déplacent la fenêtre vers la droite tandis que les négatives la font sortir de l'écran par la gauche. La même règle s'applique aux valeurs de l'axe y, si ce n'est que les valeurs positives font descendre la fenêtre depuis l'origine tandis que les négatives la font sortir par le haut de l'écran.

Empêcher le redimensionnement de la fenêtre

Pour cela, il suffit d'invoquer la méthode setResizable(boolean b) : false empêche le redimensionnement tandis que true l'autorise.

Garder la fenêtre au premier plan

Il s'agit là encore d'une méthode qui prend un booléen en paramètre. Passer true laissera la fenêtre au premier plan quoi qu'il advienne, false annulera cela. Cette méthode est setAlwaysOnTop(boolean b).

Retirer les contours et les boutons de contrôle

Pour ce faire, il faut utiliser la méthode setUndecorated(boolean b).

Je ne vais pas faire le tour de toutes les méthodes maintenant, car de toute façon, nous allons nous servir de bon nombre d'entre elles très prochainement.Cependant, je suppose que vous aimeriez bien remplir un peu votre fenêtre. Je m'en doutais, mais avant il vous faut encore apprendre une bricole. En effet, votre fenêtre, telle qu'elle apparaît, vous cache quelques petites choses !

Vous pensez, et c'est légitime, que votre fenêtre est toute simple, dépourvue de tout composant (hormis les contours). Eh bien vous vous trompez ! Une JFrame est découpée en plusieurs parties superposées, comme le montre la figure suivante.

Nous avons, dans l'ordre :

• la fenêtre ;

• le RootPane (en vert), le conteneur principal qui contient les autres composants ;

• le LayeredPane (en violet), qui forme juste un panneau composé du conteneur global et de la barre de menu (MenuBar) ;

• la MenuBar (en orange), la barre de menu, quand il y en a une ;

• le content pane (en rose) : c'est dans celui-ci que nous placerons nos composants ;

• le GlassPane (en transparence), couche utilisée pour intercepter les actions de l'utilisateur avant qu'elles ne parviennent aux composants.

Pas de panique, nous allons nous servir uniquement du content pane. Pour le récupérer, il nous suffit d'utiliser la méthode getContentPane() de la classe JFrame. Cependant, nous allons utiliser un composant autre que le content pane : un JPanel dans lequel nous insérerons nos composants.

L'objet JPanel

Comme je vous l'ai dit, nous allons utiliser un JPanel, composant de type conteneur dont la vocation est d'accueillir d'autres objets de même type ou des objets de type composant (boutons, cases à cocher…).

Voici le marche à suivre :

1. Importer la classe javax.swing.JPanel dans notre classe héritée de JFrame.

2. Instancier un JPanel puis lui spécifier une couleur de fond pour mieux le distinguer.

3. Avertir notre JFrame que ce sera notre JPanel qui constituera son content pane.

Rien de bien sorcier, en somme. Qu'attendons-nous ?

import java.awt.Color; 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame {
  public Fenetre(){             
    this.setTitle("Ma première fenêtre Java");
    this.setSize(400, 100);
    this.setLocationRelativeTo(null);               
 
    //Instanciation d'un objet JPanel
    JPanel pan = new JPanel();
    //Définition de sa couleur de fond
    pan.setBackground(Color.ORANGE);        
    //On prévient notre JFrame que notre JPanel sera son content pane
    this.setContentPane(pan);               
    this.setVisible(true);
  }       
}

Vous pouvez voir le résultat à la figure suivante.

C'est un bon début, mais je vois que vous êtes frustrés car il n'y a pas beaucoup de changement par rapport à la dernière fois. Eh bien, c'est maintenant que les choses deviennent intéressantes ! Avant de vous faire utiliser des composants (des boutons, par exemple), nous allons nous amuser avec notre JPanel. Plus particulièrement avec un objet dont le rôle est de dessiner et de peindre notre composant. Ça vous tente ? Alors, allons-y !

Les objets Graphics et Graphics2D

L'objet Graphics

Nous allons commencer par l'objet Graphics.Cet objet a une particularité de taille : vous ne pouvez l'utiliser que si et seulement si le système vous l'a donné via la méthode getGraphics() d'un composant swing ! Pour bien comprendre le fonctionnement de nos futurs conteneurs (ou composants), nous allons créer une classe héritée de JPanel : appelons-la Panneau. Nous allons faire un petit tour d'horizon du fonctionnement de cette classe, dont voici le code :

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
  public void paintComponent(Graphics g){
    //Vous verrez cette phrase chaque fois que la méthode sera invoquée
    System.out.println("Je suis exécutée !"); 
    g.fillOval(20, 20, 75, 75);
  }               
}

Cette méthode est celle que l'objet appelle pour se dessiner sur votre fenêtre ; si vous réduisez cette dernière et que vous l'affichez de nouveau, c'est encore cette méthode qui est appelée pour afficher votre composant. Idem si vous redimensionnez votre fenêtre… De plus, nous n'avons même pas besoin de redéfinir un constructeur car cette méthode est appelée automatiquement !

C'est très pratique pour personnaliser des composants, car vous n'aurez jamais à l'appeler vous-mêmes : c'est automatique ! Tout ce que vous pouvez faire, c'est forcer l'objet à se repeindre ; ce n'est toutefois pas cette méthode que vous invoquerez, mais nous y reviendrons.

Vous aurez constaté que cette méthode possède un argument et qu'il s'agit du fameux objet Graphics tant convoité. Nous reviendrons sur l'instruction g.fillOval(20, 20, 75, 75), mais vous verrez à quoi elle sert lorsque vous exécuterez votre programme.

Voici maintenant notre classe Fenetre :

import javax.swing.JFrame;
 
public class Fenetre extends JFrame {
  public Fenetre(){                
    this.setTitle("Ma première fenêtre Java");
    this.setSize(100, 150);
    this.setLocationRelativeTo(null);               
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setContentPane(new Panneau());

    this.setVisible(true);
  }     
}

Exécutez votre main, vous devriez obtenir la même chose qu'à la figure suivante.

Une fois votre fenêtre affichée, étirez-la, réduisez-la… À présent, vous pouvez voir ce qu'il se passe lorsque vous interagissez avec votre fenêtre : celle-ci met à jour ses composants à chaque changement d'état ou de statut. L'intérêt de disposer d'une classe héritée d'un conteneur ou d'un composant, c'est que nous pouvons redéfinir la façon dont est peint ce composant sur la fenêtre.

Après cette mise en bouche, explorons un peu plus les capacités de notre objet Graphics. Comme vous avez pu le voir, ce dernier permet, entre autres, de tracer des ronds ; mais il possède tout un tas de méthodes plus pratiques et amusantes les unes que les autres… Nous ne les étudierons pas toutes, mais vous aurez déjà de quoi faire.

Pour commencer, reprenons la méthode utilisée précédemment : g.fillOval(20, 20, 75, 75). Si nous devions traduire cette instruction en français, cela donnerait : « Trace un rond plein en commençant à dessiner sur l'axe x à 20 pixels et sur l'axe y à 20 pixels, et fais en sorte qu'il occupe 75 pixels de large et 75 pixels de haut. »

C'est dans ce genre de cas qu'il est intéressant d'utiliser une classe héritée. Puisque nous sommes dans notre objet JPanel, nous avons accès à ses données lorsque nous le dessinons.

En effet, il existe des méthodes dans les objets composants qui retournent leur largeur (getWidth()) et leur hauteur (getHeight()). En revanche, réussir à centrer un rond dans un JPanel en toutes circonstances demande un peu de calcul mathématique de base, une pincée de connaissances et un soupçon de logique !

Reprenons notre fenêtre telle qu'elle se trouve en ce moment. Vous pouvez constater que les coordonnées de départ correspondent au coin supérieur gauche du carré qui entoure ce cercle, comme le montre la figure suivante.

Cela signifie que si nous voulons que notre cercle soit tout le temps centré, il faut que notre carré soit centré, donc que le centre de celui-ci corresponde au centre de notre fenêtre ! La figure suivante est un schéma représentant ce que nous devons obtenir.

Ainsi, le principe est d'utiliser la largeur et la hauteur de notre composant ainsi que la largeur et la hauteur du carré qui englobe notre rond ; c'est facile, jusqu'à présent…

Maintenant, pour trouver où se situe le point depuis lequel doit commencer le dessin, il faut soustraire la moitié de la largeur du composant à la moitié de celle du rond afin d'obtenir la valeur sur l'axe x, et faire de même (en soustrayant les hauteurs, cette fois) pour l'axe y. Afin que notre rond soit le plus optimisé possible, nous allons donner comme taille à notre carré la moitié de la taille de notre fenêtre ; ce qui revient, au final, à diviser la largeur et la hauteur de cette dernière par quatre. Voici le code correspondant :

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
  public void paintComponent(Graphics g){                
    int x1 = this.getWidth()/4;
    int y1 = this.getHeight()/4;                      
    g.fillOval(x1, y1, this.getWidth()/2, this.getHeight()/2);
  }       
}

Si vous testez à nouveau notre code, vous vous apercevez que notre rond est maintenant centré. Cependant, l'objet Graphics permet d'effectuer plein d'autres choses, comme peindre des ronds vides, par exemple. Sans rire ! Maintenant que vous avez vu comment fonctionne cet objet, nous allons pouvoir utiliser ses méthodes.

La méthode drawOval()

Il s'agit de la méthode qui permet de dessiner un rond vide. Elle fonctionne exactement de la même manière que la méthode fillOval(). Voici un code mettant en œuvre cette méthode :

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){                
    int x1 = this.getWidth()/4;
    int y1 = this.getHeight()/4;
    g.drawOval(x1, y1, this.getWidth()/2, this.getHeight()/2);
  }               
}

Le résultat se trouve en figure suivante.

La méthode drawRect()

Cette méthode permet de dessiner des rectangles vides. Bien sûr, son homologue fillRect() existe. Ces deux méthodes fonctionnent de la même manière que les précédentes, voyez plutôt ce code :

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){
    //x1, y1, width, height
    g.drawRect(10, 10, 50, 60);
    g.fillRect(65, 65, 30, 40);
  }               
}

Le résultat se trouve à la figure suivante.

La méthode drawRoundRect()

Il s'agit du même élément que précédemment, hormis le fait que le rectangle sera arrondi. L'arrondi est défini par la valeur des deux derniers paramètres.

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
  public void paintComponent(Graphics g){
    //x1, y1, width, height, arcWidth, arcHeight
    g.drawRoundRect(10, 10, 30, 50, 10, 10);
    g.fillRoundRect(55, 65, 55, 30, 5, 5);
  }               
}

Voyez le résultat en figure suivante.

La méthode drawLine()

Cette méthode permet de tracer des lignes droites. Il suffit de lui spécifier les coordonnées de départ et d'arrivée de la ligne. Dans ce code, je trace les diagonales du conteneur :

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
  public void paintComponent(Graphics g){
    //x1, y1, x2, y2
    g.drawLine(0, 0, this.getWidth(), this.getHeight());
    g.drawLine(0, this.getHeight(), this.getWidth(), 0);
  }               
}

Le résultat se trouve à la figure suivante.

La méthode drawPolygon()

Grâce à cette méthode, vous pouvez dessiner des polygones de votre composition. Eh oui, c'est à vous de définir les coordonnées de tous les points qui les forment ! Voici à quoi elle ressemble

drawPolygon(int[] x, int[] y, int nbrePoints);

Le dernier paramètre est le nombre de points formant le polygone. Ainsi, vous n'aurez pas besoin d'indiquer deux fois le point d'origine pour boucler votre figure : Java la fermera automatiquement en reliant le dernier point de votre tableau au premier. Cette méthode possède également son homologue pour dessiner des polygones remplis : fillPolygon().

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){
    int x[] = {20, 30, 50, 60, 60, 50, 30, 20};
    int y[] = {30, 20, 20, 30, 50, 60, 60, 50};
    g.drawPolygon(x, y, 8);

    int x2[] = {50, 60, 80, 90, 90, 80, 60, 50};
    int y2[] = {60, 50, 50, 60, 80, 90, 90, 80};
    g.fillPolygon(x2, y2, 8);
  }               
}

Voyez le résultat à la figure suivante.

Il existe également une méthode qui prend exactement les mêmes arguments mais qui, elle, trace plusieurs lignes : drawPolyline().

Cette méthode va dessiner les lignes correspondant aux coordonnées définies dans les tableaux, sachant que lorsque son indice s'incrémente, la méthode prend automatiquement les valeurs de l'indice précédent comme point d'origine. Cette méthode ne fait pas le lien entre la première et la dernière valeur de vos tableaux. Vous pouvez essayer le code précédent en remplaçant drawPolygon() par cette méthode.

La méthode drawString()

Voici la méthode permettant d'écrire du texte. Elle est très simple à utiliser : il suffit de lui passer en paramètre la phrase à écrire et de lui spécifier à quelles coordonnées commencer.

import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){
    g.drawString("Tiens ! Le Site du Zéro !", 10, 20);
  }               
}

Le résultat se trouve à la figure suivante.

Vous pouvez aussi modifier la couleur (la modification s'appliquera également pour les autres méthodes) et la police d'écriture. Pour redéfinir la police d'écriture, vous devez créer un objet Font. Le code suivant illustre la façon de procéder.

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
 
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){                
    Font font = new Font("Courier", Font.BOLD, 20);
    g.setFont(font);
    g.setColor(Color.red);          
    g.drawString("Tiens ! Le Site du Zéro !", 10, 20);                
  }               
}

Le résultat correspond à la figure suivante.

La méthode drawImage()

Voici à quoi elle ressemble :

drawImage(Image img, int x, int y, Observer obs);

Vous devez charger votre image grâce à trois objets :

• un objet Image ;

• un objet ImageIO ;

• un objet File.

Vous allez voir que l'utilisation de ces objets est très simple. Il suffit de déclarer un objet de type Image et de l'initialiser en utilisant une méthode statique de l'objet ImageIO qui, elle, prend un objet File en paramètre. Ça peut sembler compliqué, mais vous allez voir que ce n'est pas le cas… Notre image sera stockée à la racine de notre projet, mais ce n'est pas une obligation. Dans ce cas, faites attention au chemin d'accès de votre image.

En ce qui concerne le dernier paramètre de la méthode drawImage, il s'agit de l'objet qui est censé observer l'image. Ici, nous allons utiliser notre objet Panneau, donc this.

import java.awt.Graphics;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){
    try {
      Image img = ImageIO.read(new File("images.jpg"));
      g.drawImage(img, 0, 0, this);
      //Pour une image de fond
      //g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
    } catch (IOException e) {
      e.printStackTrace();
    }                
  }               
}

Les résultats se trouvent aux deux figures suivantes (pour bien vous montrer la différence, j'ai créé une fenêtre plus grande que l'image).

L'objet Graphics2D

Ceci est une amélioration de l'objet Graphics, et vous allez vite comprendre pourquoi.

Pour utiliser cet objet, il nous suffit en effet de caster l'objet Graphics en Graphics2D (Graphics2D g2d = (Graphics2D) g), et de ne surtout pas oublier d'importer notre classe qui se trouve dans le package java.awt. L'une des possibilités qu'offre cet objet n'est autre que celle de peindre des objets avec des dégradés de couleurs. Cette opération n'est pas du tout difficile à réaliser : il suffit d'utiliser un objet GradientPaint et une méthode de l'objet Graphics2D.

Nous n'allons pas reprendre tous les cas que nous avons vus jusqu'à présent, mais juste deux ou trois afin que vous voyiez bien la différence. Commençons par notre objet GradientPaint ; voici comment l'initialiser (vous devez mettre à jour vos imports en ajoutant import java.awt.GradientPaint) :

GradientPaint gp = new GradientPaint(0, 0, Color.RED, 30, 30, Color.cyan, true);

Alors, que signifie tout cela ? Voici le détail du constructeur utilisé dans ce code :

• premier paramètre : la coordonnée x où doit commencer la première couleur ;

• deuxième paramètre : la coordonnée y où doit commencer la première couleur ;

• troisième paramètre : la première couleur ;

• quatrième paramètre : la coordonnée x où doit commencer la seconde couleur ;

• cinquième paramètre : la coordonnée y où doit commencer la seconde couleur ;

• sixième paramètre : la seconde couleur ;

• septième paramètre : le booléen indiquant si le dégradé doit se répéter.

Ensuite, pour utiliser ce dégradé dans une forme, il faut mettre à jour notre objet Graphics2D, comme ceci :

import java.awt.Color;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  public void paintComponent(Graphics g){
    Graphics2D g2d = (Graphics2D)g;         
    GradientPaint gp = new GradientPaint(0, 0, Color.RED, 30, 30, Color.cyan, true);                
    g2d.setPaint(gp);
    g2d.fillRect(0, 0, this.getWidth(), this.getHeight());                
  }               
}

Les deux figures suivantes représentent les résultats obtenus, l'un avec le booléen à true, et l'autre à false.

Votre dégradé est oblique (rien ne m'échappe, à moi :-p). Ce sont les coordonnées choisies qui influent sur la direction du dégradé. Dans notre exemple, nous partons du point de coordonnées (0, 0) vers le point de coordonnées (30, 30). Pour obtenir un dégradé vertical, il suffit d'indiquer la valeur de la seconde coordonnée x à 0, ce qui correspond à la figure suivante.

Voici un petit cadeau :

import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D; 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
  public void paintComponent(Graphics g){
    Graphics2D g2d = (Graphics2D)g;
    GradientPaint gp, gp2, gp3, gp4, gp5, gp6; 
    gp = new GradientPaint(0, 0, Color.RED, 20, 0, Color.magenta, true);
    gp2 = new GradientPaint(20, 0, Color.magenta, 40, 0, Color.blue, true);
    gp3 = new GradientPaint(40, 0, Color.blue, 60, 0, Color.green, true);
    gp4 = new GradientPaint(60, 0, Color.green, 80, 0, Color.yellow, true);
    gp5 = new GradientPaint(80, 0, Color.yellow, 100, 0, Color.orange, true);
    gp6 = new GradientPaint(100, 0, Color.orange, 120, 0, Color.red, true);

    g2d.setPaint(gp);
    g2d.fillRect(0, 0, 20, this.getHeight());               
    g2d.setPaint(gp2);
    g2d.fillRect(20, 0, 20, this.getHeight());
    g2d.setPaint(gp3);
    g2d.fillRect(40, 0, 20, this.getHeight());
    g2d.setPaint(gp4);
    g2d.fillRect(60, 0, 20, this.getHeight());
    g2d.setPaint(gp5);
    g2d.fillRect(80, 0, 20, this.getHeight());
    g2d.setPaint(gp6);
    g2d.fillRect(100, 0, 40, this.getHeight());
  }               
}

Maintenant que vous savez utiliser les dégradés avec des rectangles, vous savez les utiliser avec toutes les formes. Je vous laisse essayer cela tranquillement chez vous.

• Pour créer des fenêtres, Java fournit les composants swing (dans javax.swing) et awt (dans java.awt).

• Il ne faut pas mélanger les composants swing et awt.

• Une JFrame est constituée de plusieurs composants.

• Par défaut, une fenêtre a une taille minimale et n'est pas visible.

• Un composant doit être bien paramétré pour qu'il fonctionne à votre convenance.

• L'objet JPanel se trouve dans le package javax.swing.

• Un JPanel peut contenir des composants ou d'autres conteneurs.

• Lorsque vous ajoutez un JPanel principal à votre fenêtre, n'oubliez pas d'indiquer à votre fenêtre qu'il constituera son content pane.

• Pour redéfinir la façon dont l'objet est dessiné sur votre fenêtre, vous devez utiliser la méthode paintComponent() en créant une classe héritée.

• Cette méthode prend en paramètre un objet Graphics.

• Cet objet doit vous être fourni par le système.

• C'est lui que vous allez utiliser pour dessiner dans votre conteneur.

• Pour des dessins plus évolués, vous devez utiliser l'objet Graphics2D qui s'obtient en effectuant un cast sur l'objet Graphics.

Création de l'animation

Voici un résumé de ce que nous avons déjà codé :

• une classe héritée de JFrame ;

• une classe héritée de JPanel avec laquelle nous faisons de jolis dessins. Un rond, en l'occurrence.

En utilisant ces deux classes, nous allons pouvoir créer un effet de déplacement.
Vous avez bien lu : j'ai parlé d'un effet de déplacement ! Le principe réside dans le fait que vous allez modifier les coordonnées de votre rond et forcer votre objet Panneau à se redessiner. Tout cela - vous l'avez déjà deviné - dans une boucle.

Jusqu'à présent, nous avons utilisé des valeurs fixes pour les coordonnées du rond, mais il va falloir dynamiser tout ça. Nous allons donc créer deux variables privées de type int dans la classe Panneau : appelons-les posX et posY. Dans l'animation sur laquelle nous allons travailler, notre rond viendra de l'extérieur de la fenêtre. Partons du principe que celui-ci a un diamètre de cinquante pixels : il faut donc que notre panneau peigne ce rond en dehors de sa zone d'affichage. Nous initialiserons donc nos deux variables d'instance à « -50 ». Voici le code de notre classe Panneau :

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class Panneau extends JPanel {
  private int posX = -50;
  private int posY = -50;

  public void paintComponent(Graphics g){
    g.setColor(Color.red);
    g.fillOval(posX, posY, 50, 50);
  }

  public int getPosX() {
    return posX;
  }

  public void setPosX(int posX) {
    this.posX = posX;
  }

  public int getPosY() {
    return posY;
  }

  public void setPosY(int posY) {
    this.posY = posY;
  }        
}

Il ne nous reste plus qu'à faire en sorte que notre rond se déplace. Nous allons devoir trouver un moyen de changer ses coordonnées grâce à une boucle. Afin de gérer tout cela, ajoutons une méthode privée dans notre classe Fenetre que nous appellerons en dernier lieu dans notre constructeur. Voici donc ce à quoi ressemble notre classe Fenetre :

import java.awt.Dimension; 
import javax.swing.JFrame;
 
public class Fenetre extends JFrame{
  private Panneau pan = new Panneau();

  public Fenetre(){        
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    this.setContentPane(pan);
    this.setVisible(true);
    go();
  }

  private void go(){
    for(int i = -50; i < pan.getWidth(); i++){
      int x = pan.getPosX(), y = pan.getPosY();
      x++;
      y++;
      pan.setPosX(x);
      pan.setPosY(y);
      pan.repaint();  
      try {
        Thread.sleep(10);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }       
}

Vous vous demandez sûrement l'utilité des deux instructions à la fin de la méthode go(). La première de ces deux nouvelles instructions est pan.repaint(). Elle demande à votre composant, ici un JPanel, de se redessiner.

La toute première fois, dans le constructeur de notre classe Fenetre, votre composant avait invoqué la méthode paintComponent() et avait dessiné un rond aux coordonnées que vous lui aviez spécifiées. La méthode repaint() ne fait rien d'autre qu'appeler à nouveau la méthode paintComponent() ; mais puisque nous avons changé les coordonnées du rond par le biais des accesseurs, la position de celui-ci sera modifiée à chaque tour de boucle.

La deuxième instruction, Thread.sleep(), est un moyen de suspendre votre code. Elle met en attente votre programme pendant un laps de temps défini dans la méthode sleep() exprimé en millièmes de seconde (plus le temps d'attente est court, plus l'animation est rapide). Thread est en fait un objet qui permet de créer un nouveau processus dans un programme ou de gérer le processus principal.

Dans tous les programmes, il y a au moins un processus : celui qui est en cours d'exécution. Vous verrez plus tard qu'il est possible de diviser certaines tâches en plusieurs processus afin de ne pas perdre du temps et des performances. Pour le moment, sachez que vous pouvez effectuer des pauses dans vos programmes grâce à cette instruction :

try{
  Thread.sleep(1000); //Ici, une pause d'une seconde
}catch(InterruptedException e) {
  e.printStackTrace();
}

Maintenant que la lumière est faite sur cette affaire, exécutez ce code, vous obtenez la figure suivante.

Bien sûr, cette image est le résultat final : vous devez avoir vu votre rond bouger. Sauf qu'il a laissé une traînée derrière lui… L'explication de ce phénomène est simple : vous avez demandé à votre objet Panneau de se redessiner, mais il a également affiché les précédents passages de votre rond ! Pour résoudre ce problème, il faut effacer ces derniers avant de redessiner le rond.

Comment ? Dessinez un rectangle de n'importe quelle couleur occupant toute la surface disponible avant de peindre votre rond. Voici le nouveau code de la classe Panneau :

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
  private int posX = -50;
  private int posY = -50;

  public void paintComponent(Graphics g){
    //On choisit une couleur de fond pour le rectangle
    g.setColor(Color.white);
    //On le dessine de sorte qu'il occupe toute la surface
    g.fillRect(0, 0, this.getWidth(), this.getHeight());
    //On redéfinit une couleur pour le rond
    g.setColor(Color.red);
    //On le dessine aux coordonnées souhaitées
    g.fillOval(posX, posY, 50, 50);
  }

  public int getPosX() {
    return posX;
  }

  public void setPosX(int posX) {
    this.posX = posX;
  }

  public int getPosY() {
    return posY;
  }

  public void setPosY(int posY) {
    this.posY = posY;
  }
}

la figure suivante représente l'animation à différents moments.

Cela vous plairait-il que votre animation se poursuive tant que vous ne fermez pas la fenêtre ? Oui ? Alors, continuons.

Améliorations

Voici l'un des moments délicats que j'attendais. Si vous vous rappelez bien ce que je vous ai expliqué sur le fonctionnement des boucles, vous vous souvenez de mon avertissement à propos des boucles infinies. Eh bien, ce que nous allons faire ici, c'est justement utiliser une boucle infinie.

Il existe plusieurs manières de réaliser une boucle infinie : vous avez le choix entre une boucle for, while ou do… while. Regardez ces déclarations :

//Exemple avec une boucle while
while(true){
  //Ce code se répétera à l'infini, car la condition est toujours vraie !
}
 
//Exemple avec une boucle for
for(;;)
{
  //Idem que précédemment : il n'y a pas d'incrémentation donc la boucle ne se terminera jamais.
}
 
//Exemple avec do… while
do{
  //Encore une boucle que ne se terminera pas.
}while(true);

Nous allons donc remplacer notre boucle finie par une boucle infinie dans la méthode go() de l'objet Fenetre. Cela donne :

private void go(){
  for(;;){
    int x = pan.getPosX(), y = pan.getPosY();
    x++;
    y++;
    pan.setPosX(x);
    pan.setPosY(y);
    pan.repaint();  
    try {
      Thread.sleep(10);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

Si vous avez exécuté cette nouvelle version, vous vous êtes rendu compte qu'il reste un problème à régler… En effet, notre rond ne se replace pas à son point de départ une fois qu'il a atteint l'autre côté de la fenêtre !

Le premier objectif est bien atteint, mais il nous reste à résoudre ce dernier problème. Pour cela, il faut réinitialiser les coordonnées du rond lorsqu'elles atteignent le bout de notre composant. Voici donc notre méthode go() revue et corrigée :

private void go(){
  for(;;){
    int x = pan.getPosX(), y = pan.getPosY();
    x++;
    y++;
    pan.setPosX(x);
    pan.setPosY(y);
    pan.repaint();  
    try {
      Thread.sleep(10);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    //Si nos coordonnées arrivent au bord de notre composant
    //On réinitialise
    if(x == pan.getWidth() || y == pan.getHeight()){
      pan.setPosX(-50);
      pan.setPosY(-50);
    }
  }
}

Ce code fonctionne parfaitement (en tout cas, comme nous l'avons prévu), mais avant de passer au chapitre suivant, nous pouvons encore l'améliorer. Nous allons maintenant rendre notre rond capable de détecter les bords de notre Panneau et de ricocher sur ces derniers !

Jusqu'à présent, nous n'attachions aucune importance au bord que notre rond dépassait. Cela est terminé ! Dorénavant, nous séparerons le dépassement des coordonnées posX et posY de notre Panneau.

Voici la marche à suivre :

• si la valeur de la coordonnée x du rond est inférieure à la largeur du composant et que le rond avance, on continue d'avancer ;

• sinon, on recule.

Nous allons faire de même pour la coordonnée y.

Comment savoir si l'on doit avancer ou reculer ? Grâce à un booléen, par exemple. Au tout début de notre application, deux booléens seront initialisés à false, et si la coordonnée x est supérieure à la largeur du Panneau, on recule ; sinon, on avance. Idem pour la coordonnée y.

Voici donc le nouveau code de la méthode go() :

private void go(){
  //Les coordonnées de départ de notre rond
  int x = pan.getPosX(), y = pan.getPosY();
  //Le booléen pour savoir si l'on recule ou non sur l'axe x
  boolean backX = false;
  //Le booléen pour savoir si l'on recule ou non sur l'axe y
  boolean backY = false;

  //Dans cet exemple, j'utilise une boucle while
  //Vous verrez qu'elle fonctionne très bien
  while(true){
    //Si la coordonnée x est inférieure à 1, on avance
    if(x < 1)
      backX = false;

    //Si la coordonnée x est supérieure à la taille du Panneau moins la taille du rond, on recule
    if(x > pan.getWidth()-50)
      backX = true;

    //Idem pour l'axe y
    if(y < 1)
      backY = false;
    if(y > pan.getHeight()-50)
      backY = true;

    //Si on avance, on incrémente la coordonnée
    //backX est un booléen, donc !backX revient à écrire
    //if (backX == false)
    if(!backX)
      pan.setPosX(++x);

    //Sinon, on décrémente
    else
      pan.setPosX(--x);

    //Idem pour l'axe Y
    if(!backY)
      pan.setPosY(++y);
    else
      pan.setPosY(--y);

    //On redessine notre Panneau
    pan.repaint();

    //Comme on dit : la pause s'impose ! Ici, trois millièmes de seconde
    try {
      Thread.sleep(3);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

Exécutez l'application : le rond ricoche contre les bords du Panneau. Vous pouvez même étirer la fenêtre ou la réduire, ça marchera toujours ! On commence à faire des choses sympa, non ?

Voici le code complet du projet si vous le souhaitez :

Classe Panneau

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;

public class Panneau extends JPanel {

  private int posX = -50;
  private int posY = -50;

  public void paintComponent(Graphics g) {
    // On décide d'une couleur de fond pour notre rectangle
    g.setColor(Color.white);
    // On dessine celui-ci afin qu'il prenne tout la surface
    g.fillRect(0, 0, this.getWidth(), this.getHeight());
    // On redéfinit une couleur pour notre rond
    g.setColor(Color.red);
    // On le dessine aux coordonnées souhaitées
    g.fillOval(posX, posY, 50, 50);
  }

  public int getPosX() {
    return posX;
  }

  public void setPosX(int posX) {
    this.posX = posX;
  }

  public int getPosY() {
    return posY;
  }

  public void setPosY(int posY) {
    this.posY = posY;
  }
}

Classe Fenetre

import java.awt.Dimension;
import javax.swing.JFrame;

public class Fenetre extends JFrame {

  public static void main(String[] args) {
    new Fenetre();
  }

  private Panneau pan = new Panneau();

  public Fenetre() {
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    this.setContentPane(pan);
    this.setVisible(true);

    go();
  }

  private void go() {
    // Les coordonnées de départ de notre rond
    int x = pan.getPosX(), y = pan.getPosY();
    // Le booléen pour savoir si l'on recule ou non sur l'axe x
    boolean backX = false;
    // Le booléen pour savoir si l'on recule ou non sur l'axe y
    boolean backY = false;

    // Dans cet exemple, j'utilise une boucle while
    // Vous verrez qu'elle fonctionne très bien
    while (true) {
      // Si la coordonnée x est inférieure à 1, on avance
      if (x < 1)
        backX = false;
      // Si la coordonnée x est supérieure à la taille du Panneau moins la taille du rond, on recule
      if (x > pan.getWidth() - 50)
        backX = true;
      // Idem pour l'axe y
      if (y < 1)
        backY = false;
      if (y > pan.getHeight() - 50)
        backY = true;

      // Si on avance, on incrémente la coordonnée
      // backX est un booléen, donc !backX revient à écrire
      // if (backX == false)
      if (!backX)
        pan.setPosX(++x);
      // Sinon, on décrémente
      else
        pan.setPosX(--x);
      // Idem pour l'axe Y
      if (!backY)
        pan.setPosY(++y);
      else
        pan.setPosY(--y);

      // On redessine notre Panneau
      pan.repaint();
      // Comme on dit : la pause s'impose ! Ici, trois millièmes de seconde
      try {
        Thread.sleep(3);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

• À l'instanciation d'un composant, la méthode paintComponent() est automatiquement appelée.

• Vous pouvez forcer un composant à se redessiner en invoquant la méthode repaint().

• Pensez bien à ce que va produire votre composant une fois redessiné.

• Pour éviter que votre animation ne bave, réinitialisez le fond du composant.

• Tous les composants fonctionnent de la même manière.

• L'instruction Thread.sleep() permet d'effectuer une pause dans le programme.

• Cette méthode prend en paramètre un entier qui correspond à une valeur temporelle exprimée en millièmes de seconde.

• Vous pouvez utiliser des boucles infinies pour créer des animations.

Utiliser la classe JButton

Comme indiqué dans le titre, nous allons utiliser la classe JButton issue du package javax.swing. Au cours de ce chapitre, notre projet précédent sera mis à l'écart : oublions momentanément notre objet Panneau.

Créons un nouveau projet comprenant :

• une classe contenant une méthode main que nous appellerons Test ;

• une classe héritée de JFrame (contenant la totalité du code que l'on a déjà écrit, hormis la méthode go()), nous la nommerons Fenetre.

Dans la classe Fenetre, nous allons créer une variable d'instance de type JPanel et une autre de type JButton. Faisons de JPanel le content pane de notre Fenetre, puis définissons le libellé (on parle aussi d'étiquette) de notre bouton et mettons-le sur ce qui nous sert de content pane (en l'occurrence, JPanel).

Pour attribuer un libellé à un bouton, il y a deux possibilités :

//Possibilité 1 : instanciation avec le libellé
JButton bouton = new JButton("Mon premier bouton");

//Possibilité 2 : instanciation puis définition du libellé
JButton bouton2 = new JButton();
bouton2.setText("Mon deuxième bouton");

Il ne nous reste plus qu'à ajouter ce bouton sur notre content pane grâce à la méthode add() de l'objet JPanel. Voici donc notre code :

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Fenetre extends JFrame{
  private JPanel pan = new JPanel();
  private JButton bouton = new JButton("Mon bouton");

  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 150);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    //Ajout du bouton à notre content pane
    pan.add(bouton);
    this.setContentPane(pan);
    this.setVisible(true);
  }       
}

Voyez le résultat en figure suivante.

Je ne sais pas si vous avez remarqué, mais le bouton est centré sur votre conteneur ! Cela vous semble normal ? Ça l'est, car par défaut, JPanel gère la mise en page. En fait, il existe en Java des objets qui servent à agencer vos composants, et JPanel en instancie un par défaut.

Pour vous le prouver, je vais vous faire travailler sur le content pane de votre JFrame. Vous constaterez que pour obtenir la même chose que précédemment, nous allons être obligés d'utiliser un de ces fameux objets d'agencement.

Tout d'abord, pour utiliser le content pane d'une JFrame, il faut appeler la méthode getContentPane() : nous ajouterons nos composants au content pane qu'elle retourne. Voici donc le nouveau code :

import javax.swing.JButton;
import javax.swing.JFrame;

public class Fenetre extends JFrame{
  private JButton bouton = new JButton("Mon bouton");
       
  public Fenetre(){
    this.setTitle("Bouton");
    this.setSize(300, 150);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    //On ajoute le bouton au content pane de la JFrame
    this.getContentPane().add(bouton);
    this.setVisible(true);
  }      
}

La figure suivante montre que le résultat n'est pas du tout concluant.

Votre bouton est énorme ! En fait, il occupe toute la place disponible, parce que le content pane de votre JFrame ne possède pas d'objet d'agencement. Faisons donc un petit tour d'horizon de ces objets et voyons comment ils fonctionnent.

Positionner son composant : les layout managers

Vous allez voir qu'il existe plusieurs sortes de layout managers, plus ou moins simples à utiliser, dont le rôle est de gérer la position des éléments sur la fenêtre. Tous ces layout managers se trouvent dans le package java.awt.

L'objet BorderLayout

Le premier objet que nous aborderons est le BorderLayout. Il est très pratique si vous voulez placer vos composants de façon simple par rapport à une position cardinale de votre conteneur. Si je parle de positionnement cardinal, c'est parce que vous devez utiliser les valeurs NORTH, SOUTH, EAST, WEST ou encore CENTER. Mais puisqu'un aperçu vaut mieux qu'un exposé sur le sujet, voici un exemple à la figure suivante mettant en œuvre un BorderLayout.

Cette fenêtre est composée de cinq JButton positionnés aux cinq endroits différents que propose un BorderLayout. Voici le code de cette fenêtre :

import java.awt.BorderLayout;
import javax.swing.JButton;
import javax.swing.JFrame; 
 
public class Fenetre extends JFrame{
  public Fenetre(){
    this.setTitle("Bouton");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    //On définit le layout à utiliser sur le content pane
    this.setLayout(new BorderLayout());
    //On ajoute le bouton au content pane de la JFrame
    //Au centre
    this.getContentPane().add(new JButton("CENTER"), BorderLayout.CENTER);
    //Au nord
    this.getContentPane().add(new JButton("NORTH"), BorderLayout.NORTH);
    //Au sud
    this.getContentPane().add(new JButton("SOUTH"), BorderLayout.SOUTH);
    //À l'ouest
    this.getContentPane().add(new JButton("WEST"), BorderLayout.WEST);
    //À l'est
    this.getContentPane().add(new JButton("EAST"), BorderLayout.EAST);
    this.setVisible(true);
  }      
}

Ce n'est pas très difficile à comprendre. Vous définissez le layout à utiliser avec la méthode setLayout() de l'objet JFrame ; ensuite, pour chaque composant que vous souhaitez positionner avec add(), vous utilisez en deuxième paramètre un attribut static de la classe BorderLayout (dont la liste est citée plus haut).

Utiliser l'objet BorderLayout soumet vos composants à certaines contraintes. Pour une position NORTH ou SOUTH, la hauteur de votre composant sera proportionnelle à la fenêtre, mais il occupera toute la largeur ; tandis qu'avec WEST et EAST, ce sera la largeur qui sera proportionnelle alors que toute la hauteur sera occupée ! Et bien entendu, avec CENTER, tout l'espace est utilisé.

L'objet GridLayout

Celui-ci permet d'ajouter des composants suivant une grille définie par un nombre de lignes et de colonnes. Les éléments sont disposés à partir de la case située en haut à gauche. Dès qu'une ligne est remplie, on passe à la suivante. Si nous définissons une grille de trois lignes et de deux colonnes, nous obtenons le résultat visible sur la figure suivante.

Voici le code de cet exemple :

import java.awt.GridLayout; 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class Fenetre extends JFrame{
  public Fenetre(){
    this.setTitle("Bouton");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    //On définit le layout à utiliser sur le content pane
    //Trois lignes sur deux colonnes
    this.setLayout(new GridLayout(3, 2));
    //On ajoute le bouton au content pane de la JFrame
    this.getContentPane().add(new JButton("1"));
    this.getContentPane().add(new JButton("2"));
    this.getContentPane().add(new JButton("3"));
    this.getContentPane().add(new JButton("4"));
    this.getContentPane().add(new JButton("5"));
    this.setVisible(true);
  }      
}

Ce code n'est pas bien différent du précédent : nous utilisons simplement un autre layout manager et n'avons pas besoin de définir le positionnement lors de l'ajout du composant avec la méthode add().

Sachez également que vous pouvez définir le nombre de lignes et de colonnes en utilisant ces méthodes :

GridLayout gl = new GridLayout();
gl.setColumns(2);
gl.setRows(3);
this.setLayout(gl);

Vous pouvez aussi ajouter de l'espace entre les colonnes et les lignes.

GridLayout gl = new GridLayout(3, 2);
gl.setHgap(5); //Cinq pixels d'espace entre les colonnes (H comme Horizontal)
gl.setVgap(5); //Cinq pixels d'espace entre les lignes (V comme Vertical) 
//Ou en abrégé : GridLayout gl = new GridLayout(3, 2, 5, 5);

On obtient ainsi la figure suivante.

L'objet BoxLayout

Grâce à lui, vous pourrez ranger vos composants à la suite soit sur une ligne, soit sur une colonne. Le mieux, c'est encore un exemple de rendu (voir figure suivante) avec un code.

Voici le code correspondant :

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Fenetre extends JFrame{

  public Fenetre(){
		
    this.setTitle("Box Layout");
    this.setSize(300, 120);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    JPanel b1 = new JPanel();
    //On définit le layout en lui indiquant qu'il travaillera en ligne
    b1.setLayout(new BoxLayout(b1, BoxLayout.LINE_AXIS));
    b1.add(new JButton("Bouton 1"));

    JPanel b2 = new JPanel();
    //Idem pour cette ligne
    b2.setLayout(new BoxLayout(b2, BoxLayout.LINE_AXIS));
    b2.add(new JButton("Bouton 2"));
    b2.add(new JButton("Bouton 3"));

    JPanel b3 = new JPanel();
    //Idem pour cette ligne
    b3.setLayout(new BoxLayout(b3, BoxLayout.LINE_AXIS));
    b3.add(new JButton("Bouton 4"));
    b3.add(new JButton("Bouton 5"));
    b3.add(new JButton("Bouton 6"));

    JPanel b4 = new JPanel();
    //On positionne maintenant ces trois lignes en colonne
    b4.setLayout(new BoxLayout(b4, BoxLayout.PAGE_AXIS));
    b4.add(b1);
    b4.add(b2);
    b4.add(b3);
		
    this.getContentPane().add(b4);
    this.setVisible(true);
  }
}

Ce code est simple : on crée trois JPanel contenant chacun un certain nombre de JButton rangés en ligne grâce à l'attribut LINE_AXIS. Ces trois conteneurs créés, nous les rangeons dans un quatrième où, cette fois, nous les agençons dans une colonne grâce à l'attribut PAGE_AXIS. Rien de compliqué, vous en conviendrez, mais vous devez savoir qu'il existe un moyen encore plus simple d'utiliser ce layout : via l'objet Box. Ce dernier n'est rien d'autre qu'un conteneur paramétré avec un BoxLayout. Voici un code affichant la même chose que le précédent :

import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JFrame;

public class Fenetre extends JFrame{

  public Fenetre(){
    this.setTitle("Box Layout");
    this.setSize(300, 120);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    //On crée un conteneur avec gestion horizontale
    Box b1 = Box.createHorizontalBox();
    b1.add(new JButton("Bouton 1"));
    //Idem
    Box b2 = Box.createHorizontalBox();
    b2.add(new JButton("Bouton 2"));
    b2.add(new JButton("Bouton 3"));
    //Idem
    Box b3 = Box.createHorizontalBox();
    b3.add(new JButton("Bouton 4"));
    b3.add(new JButton("Bouton 5"));
    b3.add(new JButton("Bouton 6"));
    //On crée un conteneur avec gestion verticale
    Box b4 = Box.createVerticalBox();
    b4.add(b1);
    b4.add(b2);
    b4.add(b3);

    this.getContentPane().add(b4);
    this.setVisible(true);
  }	
}

L'objet CardLayout

Vous allez à présent pouvoir gérer vos conteneurs comme un tas de cartes (les uns sur les autres), et basculer d'un contenu à l'autre en deux temps, trois clics. Le principe est d'assigner des conteneurs au layout en leur donnant un nom afin de les retrouver plus facilement, permettant de passer de l'un à l'autre sans effort. La figure suivante est un schéma représentant ce mode de fonctionnement.

Je vous propose un code utilisant ce layout. Vous remarquerez que j'ai utilisé des boutons afin de passer d'un conteneur à un autre et n'y comprendrez peut-être pas tout, mais ne vous inquiétez pas, nous allons apprendre à réaliser tout cela avant la fin de ce chapitre. Pour le moment, ne vous attardez donc pas trop sur les actions : concentrez-vous sur le layout en lui-même.

import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Fenetre extends JFrame{

  CardLayout cl = new CardLayout();
  JPanel content = new JPanel();
  //Liste des noms de nos conteneurs pour la pile de cartes
  String[] listContent = {"CARD_1", "CARD_2", "CARD_3"};
  int indice = 0;

  public Fenetre(){
    this.setTitle("CardLayout");
    this.setSize(300, 120);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
		
    //On crée trois conteneurs de couleur différente
    JPanel card1 = new JPanel();
    card1.setBackground(Color.blue);		
    JPanel card2 = new JPanel();
    card2.setBackground(Color.red);		
    JPanel card3 = new JPanel();
    card3.setBackground(Color.green);

    JPanel boutonPane = new JPanel();
    JButton bouton = new JButton("Contenu suivant");
    //Définition de l'action du bouton
    bouton.addActionListener(new ActionListener(){
      public void actionPerformed(ActionEvent event){
        //Via cette instruction, on passe au prochain conteneur de la pile
        cl.next(content);
      }
    });
		
    JButton bouton2 = new JButton("Contenu par indice");
    //Définition de l'action du bouton2
    bouton2.addActionListener(new ActionListener(){
      public void actionPerformed(ActionEvent event){				
        if(++indice > 2)
          indice = 0;
        //Via cette instruction, on passe au conteneur correspondant au nom fourni en paramètre
        cl.show(content, listContent[indice]);
      }
    });
		
    boutonPane.add(bouton);
    boutonPane.add(bouton2);
    //On définit le layout
    content.setLayout(cl);
    //On ajoute les cartes à la pile avec un nom pour les retrouver
    content.add(card1, listContent[0]);
    content.add(card2, listContent[1]);
    content.add(card3, listContent[2]);

    this.getContentPane().add(boutonPane, BorderLayout.NORTH);
    this.getContentPane().add(content, BorderLayout.CENTER);
    this.setVisible(true);
  }	
}

La figure suivante correspond aux résultats de ce code à chaque clic sur les boutons.

L'objet GridBagLayout

Cet objet est certainement le plus difficile à utiliser et à comprendre (ce qui l'a beaucoup desservi auprès des développeurs Java). Pour faire simple, ce layout se présente sous la forme d'une grille à la façon d'un tableau Excel : vous devez positionner vos composants en vous servant des coordonnées des cellules (qui sont définies lorsque vous spécifiez leur nombre). Vous devez aussi définir les marges et la façon dont vos composants se répliquent dans les cellules... Vous voyez que c'est plutôt dense comme gestion du positionnement. Je tiens aussi à vous prévenir que je n'entrerai pas trop dans les détails de ce layout afin de ne pas trop compliquer les choses.

La figure suivante représente la façon dont nous allons positionner nos composants.

Imaginez que le nombre de colonnes et de lignes ne soit pas limité comme il l'est sur le schéma (c'est un exemple et j'ai dû limiter sa taille, mais le principe est là). Vous paramétreriez le composant avec des coordonnées de cellules, en précisant si celui-ci doit occuper une ou plusieurs d'entre elles. Afin d'obtenir un rendu correct, vous devriez indiquer au layout manager lorsqu'une ligne se termine, ce qui se fait en spécifiant qu'un composant est le dernier élément d'une ligne, et vous devriez en plus spécifier au composant débutant la ligne qu'il doit suivre le dernier composant de la précédente.

Je me doute que c'est assez flou et confus, je vous propose donc de regarder la figure suivante, qui est un exemple de ce que nous allons obtenir.

Tous les éléments que vous voyez sont des conteneurs positionnés suivant une matrice, comme expliqué ci-dessus. Afin que vous vous en rendiez compte, regardez comment le tout est rangé sur la figure suivante.

Vous pouvez voir que nous avons fait en sorte d'obtenir un tableau de quatre colonnes sur trois lignes. Nous avons positionné quatre éléments sur la première ligne, spécifié que le quatrième élément terminait celle-ci, puis nous avons placé un autre composant au début de la deuxième ligne d'une hauteur de deux cases, en informant le gestionnaire que celui-ci suivait directement la fin de la première ligne. Nous ajoutons un composant de trois cases de long terminant la deuxième ligne, pour passer ensuite à un composant de deux cases de long puis à un dernier achevant la dernière ligne.

Lorsque des composants se trouvent sur plusieurs cases, vous devez spécifier la façon dont ils s'étalent : horizontalement ou verticalement.

Le moment est venu de vous fournir le code de cet exemple, mais je vous préviens, ça pique un peu les yeux :

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Fenetre extends JFrame{

  public Fenetre(){
    this.setTitle("GridBagLayout");
    this.setSize(300, 160);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    //On crée nos différents conteneurs de couleur différente
    JPanel cell1 = new JPanel();
    cell1.setBackground(Color.YELLOW);
    cell1.setPreferredSize(new Dimension(60, 40));		
    JPanel cell2 = new JPanel();
    cell2.setBackground(Color.red);
    cell2.setPreferredSize(new Dimension(60, 40));
    JPanel cell3 = new JPanel();
    cell3.setBackground(Color.green);
    cell3.setPreferredSize(new Dimension(60, 40));
    JPanel cell4 = new JPanel();
    cell4.setBackground(Color.black);
    cell4.setPreferredSize(new Dimension(60, 40));
    JPanel cell5 = new JPanel();
    cell5.setBackground(Color.cyan);
    cell5.setPreferredSize(new Dimension(60, 40));
    JPanel cell6 = new JPanel();
    cell6.setBackground(Color.BLUE);
    cell6.setPreferredSize(new Dimension(60, 40));
    JPanel cell7 = new JPanel();
    cell7.setBackground(Color.orange);
    cell7.setPreferredSize(new Dimension(60, 40));
    JPanel cell8 = new JPanel();
    cell8.setBackground(Color.DARK_GRAY);
    cell8.setPreferredSize(new Dimension(60, 40));
		
    //Le conteneur principal
    JPanel content = new JPanel();
    content.setPreferredSize(new Dimension(300, 120));
    content.setBackground(Color.WHITE);
    //On définit le layout manager
    content.setLayout(new GridBagLayout());
		
    //L'objet servant à positionner les composants
    GridBagConstraints gbc = new GridBagConstraints();
		
    //On positionne la case de départ du composant
    gbc.gridx = 0;
    gbc.gridy = 0;
    //La taille en hauteur et en largeur
    gbc.gridheight = 1;
    gbc.gridwidth = 1;
    content.add(cell1, gbc);
    //---------------------------------------------
    gbc.gridx = 1;
    content.add(cell2, gbc);
    //---------------------------------------------
    gbc.gridx = 2;		
    content.add(cell3, gbc);		
    //---------------------------------------------
    //Cette instruction informe le layout que c'est une fin de ligne
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    gbc.gridx = 3;	
    content.add(cell4, gbc);
    //---------------------------------------------
    gbc.gridx = 0;
    gbc.gridy = 1;
    gbc.gridwidth = 1;
    gbc.gridheight = 2;
    //Celle-ci indique que la cellule se réplique de façon verticale
    gbc.fill = GridBagConstraints.VERTICAL;
    content.add(cell5, gbc);
    //---------------------------------------------
    gbc.gridx = 1;
    gbc.gridheight = 1;
    //Celle-ci indique que la cellule se réplique de façon horizontale
    gbc.fill = GridBagConstraints.HORIZONTAL;
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    content.add(cell6, gbc);
    //---------------------------------------------
    gbc.gridx = 1;
    gbc.gridy = 2;
    gbc.gridwidth = 2;
    content.add(cell7, gbc);
    //---------------------------------------------
    gbc.gridx = 3;
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    content.add(cell8, gbc);
    //---------------------------------------------
    //On ajoute le conteneur
    this.setContentPane(content);
    this.setVisible(true);		
  }
}

Vous pouvez vous rendre compte que c'est via l'objet GridBagConstraints que tout se joue. Vous pouvez utiliser ses différents arguments afin de positionner vos composants, en voici une liste :

• gridx : position en x dans la grille.

• gridy : position en y dans la grille.

• gridwidth : nombre de colonnes occupées.

• gridheight : nombre de lignes occupées.

• weightx : si la grille est plus large que l'espace demandé, l'espace est redistribué proportionnellement aux valeurs de weightx des différentes colonnes.

• weighty : si la grille est plus haute que l'espace demandé, l'espace est redistribué proportionnellement aux valeurs de weighty des différentes lignes.

• anchor : ancrage du composant dans la cellule, c'est-à-dire son alignement dans la cellule (en bas à droite, en haut à gauche…). Voici les différentes valeurs utilisables :

  • FIRST_LINE_START : en haut à gauche ;

  • PAGE_START : en haut au centre ;

  • FIRST_LINE_END : en haut à droite ;

  • LINE_START : au milieu à gauche ;

  • CENTER : au milieu et centré ;

  • LINE_END : au milieu à droite ;

  • LAST_LINE_START : en bas à gauche ;

  • PAGE_END : en bas au centre ;

  • LAST_LINE_END : en bas à droite.

• fill : remplissage si la cellule est plus grande que le composant. Valeurs possibles : NONE, HORIZONTAL, VERTICAL et BOTH.

• insets : espace autour du composant. S'ajoute aux espacements définis par les propriétés ipadx et ipady ci-dessous.

• ipadx : espacement à gauche et à droite du composant.

• ipady : espacement au-dessus et au-dessous du composant.

Dans mon exemple, je ne vous ai pas parlé de tous les attributs existants, mais si vous avez besoin d'un complément d'information, n'hésitez pas à consulter le site d'Oracle.

L'objet FlowLayout

Celui-ci est certainement le plus facile à utiliser ! Il se contente de centrer les composants dans le conteneur. Regardez plutôt la figure suivante.

On dirait bien que nous venons de trouver le layout manager défini par défaut dans les objets JPanel. Lorsque vous insérez plusieurs composants dans ce gestionnaire, il passe à la ligne suivante dès que la place est trop étroite. Voyez l'exemple de la figure suivante.

Il faut que vous sachiez que les IHM ne sont en fait qu'une imbrication de composants positionnés grâce à des layout managers. Vous allez tout de suite voir de quoi je veux parler : nous allons maintenant utiliser notre conteneur personnalisé avec un bouton. Vous pouvez donc revenir dans le projet contenant notre animation créée au cours des chapitres précédents. Le but est d'insérer notre animation au centre de notre fenêtre et un bouton en bas de celle-ci, comme le montre la figure suivante.

Voici le nouveau code de notre classe Fenetre :

import java.awt.BorderLayout;
import java.awt.Color; 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Fenetre extends JFrame{
  private Panneau pan = new Panneau();
  private JButton bouton = new JButton("mon bouton");
  private JPanel container = new JPanel();
  
  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);
    container.add(bouton, BorderLayout.SOUTH);
    this.setContentPane(container);
    this.setVisible(true);    
    go();
  }
  
  private void go(){  
    //Les coordonnées de départ de notre rond
    int x = pan.getPosX(), y = pan.getPosY();
    //Le booléen pour savoir si l'on recule ou non sur l'axe x
    boolean backX = false;
    //Le booléen pour savoir si l'on recule ou non sur l'axe y
    boolean backY = false;
    
    //Dans cet exemple, j'utilise une boucle while
    //Vous verrez qu'elle fonctionne très bien
    while(true){
      //Si la coordonnée x est inférieure à 1, on avance
      if(x < 1)backX = false;
      //Si la coordonnée x est supérieure à la taille du Panneau moins la taille du rond, on recule
      if(x > pan.getWidth()-50)backX = true;
      //Idem pour l'axe y
      if(y < 1)backY = false;
      if(y > pan.getHeight()-50)backY = true;
      
      //Si on avance, on incrémente la coordonnée
      if(!backX)
        pan.setPosX(++x);
      //Sinon, on décrémente
      else
        pan.setPosX(--x);
      //Idem pour l'axe Y
      if(!backY)
        pan.setPosY(++y);
      else
        pan.setPosY(--y);
        
      //On redessine notre Panneau
      pan.repaint();
      //Comme on dit : la pause s'impose ! Ici, trois millièmes de seconde
      try {
        Thread.sleep(3);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }    
  }  
}

• Un bouton s'utilise avec la classe JButton présente dans le package javax.swing.

• Pour ajouter un bouton dans une fenêtre, vous devez utiliser la méthode add() de son content pane.

• Il existe des objets permettant de positionner les composants sur un content pane ou un conteneur : les layout managers.

• Les layout managers se trouvent dans le package java.awt.

• Le layout manager par défaut du content pane d'un objet JFrame est le BorderLayout.

• Le layout manager par défaut d'un objet JPanel est le FlowLayout.

• Outre le FlowLayout et le BorderLayout, il existe le GridLayout, le CardLayout, le BoxLayout et le GridBagLayout. La liste n'est pas exhaustive.

• On définit un layout sur un conteneur grâce à la méthode setLayout().

Une classe Bouton personnalisée

Créons une classe héritant de javax.swing.JButton que nous appellerons Bouton et redéfinissons sa méthode paintComponent(). Vous devriez y arriver tout seuls. Cet exemple est représenté à la figure suivante :

Voici la classe Bouton de cette application :

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.swing.JButton;
  
public class Bouton extends JButton {
  private String name;
  public Bouton(String str){
    super(str);
    this.name = str;
  }
        
  public void paintComponent(Graphics g){
    Graphics2D g2d = (Graphics2D)g;
    GradientPaint gp = new GradientPaint(0, 0, Color.blue, 0, 20, Color.cyan, true);
    g2d.setPaint(gp);
    g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
    g2d.setColor(Color.white);
    g2d.drawString(this.name, this.getWidth() / 2 - (this.getWidth()/ 2 /4), (this.getHeight() / 2) + 5);
  }        
}

J'ai aussi créé un bouton personnalisé avec une image de fond, comme le montre la figure suivante.

Voyez le résultat en figure suivante.

J'ai appliqué l'image (bien sûr, ladite image se trouve à la racine de mon projet !) sur l'intégralité du fond, comme je l'ai montré lorsque nous nous amusions avec notre Panneau. Voici le code de cette classe Bouton :

import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JButton;
  
public class Bouton extends JButton{
  private String name;
  private Image img;

  public Bouton(String str){
    super(str);
    this.name = str;
    try {
      img = ImageIO.read(new File("fondBouton.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public void paintComponent(Graphics g){
    Graphics2D g2d = (Graphics2D)g;
    GradientPaint gp = new GradientPaint(0, 0, Color.blue, 0, 20, Color.cyan, true);
    g2d.setPaint(gp);
    g2d.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
    g2d.setColor(Color.black);
    g2d.drawString(this.name, this.getWidth() / 2 - (this.getWidth() / 2 /4), (this.getHeight() / 2) + 5);
  }
}

Rien de compliqué jusque-là… C'est à partir de maintenant que les choses deviennent intéressantes !

Et si je vous proposais de changer l'aspect de votre objet lorsque vous cliquez dessus avec votre souris et lorsque vous relâchez le clic ? Il existe des interfaces à implémenter qui permettent de gérer toutes sortes d'événements dans votre IHM. Le principe est un peu déroutant au premier abord, mais il est assez simple lorsqu'on a un peu pratiqué. N'attendons plus et voyons cela de plus près !

Interactions avec la souris : l'interface MouseListener

Avant de nous lancer dans l'implémentation, vous pouvez voir le résultat que nous allons obtenir sur les deux figures suivantes.

Il va tout de même falloir passer par un peu de théorie avant d'arriver à ce résultat. Pour détecter les événements qui surviennent sur votre composant, Java utilise ce qu'on appelle le design pattern observer. Je ne vous l'expliquerai pas dans le détail tout de suite, nous le verrons à la fin de ce chapitre.

Vous vous en doutez, nous devrons implémenter l'interface MouseListener dans notre classe Bouton. Nous devrons aussi préciser à notre classe qu'elle devra tenir quelqu'un au courant de ses changements d'état par rapport à la souris. Ce quelqu'un n'est autre… qu'elle-même ! Eh oui : notre classe va s'écouter, ce qui signifie que dès que notre objet observable (notre bouton) obtiendra des informations concernant les actions effectuées par la souris, il indiquera à l'objet qui l'observe (c'est-à-dire à lui-même) ce qu'il doit effectuer.

Cela est réalisable grâce à la méthode addMouseListener(MouseListener obj) qui prend un objet MouseListener en paramètre (ici, elle prendra this). Rappelez-vous que vous pouvez utiliser le type d'une interface comme supertype : ici, notre classe implémente l'interface MouseListener, nous pouvons donc utiliser cet objet comme référence de cette interface.

Voici à présent notre classe Bouton :

import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import java.io.IOException; 
import javax.imageio.ImageIO;
import javax.swing.JButton;

public class Bouton extends JButton implements MouseListener{
  private String name;
  private Image img;
  public Bouton(String str){
    super(str);
    this.name = str;
    try {
      img = ImageIO.read(new File("fondBouton.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
    //Grâce à cette instruction, notre objet va s'écouter
    //Dès qu'un événement de la souris sera intercepté, il en sera averti
    this.addMouseListener(this);
  }

  public void paintComponent(Graphics g){
    Graphics2D g2d = (Graphics2D)g;
    GradientPaint gp = new GradientPaint(0, 0, Color.blue, 0, 20, Color.cyan, true);
    g2d.setPaint(gp);
    g2d.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
    g2d.setColor(Color.black);
    g2d.drawString(this.name, this.getWidth() / 2 - (this.getWidth() /  2 /4), (this.getHeight() / 2) + 5);
  }

  //Méthode appelée lors du clic de souris
  public void mouseClicked(MouseEvent event) { }

  //Méthode appelée lors du survol de la souris
  public void mouseEntered(MouseEvent event) { }

  //Méthode appelée lorsque la souris sort de la zone du bouton
  public void mouseExited(MouseEvent event) { }

  //Méthode appelée lorsque l'on presse le bouton gauche de la souris
  public void mousePressed(MouseEvent event) { }

  //Méthode appelée lorsque l'on relâche le clic de souris
  public void mouseReleased(MouseEvent event) { }       
}

C'est en redéfinissant ces différentes méthodes présentes dans l'interface MouseListener que nous allons gérer les différentes images à dessiner dans notre objet.
Rappelez-vous en outre que même si vous n'utilisez pas toutes les méthodes d'une interface, vous devez malgré tout insérer le squelette des méthodes non utilisées (avec les accolades), cela étant également valable pour les classes abstraites.

Nous n'avons alors plus qu'à modifier notre image en fonction de la méthode invoquée. Notre objet comportera les caractéristiques suivantes :

• il aura une teinte jaune au survol de la souris ;

• il aura une teinte orangée lorsque l'on pressera le bouton gauche ;

• il reviendra à la normale si on relâche le clic.

Pour ce faire, je vous propose de télécharger les fichiers PNG dont je me suis servi (rien ne vous empêche de les créer vous-mêmes).

Télécharger les images

Voici maintenant le code de notre classe Bouton personnalisée :

import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import java.io.IOException; 
import javax.imageio.ImageIO;
import javax.swing.JButton;
  
public class Bouton extends JButton implements MouseListener{
  private String name;
  private Image img;

  public Bouton(String str){
    super(str);
    this.name = str;
    try {
      img = ImageIO.read(new File("fondBouton.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  this.addMouseListener(this);
  }

  public void paintComponent(Graphics g){
    Graphics2D g2d = (Graphics2D)g;
    GradientPaint gp = new GradientPaint(0, 0, Color.blue, 0, 20, Color.cyan, true);
    g2d.setPaint(gp);
    g2d.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
    g2d.setColor(Color.black);
    g2d.drawString(this.name, this.getWidth() / 2 - (this.getWidth() / 2 /4), (this.getHeight() / 2) + 5);
  }

  public void mouseClicked(MouseEvent event) {
    //Inutile d'utiliser cette méthode ici                      
  }

  public void mouseEntered(MouseEvent event) {
    //Nous changeons le fond de notre image pour le jaune lors du survol, avec le fichier fondBoutonHover.png
    try {
      img = ImageIO.read(new File("fondBoutonHover.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public void mouseExited(MouseEvent event) {
  //Nous changeons le fond de notre image pour le vert lorsque nous quittons le bouton, avec le fichier fondBouton.png
    try {
      img = ImageIO.read(new File("fondBouton.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public void mousePressed(MouseEvent event) {
    //Nous changeons le fond de notre image pour le jaune lors du clic gauche, avec le fichier fondBoutonClic.png
    try {
      img = ImageIO.read(new File("fondBoutonClic.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
 
  public void mouseReleased(MouseEvent event) {
    //Nous changeons le fond de notre image pour le orange lorsque nous relâchons le clic, avec le fichier fondBoutonHover.png
    try {
      img = ImageIO.read(new File("fondBoutonHover.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }               
  }       
}

Et voilà le travail ! Si vous avez enregistré mes images, elles ne possèdent probablement pas le même nom que dans mon code : vous devez alors modifier le code en fonction de celui que vous leur avez attribué ! D'accord, ça va de soi… mais on ne sait jamais.

Vous possédez dorénavant un bouton personnalisé qui réagit au passage de votre souris. Je sais qu'il y aura des « p'tits malins » qui cliqueront sur le bouton et relâcheront le clic en dehors du bouton : dans ce cas, le fond du bouton deviendra orange, puisque c'est ce qui doit être effectué vu la méthode mouseReleased(). Afin de pallier ce problème, nous allons vérifier que lorsque le clic est relâché, la souris se trouve toujours sur le bouton.

Nous avons implémenté l'interface MouseListener ; il reste cependant un objet que nous n'avons pas encore utilisé. Vous ne le voyez pas ? C'est le paramètre présent dans toutes les méthodes de cette interface : oui, c'est MouseEvent !

Cet objet nous permet d'obtenir beaucoup d'informations sur les événements. Nous ne détaillerons pas tout ici, mais nous verrons certains côtés pratiques de ce type d'objet tout au long de cette partie. Dans notre cas, nous pouvons récupérer les coordonnées x et y du curseur de la souris par rapport au Bouton grâce aux méthodes getX() et getY(). Cela signifie que si nous relâchons le clic en dehors de la zone où se trouve notre objet, la valeur retournée par la méthode getY() sera négative.

Voici le correctif de la méthode mouseReleased() de notre classe Bouton :

public void mouseReleased(MouseEvent event) {
  //Nous changeons le fond de notre image pour le orange lorsque nous relâchons le clic avec le fichier fondBoutonHover.png si la souris est toujours sur le bouton
  if((event.getY() > 0 && event.getY() < bouton.getHeight()) && (event.getX() > 0 && event.getX() < bouton.getWidth())){
    try {
      img = ImageIO.read(new File("fondBoutonHover.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  //Si on se trouve à l'extérieur, on dessine le fond par défaut
  else{
    try {
      img = ImageIO.read(new File("fondBouton.png"));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }               
}

Nous possédons à présent un bouton réactif, mais qui n'effectue rien pour le moment. Je vous propose de combler cette lacune.

Interagir avec son bouton

Déclencher une action : l'interface ActionListener

Afin de gérer les différentes actions à effectuer selon le bouton sur lequel on clique, nous allons utiliser l'interface ActionListener.

Nous n'allons pas implémenter cette interface dans notre classe Bouton mais dans notre classe Fenetre, le but étant de faire en sorte que lorsque l'on clique sur le bouton, il se passe quelque chose dans notre application : changer un état, une variable, effectuer une incrémentation… Enfin, n'importe quelle action !

Comme je vous l'ai expliqué, lorsque nous appliquons un addMouseListener(), nous informons l'objet observé qu'un autre objet doit être tenu au courant de l'événement. Ici, nous voulons que ce soit notre application (notre Fenetre) qui écoute notre Bouton, le but étant de pouvoir lancer ou arrêter l'animation dans le Panneau.

Avant d'en arriver là, nous allons faire plus simple : nous nous pencherons dans un premier temps sur l'implémentation de l'interface ActionListener. Afin de vous montrer toute la puissance de cette interface, nous utiliserons un nouvel objet issu du package javax.swing : le JLabel. Cet objet se comporte comme un libellé : il est spécialisé dans l'affichage de texte ou d'image. Il est donc idéal pour notre premier exemple !

On l'instancie et l'initialise plus ou moins de la même manière que le JButton :

JLabel label1 = new JLabel();
label1.setText("Mon premier JLabel");
//Ou encore
JLabel label2 = new JLabel("Mon deuxième JLabel");

Créez une variable d'instance de type JLabel (appelez-la label) et initialisez-la avec le texte qui vous plaît ; ajoutez-la ensuite à votre content pane en position BorderLayout.NORTH.

Le résultat se trouve en figure suivante.

Voici le code correspondant :

public class Fenetre extends JFrame {
  private Panneau pan = new Panneau();
  private Bouton bouton = new Bouton("mon bouton");
  private JPanel container = new JPanel();
  private JLabel label = new JLabel("Le JLabel");

  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);
    container.add(bouton, BorderLayout.SOUTH);
    container.add(label, BorderLayout.NORTH);

    this.setContentPane(container);
    this.setVisible(true);
    go();
  }
  //Le reste ne change pas
}

Vous pouvez voir que le texte de cet objet est aligné par défaut en haut à gauche. Il est possible de modifier quelques paramètres tels que :

• l'alignement du texte ;

• la police à utiliser ;

• la couleur du texte ;

• d'autres paramètres.

Voici un code mettant tout cela en pratique :

public Fenetre(){
  this.setTitle("Animation");
  this.setSize(300, 300);
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  this.setLocationRelativeTo(null);
 
  container.setBackground(Color.white);
  container.setLayout(new BorderLayout());
  container.add(pan, BorderLayout.CENTER);
  container.add(bouton, BorderLayout.SOUTH);
        
  //Définition d'une police d'écriture
  Font police = new Font("Tahoma", Font.BOLD, 16);
  //On l'applique au JLabel
  label.setFont(police);
  //Changement de la couleur du texte
  label.setForeground(Color.blue);
  //On modifie l'alignement du texte grâce aux attributs statiques
  //de la classe JLabel
  label.setHorizontalAlignment(JLabel.CENTER);
        
  container.add(label, BorderLayout.NORTH);
  this.setContentPane(container);
  this.setVisible(true);
  go();
}

La figure suivante donne un aperçu de ce code.

Maintenant que notre libellé se présente exactement sous la forme que nous voulons, nous pouvons implémenter l'interface ActionListener. Vous remarquerez que cette interface ne contient qu'une seule méthode !

//CTRL + SHIFT + O pour générer les imports
public class Fenetre extends JFrame implements ActionListener{
  private Panneau pan = new Panneau();
  private Bouton bouton = new Bouton("mon bouton");
  private JPanel container = new JPanel();
  private JLabel label = new JLabel("Le JLabel");

  public Fenetre(){
    //Ce morceau de code ne change pas
  }

  //Méthode qui sera appelée lors d'un clic sur le bouton
  public void actionPerformed(ActionEvent arg0) {      

  } 
}

Nous allons maintenant informer notre objet Bouton que notre objet Fenetre l'écoute. Vous l'avez deviné : ajoutons notre Fenetre à la liste des objets qui écoutent notre Bouton grâce à la méthode addActionListener(ActionListener obj) présente dans la classe JButton, donc utilisable avec la variable bouton. Ajoutons cette instruction dans le constructeur en passant this en paramètre (puisque c'est notre Fenetre qui écoute le Bouton).

Une fois l'opération effectuée, nous pouvons modifier le texte du JLabel avec la méthode actionPerformed(). Nous allons compter le nombre de fois que l'on a cliqué sur le bouton : ajoutons une variable d'instance de type int dans notre class et appelons-la compteur, puis dans la méthode actionPerformed(), incrémentons ce compteur et affichons son contenu dans notre libellé.

Voici le code de notre objet mis à jour :

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; 
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame implements ActionListener{
  private Panneau pan = new Panneau();
  private Bouton bouton = new Bouton("mon bouton");
  private JPanel container = new JPanel();
  private JLabel label = new JLabel("Le JLabel");
  //Compteur de clics
  private int compteur = 0;
  
  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
 
    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);
        
    //Nous ajoutons notre fenêtre à la liste des auditeurs de notre bouton
    bouton.addActionListener(this);
        
    container.add(bouton, BorderLayout.SOUTH);
          
    Font police = new Font("Tahoma", Font.BOLD, 16);  
    label.setFont(police);  
    label.setForeground(Color.blue);  
    label.setHorizontalAlignment(JLabel.CENTER);
    container.add(label, BorderLayout.NORTH);
    this.setContentPane(container);
    this.setVisible(true);
    go();
  }
      
  private void go(){
    //Cette méthode ne change pas
  }
 
   public void actionPerformed(ActionEvent arg0) {
    //Lorsque l'on clique sur le bouton, on met à jour le JLabel
    this.compteur++;
    label.setText("Vous avez cliqué " + this.compteur + " fois");
  }      
}

Voyez le résultat à la figure suivante.

Et nous ne faisons que commencer… Eh oui, nous allons maintenant ajouter un deuxième bouton à notre Fenetre, à côté du premier (vous êtes libres d'utiliser la classe personnalisée ou un simple JButton). Pour ma part, j'utiliserai des boutons normaux ; en effet, dans notre classe personnalisée, la façon dont le libellé est écrit dans notre bouton n'est pas assez souple et l'affichage peut donc être décevant (dans certains cas, le libellé peut ne pas être centré)…

Bref, nous possédons à présent deux boutons écoutés par notre objet Fenetre.

Voici notre nouveau code :

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Fenetre extends JFrame implements ActionListener{
  private Panneau pan = new Panneau();
  private JButton bouton = new JButton("bouton 1");
  private JButton bouton2 = new JButton("bouton 2");
  private JPanel container = new JPanel();
  private JLabel label = new JLabel("Le JLabel");
  private int compteur = 0;

  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);

    bouton.addActionListener(this);
    bouton2.addActionListener(this);

    JPanel south = new JPanel();
    south.add(bouton);
    south.add(bouton2);
    container.add(south, BorderLayout.SOUTH);

    Font police = new Font("Tahoma", Font.BOLD, 16);
    label.setFont(police);
    label.setForeground(Color.blue);
    label.setHorizontalAlignment(JLabel.CENTER);
    container.add(label, BorderLayout.NORTH);
    this.setContentPane(container);
    this.setVisible(true);
    go();
  }

  //…
}

La figure suivante illustre le résultat que nous obtenons.

À présent, le problème est le suivant : comment effectuer deux actions différentes dans la méthode actionPerformed() ?

En effet, si nous laissons la méthode actionPerformed() telle quelle, les deux boutons exécutent la même action lorsqu'on les clique. Essayez, vous verrez le résultat.

Il existe un moyen de connaître l'élément ayant déclenché l'événement : il faut se servir de l'objet passé en paramètre dans la méthode actionPerformed(). Nous pouvons exploiter la méthode getSource() de cet objet pour connaître le nom de l'instance qui a généré l'événement. Testez la méthode actionPerformed() suivante et voyez si le résultat correspond à la figure suivante.

public void actionPerformed(ActionEvent arg0) {
  if(arg0.getSource() == bouton)
    label.setText("Vous avez cliqué sur le bouton 1");

  if(arg0.getSource() == bouton2)
    label.setText("Vous avez cliqué sur le bouton 2");
}

Notre code fonctionne à merveille ! Cependant, cette approche n'est pas très orientée objet : si notre IHM contient une multitude de boutons, la méthode actionPerformed() sera très chargée. Nous pourrions créer deux objets à part, chacun écoutant un bouton, dont le rôle serait de réagir de façon appropriée pour chaque bouton ; mais si nous avions besoin de modifier des données spécifiques à la classe contenant nos boutons, il faudrait ruser afin de parvenir à faire communiquer nos objets… Pas terrible non plus.

Parler avec sa classe intérieure

En Java, on peut créer ce que l'on appelle des classes internes. Cela consiste à déclarer une classe à l'intérieur d'une autre classe. Je sais, ça peut paraître tordu, mais vous allez bientôt constater que c'est très pratique.

En effet, les classes internes possèdent tous les avantages des classes normales, de l'héritage d'une superclasse à l'implémentation d'une interface. Elles bénéficient donc du polymorphisme et de la covariance des variables. En outre, elles ont l'avantage d'avoir accès aux attributs de la classe dans laquelle elles sont déclarées !

Dans le cas qui nous intéresse, cela permet de créer une implémentation de l'interface ActionListener détachée de notre classe Fenetre, mais pouvant utiliser ses attributs. La déclaration d'une telle classe se fait exactement de la même manière que pour une classe normale, si ce n'est qu'elle se trouve déjà dans une autre classe. Nous procédons donc comme ceci :

public class MaClasseExterne{

  public MaClasseExterne(){
    //…
  }

  class MaClassInterne{
    public MaClassInterne(){
      //…
    }
  }
}

Grâce à cela, nous pourrons concevoir une classe spécialisée dans l'écoute des composants et qui effectuera un travail bien déterminé. Dans notre exemple, nous créerons deux classes internes implémentant chacune l'interface ActionListener et redéfinissant la méthode actionPerformed() :

• BoutonListener écoutera le premier bouton ;

• Bouton2Listener écoutera le second.

Une fois ces opérations effectuées, il ne nous reste plus qu'à indiquer à chaque bouton « qui l'écoute » grâce à la méthode addActionListener().

Voyez ci-dessous la classe Fenetre mise à jour.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame{
 
  private Panneau pan = new Panneau();
  private JButton bouton = new JButton("bouton 1");
  private JButton bouton2 = new JButton("bouton 2");
  private JPanel container = new JPanel();
  private JLabel label = new JLabel("Le JLabel");
  private int compteur = 0;
  
  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
 
    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);
        
    //Ce sont maintenant nos classes internes qui écoutent nos boutons 
    bouton.addActionListener(new BoutonListener());
    bouton2.addActionListener(new Bouton2Listener());
        
    JPanel south = new JPanel();
    south.add(bouton);
    south.add(bouton2);
    container.add(south, BorderLayout.SOUTH);
    Font police = new Font("Tahoma", Font.BOLD, 16);
    label.setFont(police);
    label.setForeground(Color.blue);
    label.setHorizontalAlignment(JLabel.CENTER);
    container.add(label, BorderLayout.NORTH);
    this.setContentPane(container);
    this.setVisible(true);
    go();
  }
      
  private void go(){
    //Cette méthode ne change pas
  }
      
  //Classe écoutant notre premier bouton
  class BoutonListener implements ActionListener{
    //Redéfinition de la méthode actionPerformed()
    public void actionPerformed(ActionEvent arg0) {
      label.setText("Vous avez cliqué sur le bouton 1");        
    }
  }
      
  //Classe écoutant notre second bouton
  class Bouton2Listener implements ActionListener{
    //Redéfinition de la méthode actionPerformed()
    public void actionPerformed(ActionEvent e) {
      label.setText("Vous avez cliqué sur le bouton 2");    
    }
  }      
}

Le résultat, visible à la figure suivante, est parfait.

Dorénavant, nous n'avons plus à nous soucier du bouton qui a déclenché l'événement, car nous disposons de deux classes écoutant chacune un bouton. Nous pouvons souffler un peu : une grosse épine vient de nous être retirée du pied.

Eh oui, faites le test : créez une troisième classe interne et attribuez-lui le nom que vous voulez (personnellement, je l'ai appelée Bouton3Listener). Implémentez-y l'interface ActionListener et contentez-vous d'effectuer un simple System.out.println() dans la méthode actionPerformed(). N'oubliez pas de l'ajouter à la liste des classes qui écoutent votre bouton (n'importe lequel des deux ; j'ai pour ma part choisi le premier).

Je vous écris uniquement le code ajouté :

//Les imports…

public class Fenetre extends JFrame{
  //Les variables d'instance…
  
  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);
 
    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);
        
    //Première classe écoutant mon premier bouton 
    bouton.addActionListener(new BoutonListener());
    //Deuxième classe écoutant mon premier bouton
    bouton.addActionListener(new Bouton3Listener());
        
    bouton2.addActionListener(new Bouton2Listener());
        
    JPanel south = new JPanel();
    south.add(bouton);
    south.add(bouton2);
    container.add(south, BorderLayout.SOUTH);
        
    Font police = new Font("Tahoma", Font.BOLD, 16);
    label.setFont(police);
    label.setForeground(Color.blue);
    label.setHorizontalAlignment(JLabel.CENTER);
    container.add(label, BorderLayout.NORTH);
    this.setContentPane(container);
    this.setVisible(true);
    go();
  }
 
  //…
 
  class Bouton3Listener implements ActionListener{
    //Redéfinition de la méthode actionPerformed()
    public void actionPerformed(ActionEvent e) {
      System.out.println("Ma classe interne numéro 3 écoute bien !");          
    }
  }
}

Le résultat se trouve sur la figure suivante.

Les classes internes sont vraiment des classes à part entière. Elles peuvent également hériter d'une superclasse. De ce fait, c'est presque comme si nous nous trouvions dans le cas d'un héritage multiple (ce n'en est pas un, même si cela y ressemble). Ce code est donc valide :

public class MaClasseExterne extends JFrame{

  public MaClasseExterne(){
    //...
  }

  class MaClassInterne extends JPanel{
    public MaClassInterne(){
      //…
    }
  }

  class MaClassInterne2 extends JButton{
    public MaClassInterne(){
      //…
    }
  }
}

Vous voyez bien que ce genre de classes peut s'avérer très utile.

Bon, nous avons réglé le problème d'implémentation : nous possédons deux boutons qui sont écoutés. Il ne nous reste plus qu'à lancer et arrêter notre animation à l'aide de ces boutons. Mais auparavant, nous allons étudier une autre manière d'implémenter des écouteurs et, par extension, des classes devant redéfinir les méthodes d'une classe abstraite ou d'une interface.

Les classes anonymes

Il n'y a rien de compliqué dans cette façon de procéder, mais je me rappelle avoir été déconcerté lorsque je l'ai rencontrée pour la première fois.

Les classes anonymes sont le plus souvent utilisées pour la gestion d'événements ponctuels, lorsque créer une classe pour un seul traitement est trop lourd. Rappelez-vous ce que j'ai utilisé pour définir le comportement de mes boutons lorsque je vous ai présenté l'objet CardLayout : c'étaient des classes anonymes. Pour rappel, voici ce que je vous avais amenés à coder :

JButton bouton = new JButton("Contenu suivant");
//Définition de l'action sur le bouton
bouton.addActionListener(new ActionListener(){
  public void actionPerformed(ActionEvent event){
    //Action !
  }
});

L'une des particularités de cette méthode, c'est que l'écouteur n'écoutera que ce composant. Vous pouvez vérifier qu'il n'y se trouve aucune déclaration de classe et que nous instancions une interface par l'instruction new ActionListener(). Nous devons seulement redéfinir la méthode, que vous connaissez bien maintenant, dans un bloc d'instructions ; d'où les accolades après l'instanciation, comme le montre la figure suivante.

C'est simple : procéder de cette manière revient à créer une classe fille sans être obligé de créer cette classe de façon explicite. L'héritage se produit automatiquement. En fait, le code ci-dessus revient à effectuer ceci :

class Fenetre extends JFrame{
  //…
  bouton.addActionListener(new ActionListenerBis());
  //…

  public class ActionListenerBis implements ActionListener{
    public void actionPerformed(ActionEvent event){
      //Action !
    }
  }
}

Seulement, la classe créée n'a pas de nom, l'héritage s'effectue de façon implicite ! Nous bénéficions donc de tous les avantages de la classe mère en ne redéfinissant que la méthode qui nous intéresse.

Sachez aussi que les classes anonymes peuvent être utilisées pour implémenter des classes abstraites. Je vous conseille d'effectuer de nouveaux tests en utilisant notre exemple du pattern strategy ; mais cette fois, plutôt que de créer des classes, créez des classes anonymes.

Les classes anonymes sont soumises aux mêmes règles que les classes « normales » :

• utilisation des méthodes non redéfinies de la classe mère ;

• obligation de redéfinir toutes les méthodes d'une interface ;

• obligation de redéfinir les méthodes abstraites d'une classe abstraite.

Cependant, ces classes possèdent des restrictions à cause de leur rôle et de leur raison d'être :

• elles ne peuvent pas être déclarées abstract ;

• elles ne peuvent pas non plus être déclarées static ;

• elles ne peuvent pas définir de constructeur ;

• elles sont automatiquement déclarées final : on ne peut dériver de cette classe, l'héritage est donc impossible !

Contrôler son animation : lancement et arrêt

Pour parvenir à gérer le lancement et l'arrêt de notre animation, nous allons devoir modifier un peu le code de notre classe Fenetre. Il va falloir changer le libellé des boutons de notre IHM : le premier affichera Go et le deuxième Stop. Pour éviter d'interrompre l'animation alors qu'elle n'est pas lancée et de l'animer quand elle l'est déjà, nous allons tantôt activer et désactiver les boutons. Je m'explique :

• au lancement, le bouton Go ne sera pas cliquable alors que le bouton Stop oui ;

• si l'animation est interrompue, le bouton Stop ne sera plus cliquable, mais le bouton Go le sera.

Ne vous inquiétez pas, c'est très simple à réaliser. Il existe une méthode gérant ces changements d'état :

JButton bouton = new JButton("bouton");
bouton.setEnabled(false); //Le bouton n'est plus cliquable
bouton.setEnabled(true);  //Le bouton est de nouveau cliquable

Ces objets permettent de réaliser pas mal de choses ; soyez curieux et testez-en les méthodes. Allez donc faire un tour sur le site d'Oracle : fouillez, fouinez…

L'une de ces méthodes, qui s'avère souvent utile et est utilisable avec tous ces objets (ainsi qu'avec les objets que nous verrons par la suite), est la méthode de gestion de dimension. Il ne s'agit pas de la méthode setSize(), mais de la méthode setPreferredSize(). Elle prend en paramètre un objet Dimension, qui, lui, prend deux entiers comme arguments.

Voici un exemple :

bouton.setPreferredSize(new Dimension(150, 120));

En l'utilisant dans notre application, nous obtenons la figure suivante.

Afin de bien gérer notre animation, nous devons améliorer notre méthode go(). Sortons donc de cette méthode les deux entiers dont nous nous servions afin de recalculer les coordonnées de notre rond. La boucle infinie doit dorénavant pouvoir être interrompue ! Pour réussir cela, nous allons déclarer un booléen qui changera d'état selon le bouton sur lequel on cliquera ; nous l'utiliserons comme paramètre de notre boucle.

Voyez ci-dessous le code de notre classe Fenetre.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Fenetre extends JFrame{

  private Panneau pan = new Panneau();
  private JButton bouton = new JButton("Go");
  private JButton bouton2 = new JButton("Stop");
  private JPanel container = new JPanel();
  private JLabel label = new JLabel("Le JLabel");
  private int compteur = 0;
  private boolean animated = true;
  private boolean backX, backY;
  private int x, y;

  public Fenetre(){
    this.setTitle("Animation");
    this.setSize(300, 300);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    container.setBackground(Color.white);
    container.setLayout(new BorderLayout());
    container.add(pan, BorderLayout.CENTER);
    bouton.addActionListener(new BoutonListener()); 
    bouton.setEnabled(false);
    bouton2.addActionListener(new Bouton2Listener());

    JPanel south = new JPanel();
    south.add(bouton);
    south.add(bouton2);
    container.add(south, BorderLayout.SOUTH);
    Font police = new Font("Tahoma", Font.BOLD, 16);
    label.setFont(police);
    label.setForeground(Color.blue);
    label.setHorizontalAlignment(JLabel.CENTER);
    container.add(label, BorderLayout.NORTH);
    this.setContentPane(container);
    this.setVisible(true);
    go();
  }

  private void go(){
    //Les coordonnées de départ de notre rond
    x = pan.getPosX();
    y = pan.getPosY();
    //Dans cet exemple, j'utilise une boucle while
    //Vous verrez qu'elle fonctionne très bien
    while(this.animated){
      if(x < 1)backX = false;
      if(x > pan.getWidth()-50)backX = true;          
      if(y < 1)backY = false;
      if(y > pan.getHeight()-50)backY = true;
      if(!backX)pan.setPosX(++x);
      else pan.setPosX(--x);
      if(!backY) pan.setPosY(++y);
      else pan.setPosY(--y);
      pan.repaint();

      try {
        Thread.sleep(3);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }     
  }

  class BoutonListener implements ActionListener{
    public void actionPerformed(ActionEvent arg0) {
      animated = true;
      bouton.setEnabled(false);
      bouton2.setEnabled(true);
      go();
    }
  }

  class Bouton2Listener implements ActionListener{
     public void actionPerformed(ActionEvent e) {
      animated = false;     
      bouton.setEnabled(true);
      bouton2.setEnabled(false);
    }
  }     
}

À l'exécution, vous remarquez que :

• le bouton Go n'est pas cliquable et l'autre l'est ;

• l'animation se lance ;

• l'animation s'arrête lorsque l'on clique sur le bouton Stop ;

• le bouton Go devient alors cliquable ;

• lorsque vous cliquez dessus, l'animation ne se relance pas !

Comme je l'ai expliqué dans le chapitre traitant des conteneurs, un thread est lancé au démarrage de notre application : c'est le processus principal du programme. Au démarrage, l'animation est donc lancée dans le même thread que notre objet Fenetre. Lorsque nous lui demandons de s'arrêter, aucun problème : les ressources mémoire sont libérées, on sort de la boucle infinie et l'application continue à fonctionner.

Mais lorsque nous redemandons à l'animation de se lancer, l'instruction se trouvant dans la méthode actionPerformed() appelle la méthode go() et, étant donné que nous nous trouvons à l'intérieur d'une boucle infinie, nous restons dans la méthode go() et ne sortons plus de la méthode actionPerformed().

Explication de ce phénomène

Java gère les appels aux méthodes grâce à ce que l'on appelle vulgairement la pile.

Pour expliquer cela, prenons un exemple tout bête ; regardez cet objet :

public class TestPile {
  public TestPile(){
    System.out.println("Début constructeur");
    methode1();
    System.out.println("Fin constructeur");
  }

  public void methode1(){
      System.out.println("Début méthode 1");
      methode2();
      System.out.println("Fin méthode 1");
   }
        
   public void methode2(){
    System.out.println("Début méthode 2");
    methode3();
    System.out.println("Fin méthode 2");
  }

  public void methode3(){
    System.out.println("Début méthode 3");
    System.out.println("Fin méthode 3");
  }
}

Si vous instanciez cet objet, vous obtenez dans la console la figure suivante.

Je suppose que vous avez remarqué avec stupéfaction que l'ordre des instructions est un peu bizarre. Voici ce qu'il se passe :

• à l'instanciation, notre objet appelle la méthode 1 ;

• cette dernière invoque la méthode 2 ;

• celle-ci utilise la méthode 3 : une fois qu'elle a terminé, la JVM retourne dans la méthode 2 ;

• lorsqu'elle a fini de s'exécuter, on remonte à la fin de la méthode 1, jusqu'à la dernière instruction appelante : le constructeur.

La figure suivante présente un schéma résumant la situation.

Dans notre programme, imaginez que la méthode actionPerformed() soit représentée par la méthode 2, et que notre méthode go() soit représentée par la méthode 3. Lorsque nous entrons dans la méthode 3, nous entrons dans une boucle infinie… Conséquence directe : nous ne ressortons jamais de cette méthode et la JVM ne dépile plus !

Afin de pallier ce problème, nous allons utiliser un nouveau thread. Grâce à cela, la méthode go() se trouvera dans une pile à part.

Tout simplement parce que nous ne demandons d'effectuer qu'une simple initialisation de variable dans la gestion de notre événement ! Si vous créez une deuxième méthode comprenant une boucle infinie et que vous l'invoquez lors du clic sur le bouton Stop, vous aurez exactement le même problème.

Je ne vais pas m'éterniser là-dessus, nous verrons cela dans un prochain chapitre. À présent, je pense qu'il est de bon ton de vous parler du mécanisme d'écoute d'événements, le fameux pattern observer.