Langage de Programmation - 2022

Cours de Langage de programmation, G3 Gestion Informatique, I.S.C.
–BENI
ENSEIGNEMENT SUPERIEUR ET UNIVERSITAIRE
INSTITUT SUPERIEUR DE COMMERCE DE BENI
(I.S.C.)
1
LANGAGE DE PROGRAMMATION III

(Programmation orientée Objet)
Notes illustrées d’exercices
Par
MUHINDO NGAINGAI Alphée,
-Chef de Travaux-
Contacts: +243 992 433 801 / aiglengaingai@gmail.com
ANNEE ACADEMIQUE 2021-2022
© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

Cours de Langage de programmation, G3 Gestion Informatique, I.S.C. –BENI
La prise de décision assistée par ordinateur et l'optimisation

deviennent des éléments fondamentaux de l'assistance aux activités
humaines de toutes sortes.
Bertrand Braunschweig
Songer à la source en buvant l'eau.

(Expression chinoise)

INTRODUCTION GENERALE
La programmation classique telle qu’étudiée au travers des
langages C, Pascal… définie un programme comme étant un ensemble de
données sur lesquelles agissent des procédures et des fonctions. Les
3
données constituent la partie passive du programme. Les procédures et

les fonctions constituent la partie active.
Programmer dans ce cas revenait à :
Définir un certain nombre de variables (structures, tableaux…)
Écrire des procédures pour les manipuler sans associer
explicitement les unes aux autres.
Exécuter un programme se réduit alors à appeler ces procédures dans un
ordre décrit par le séquençage des instructions et en leur fournissant les
données nécessaires à l’accomplissement de leurs tâches.
Dans cette approche données et procédure sont traitées
indépendamment les unes des autres sans tenir compte des relations
étroites qui les unissent.
Les questions qu’on peut poser dans ce cas :
1. Cette séparation (données, procédures) est-elle utile ?
2. Pourquoi privilégier les procédures sur les données (Que veut-on
faire ?) ?
3. Pourquoi ne pas considérer que les programmes sont avant tout des
ensembles objets informatiques caractérisé par les opérations
qu’ils connaissent ?
Les langages objets sont nés pour répondre à ces questions. Ils sont
fondés sur la connaissance d’une seule catégorie d’entités informatiques
: les objets.
Un objet incorpore des aspects statiques et dynamiques au sein d’une
même notion.

Avec les objets se sont les données qui deviennent prépondérantes. On

répond tout d’abord à la question « De quoi parle-t-on ? »
Un programme est constitué d’un ensemble d’objets chacun disposant
d’une partie procédures et d’une partie données. Les objets
interagissent par envoie de messages.
4
Dans le programme de cours en département de gestion informatique à

l’I.S.C. de Beni, ce cours est une suite logique de celui de langage de
programmation I et II et d'algorithmes et méthodes de programmation.
Il initie l’étudiant au nouveau paradigme de programmation :
Programmation Orientée Objet (P.O.O.).
Objectifs éducationnels
D’une façon plus précise et plus spécifique, ce cours ce veut d’amener
l’étudiant à être capable de (d’):
 Expliquer les principes et les concepts fondamentaux de la P.O.O. ;
 Appliquer les concepts de la P.O.O. en Java ;
 Créer les interfaces graphiques en Java ;
 Connecter l’interface graphique (GUI) Java à une base de données
MySQL ;
Contenu de l’enseignement
Chapitre I Introduction à la P.O.O.: Principes et Concepts en Java
Chapitre II Les interfaces graphique en Java
Chapitre III Java et les bases de données MySQL
Méthodologie, exigences et pondération du cours
1. Méthodologie
Pour atteindre nos objectifs, le cours aura les activités suivantes :
1) La présentation : un exposé couplé d’une explication illustrée.
2) La découverte : L’étudiant est requis de lire les livres de base,
d’exécuter les exemples du support et d’en faire un compte rendu

écrit. Notons que les services de l’Internet sont à sa portée pour

l’approfondissement.
3) L’interaction : Les étudiants seront repartis en groupe et doivent
interagir entre eux pour résoudre certains programmes en groupe.
Chaque membre du groupe doit démontrer sa participation au
5
débat du groupe dans les présentations orales.

2. Exigences et pondération
Les exigences de ce cours sont telles que :
 Posséder le support pédagogique et payer le droit de production
intellectuelle (caractère obligatoire) ;
 Lire régulièrement le support et exécuter les exercices et d’en
faire un compte rendu par écrit (en termes d’application);
 Etre réguliers et ponctuel au cours ;
 Participer à tous les travaux pratiques, interrogations et examens ;
 Présenter un projet de recherche en rapport avec le cours.
Le cours est pondéré de la manière suivante :
Rubriques Pourcentage Pondération
 Travaux  25%  15 points
pratiques :
 Interrogations :  8,33%  5 points
 Examen finale :  25 %  15 points
 Projet de  41,67%  25 points
recherche :
BIBLIOGRAPHIE SELECTIVE
Hugues Bersini (2014). La programmation orientée objet Cours et
exercices en UML 2. ÉDITIONS EYROLLES 61, bd Saint-
Germain 75240 Paris Cedex05
Cysboy et John-John (2011). Apprenez à programmer en Java. Disponible
sur www.siteduzero.com

Fisher, T. R. (2009). Java L'essentiel du code et des commandes. Paris:
CampusPress.
Boichat, J.-B. (2008). Apprendre Java et C++ en parallèle. Paris:
Eyrolles.
6
DELANNOY, C. (2008). Programmer en JAVA. Paris: Eyrolles.
Goncalves, A. (2008). Les cahiers du programmeur Java EE 5. Paris:
Eyrolles.
Delanoy, C. (2006). Exercices en Java. Paris: Eyrolles.
Divay, M. (2006). La programmation orientée objet en Java. Paris:
Dunod.
Divay, M. (2006). La_programmation_objet_en_java. Paris: Dunod.
Jean Michel DOUDOUX(2002). Développons en Java. Notes Inédites
Laugié, H. (2000). Java et Eclipse Développez une application Java. ENI
Editions.
Haro, C. (sd). Algorithmique Raisonner pour concevoir. Paris: ENI
Editions.
Rohaut, S. (sd). Algorithmique Techniques fondamentales de
programmation (exemples en PHP et en JAVA). Paris: ENI
Editions.
CHAPITRE I

INTRODUCTION A LA P.O.O.: PRINCIPES ET CONCEPTS EN JAVA

I.1. Introduction à la Programmation Orienté Objet
Chaque langage de programmation appartient à une « famille » de

langages définissant une approche ou une méthodologie générale de
programmation. Cette approche ou manière de programmer est 7
communément appelée « paradigme de programmation ». Il existe

plusieurs paradigmes de programmation dont nous pouvons citer la
programmation procédurale, la programmation orientée objet, etc. Il
existe des langages de programmation qui se prêtent bien à un
paradigme de programmation spécifique. Toutefois, certains
programmes, dits généralistes, peuvent accommoder plusieurs
paradigmes de programmation. VB.Net, C#, PHP et Java sont des
langages utilisant le paradigme orienté objet. A la différence des autres,
Java produit des programmes portables dont le secret réside dans sa
machine virtuelle : celle-ci assure à tous les développeurs Java qu'un
programme sera utilisable avec tous les systèmes d'exploitation sur
lesquels est installée une machine virtuelle Java. Lors de la phase de
compilation du code source, celui-ci prend une forme intermédiaire
appelée bytecode : c'est ce code qui est inintelligible pour l’ordinateur
de l‘utilisateur mais interprétable par la machine virtuelle Java. Cette
machine virtuelle porte le nom de JRE (Java Runtime Environment). Plus
besoin de se soucier des spécificités liées à tel ou tel OS (Operating
System, soit système d'exploitation) car Java produit des programmes
portables car un même programme compilé peut s‘exécuter sur ces
différents environnements. Bref, on reconnait au langage Java certaines
caractéristiques : Java est un langage interprété, ce qui signifie qu‘un
programme compilé n‘est pas directement exécutable par le système
d‘exploitation mais il doit être interprété par un autre programme,

qu‘on appelle interpréteur c’est-à-dire le source est compilé en pseudo

code puis exécuté par un interpréteur Java (la Java Virtual Machine
(JVM)). Java est indépendant de toute plate−forme cela signifie qu’il
n'y a pas de compilation spécifique pour chaque plate forme. Le code
reste indépendant de la machine sur laquelle il s'exécute. Il est possible
8
d'exécuter des programmes Java sur tous les environnements qui

possèdent une Java Virtual Machine. Cette indépendance est assurée au
niveau du code source grâce à Unicode et au niveau du byte code.
La figure suivante illustre ce fonctionnement.
Afin de simplifier la tâche de programmation, le programmeur utilise des

outils de développement (éditeur de code de codes source, débuggeurs
pour corriger le code, le compilateur pour la production du code
exédutable, …). Tous ces outils peuvent sont regrouper dans un
programme appelé IDE (Integrated Development Environment) tel que
Eclipse ou NetBeans et Visual Studio.
Dans la suite de ce cours nous utiliserons ces outils : NetBeans ou
Eclipse pour programmer en Java.

Ce chapitre est consacré à la présentation du paradigme de

programmation orientée objet en mettant en évidence les principes et
concepts fondamentaux.
La programmation orientée-objet (introduite par le langage SmallTalk)
propose une méthodologie centrée sur les données. Le programmeur
9
utilisant le paradigme orienté objet procède en deux temps :

1. d’abord il identifie un ensemble d’objets, tel que chaque objet
représente un élément qui doit être utilisé ou manipulé par le
programme, sous la forme d’ensembles de données.
2. dans un deuxième temps, que le programmeur va écrire les
traitements, en associant chaque traitement à un objet donné.
Dans ce paradigme, un objet, qui est au centre de la programmation,
peut être vu comme une entité regroupant un ensemble de données et
de méthodes (l’équivalent d’une fonction ou procédure en
programmation procédurale) de traitement.
La P.O.O.-est une méthode d’implémentation dans laquelle les
programmes sont organisés sous formes de collections coopératives
d’objets, dont chacun représente une instance d’une classe quelconque
et dont toutes les classes sont membres d’une hiérarchie de classes unis
à travers des relations d’héritage.
À la différence de la programmation procédurale, un programme écrit
dans un langage objet répartit l’effort de résolution de problèmes sur
un ensemble d’objets collaborant par envoi de messages. Chaque objet
se décrit par un ensemble d’attributs (partie statique) et un ensemble
de méthodes portant sur ces attributs (partie dynamique).
Certains de ces attributs étant l’adresse des objets avec lesquels les
premiers collaborent, il leur est possible de déléguer certaines des
tâches à leurs collaborateurs. Le tout s’opère en respectant un principe

de distribution des responsabilités on ne peut plus simple, chaque objet

s’occupant de ses propres attributs.
Lorsqu’un objet exige de s’informer ou de modifier les attributs d’un
autre, il charge cet autre de s’acquitter de cette tâche. Cette
programmation est fondamentalement distribuée, modularisée et
10
décentralisée. Pour autant qu’elle respecte également des principes de

confinement et d’accès limité (dit d’encapsulation) que nous décrirons
dans ce cours, cette répartition modulaire a également l’insigne
avantage de favoriser la stabilité des développements, en restreignant
au maximum l’impact de modifications apportées au code au cours du
temps. Ces impacts seront limités aux seuls objets qu’ils concernent et
à aucun de leurs collaborateurs, même si le comportement de ces
derniers dépend en partie des fonctionnalités affectées.
Ces améliorations, résultant de la prise de conscience des problèmes
posés par l’industrie du logiciel ces dernières années, complexité accrue
et stabilité dégradée, ont enrichi la syntaxe des langages objet. Un autre
mécanisme de modularisation inhérent à l’orienté objet est l’héritage
qui permet à la programmation de refléter l’organisation taxonomique
de notre connaissance en une hiérarchie de concepts du plus au moins
général.
À nouveau, cette organisation modulaire en objets génériques et plus
spécialistes est à l’origine d’une simplification de la programmation,
d’une économie d’écriture et de la création de zone de code aux
modifications confinées. Tant cet héritage que la répartition des tâches
entre les objets, permet tout à la fois, une décomposition plus naturelle
des problèmes, une réutilisation facilitée des codes déjà existants, et
une maintenance facilitée et allégée de ces derniers. L’orientation objet
s’impose, non pas comme une panacée universelle, mais une évolution
naturelle, au départ de la programmation procédurale, qui facilite

l’écriture de programmes, les rendant plus gérables, plus

compréhensibles, plus stables et réexploitables.
L’orienté objet inscrit la programmation dans une démarche somme
toute très classique pour affronter la complexité de quelque problème
qui soit : une découpe naturelle et intuitive en des parties plus simples.
11
A fortiori, cette découpe sera d’autant plus intuitive qu’elle s’inspire de

notre manière « cognitive » de découper la réalité qui nous entoure.
L’héritage, reflet fidèle de notre organisation cognitive, en est le
témoignage le plus éclatant. L’approche procédurale rendait cette
découpe moins naturelle, plus « forcée ». Si de nombreux adeptes de la
programmation procédurale sont en effet conscients qu’une manière
incontournable de simplifier le développement d’un programme
complexe est de le découper physiquement, ils souffrent de l’absence
d’une prise en compte naturelle et syntaxique de cette découpe dans les
langages de programmation utilisés. Dans un programme imposant,
l’Orienté Objet permet de tracer les pointillés que les ciseaux doivent
suivre là où il semble le plus naturel de les tracer : au niveau du cou,
des épaules ou de la ceinture, et non pas au niveau des sourcils, des
biceps ou des mollets. De surcroît, cette pratique de la programmation
incite à cette découpe suivant deux dimensions orthogonales :
horizontalement, les classes se déléguant mutuellement un ensemble de
services, verticalement, les classes héritant entre elles d’attributs et de
méthodes installés à différents niveaux d’une hiérarchie taxonomique.
Pour chacune de ces dimensions, reproduisant fidèlement nos
mécanismes cognitifs de conceptualisation, en plus de simplifier
l’écriture des codes, il est important de faciliter la récupération de ces
parties dans de nouveaux contextes et d’assurer la robustesse de ces
parties aux changements survenus dans d’autres. Un code Orienté Objet,

idéalement, sera aussi simple à créer qu’à maintenir, récupérer et faire

évoluer.
Il est parfaitement inconséquent d’opposer le procédural à l’Orienté
Objet car, in fine, toute programmation des méthodes (c’est-à-dire la
partie active des classes et des objets) reste totalement tributaire des
12
mécanismes procéduraux.
On y rencontre des variables, des arguments, des boucles, des arguments
de fonction, des instructions conditionnelles, tout ce que l’on trouve
classiquement dans les boîtes à outils procédurales. L’Orienté Objet ne
permet en rien de faire l’économie du procédural, simplement, il
complémente celui-ci, en lui superposant un système de découpe plus
naturel et facile à mettre en œuvre. Il n’est guère surprenant que la
plupart des langages procéduraux comme le C, Cobol ou, plus
récemment, PHP, se soient relativement aisément enrichi d’une couche
dite Orienté Objet sans que cette addition ne remette sérieusement en
question l’existant procédural. Cependant, l’impact de cette couche
additionnelle ne se limite pas à quelques structures de données
supplémentaires afin de mieux organiser les informations manipulées par
le programme. Il va bien au-delà. C’est toute une manière de concevoir
un programme et la répartition de ses parties fonctionnelles qui est en
jeu. Les fonctions et les données ne sont plus d’un seul tenant mais
éclatées en un ensemble de modules reprenant, chacun, une sous-partie
de ces données et les seules fonctions qui les manipulent. Il faut
réapprendre à programmer en s’essayant au développement d’une
succession de microprogrammes et au couplage soigné et réduit au
minimum de ces microprogrammes. En substance, la programmation
Orienté Objet pourrait reprendre à son compte ce slogan devenu très
célèbre parmi les adeptes des courants altermondialistes : « agir
localement, penser globalement ».

Pour mieux programmer dans un langage orienté objet, le programmeur

doit maîtriser les concepts clés de ce paradigme de programmation.
Exercice d’application
1. Donnez cinq avantages du paradigme de la P.O.O. ?
2. Dissociez le paradigme de programmation procédurale de l’orienté
13
Objet.
3. La programmation Orienté Objet pourrait reprendre à son compte
ce slogan : « agir localement, penser globalement ».
I.2. Principes et concepts de la P.O.O. en Java

Dans cette section, nous présentons les principaux concepts
orientés objet et les illustrons dans les langages de programmation Java.
I.2.1. Classe
Une classe est un ensemble, un groupe ou un type d‘éléments ayant
les mêmes caractéristiques et les mêmes comportements. Ces éléments
peuvent être physiques ou logiques. Pour écrire un programme avec un
langage orienté-objet, le programmeur écrit uniquement des classes
correspondant aux éléments de son système.
Une classe peut être comparée à un moule, qui, lorsque nous le
remplissons, nous donne un objet ayant la forme du moule, et toutes ses
caractéristiques. En Java, tout est classe.
Exemple
Voici quelques ensembles constituant ainsi des classes : Etudiant,
Voiture,
Véhicule, Bus, Facture, Logiciel, Bouton, Feuilles, Pages, Rectangle, …
Importance d’une classe
Une classe est une sorte de moule ou une sorte de plan ou
maquette qui permettra de créer les objets qu’on voudra.

I.2.2. Propriété
Les caractéristiques communes aux éléments d‘une classe
permettent de différencier les éléments appartenant à la classe. Elles
sont appelées « données membres » ou « propriétés ».
Les données à stocker dans un programme orienté objet sont stockées
14
dans les propriétés des classes.

Ces propriétés constituent les variables pouvant recevoir des valeurs
selon chaque élément de la classe. Chaque propriété doit avoir un nom
(court, significatif, sans espace, sans caractère spécial et différent d‘un
mot clé du langage) et un type (indiquant les valeurs qu‘elle peut
recevoir).
Les différents types de variables
Dans un langage de programmation, on rencontre deux types de
variables : des variables de type simple ou « primitif » et des variables
de type complexe qui sont des classes. Ce qu'on appelle des types
simples ou types primitifs sont des nombres entiers, des nombres réels,
des booléens ou encore des chaines de caractères.
Déclaration des variables
// Première méthode de déclaration
String phrase ;
phrase = " Joel et noel ";
// Deuxième méthode de déclaration
String str = new String ();
str = "je suis malade";
// Troisième méthode de déclaration
String string = " je suis toujours malade";
// Quatrième méthode de déclaration
String chaine = new String ("la lune de miele !");

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.
I.2.3. Méthodes
15
Les comportements appelés « méthodes », sont les traitements, les

opérations ou les réactions qu‘un élément de la classe peut réaliser sur
ses propres données et/ou sur de données extérieures à la classe.
Les traitements à effectuer dans un programme orienté objet sont
programmés dans les méthodes de ces classes qui peuvent faire appel à
des méthodes d’autres classes. Ainsi, pour chaque méthode, le
programmeur objet écrit l’algorithme correspondant.
En modélisation informatique, une classe a donc un nom, des données
membres et des méthodes. Une classe est représentée par un rectangle
séparée en trois parties :
- la première partie contient le nom de la classe
- la seconde contient les attributs de la classe
- la dernière contient les méthodes de la classe.
Conventions : Les conventions suivantes ont été adoptés en
programmation orientée objet:
 Tous les noms de classes doivent commencer par une majuscule ;
 Tous les noms de variables doivent commencer par une minuscule
ou du tiret ;
 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 ;
Exemple
Supposons que la classe Etudiant a deux données membres (Matricule et
Année de naissance) et une méthode (calcul de l’âge). Le matricule est

de type alpha numérique, l’année de naissance est du type entier et

calcul de l’âge prends un entier représentant l’année en cours en
paramètre et retourne un entier.
I.2.4. Encapsulation
L'encapsulation est la capacité à contenir un groupe d'éléments
16
associés et à en contrôler l'accès. Les classes constituent l'un des moyens

les plus courants d'encapsuler des éléments.
L‘encapsulation de données dans un objet permet de cacher ou non leur
existence aux autres objets du programme.
L’encapsulation est le faite qu’un objet renferme ses propres attributs
et ses méthodes. Les détails de l’implémentation d’un objet sont
masqués aux autres objets du système à objets. On dit qu’il ya
encapsulation de données et du comportement des objets.
On précise trois modes d’accès aux attributs d’un objet.
 Le mode public avec lequel les attributs seront accessibles
directement par l’objet lui-même ou par d’autres objets. Il s’agit
du niveau le plus bas de protection.
 Le mode private avec lequel les attributs de l’objet seront
inaccessibles à partir d’autres objets : seules les méthodes de
l’objet pourront y accéder. Il s’agit du niveau le plus fort de
protection.
 Le mode protected : cette technique de protection est
étroitement associée à la notion d’héritage (suite du cours).
I.2.5. Package
Définition

Un package est un ensemble des classes regrouper sous un nom, et

réutilisable dans d‘autres applications. Dans la plupart de langage de
programmation orientés objet, les classes d‘une application (projet) sont
automatiquement regroupés dans un package du même nom que le
projet.
17
Un langage de programmation comme java est essentiellement composé

des packages qui forme l‘interface de programmation (Application
Programmer Interface) API. En guise d‘illustration les principaux
packages qui forment java sont dans le tableau qui suit :
Package Description
java.io Gestion des entrées et sortie
java.awt Gestion des graphiques
java.lang Classe de base (par défaut n’a pas
besoin d‘être importé)
java.util Classe des utilitaires (date, heure)
Javax.swing Autres classe graphique
Utilisation
Pour utiliser les classes (les attributs et les méthodes de ces
classes) d‘un package dans une autre classe, le programmeur doit
importer ce package dans sa classe comme suit :
import nom_package.*; pour accéder à toutes les classes du package
Ou pour accéder directement à une classe spécifique
import nom_package.nom_classe ;
Utilisation des packages d’entrée et sortie (en mode console)
Pour afficher des sorties à l‘écran, on utilise la classe « System »
du package Java.lang. Comme ce package est importé par défaut lors
du lancement de NetBeans aucune importation n‘est nécéssaire pour
l‘affichage. Il suffit donc d‘utiliser la syntaxe suivante :

System.out.print(); ou
System.out.println(); // Affiche et retourne à la ligne
Le messages à afficher sont mises entre les parenthèses et concaténés
par des +.
Les messages sont entre guillemets mais pas les variables.
18
Pour que Java puisse lire ce que l‘utilisateur tape au clavier, le

programmeur peut utiliser la classe Scanner du package Java.util.
Comme ce package n‘est pas importé par défaut, le programmeur doit
d‘abord l‘importer (import Java.util.* ou import Java.util.Scanner).
Une fois que l‘importation a été faite, l‘utilisation de cette classe se fait
avec la syntaxe suivante :
1. Déclaration de la variable du type Scanner
Scanner nomduScanneur = new Scanner ( System .in);
2. Invitation de l’utilisateur à la saisie
System .out. println (" Message :"); //
3. Récuperer de l’information saisie et stockage dans la variable
La classe Scanner a plusieurs méthodes permettant de récuperer
l‘information saisie en fonction du type de la variable de stockage.
La méthode est de la forme
Next<Type de variable commençant par une majuscule>. Nous
pouvons en citer :
- nextInt() : récupérer les entiers
- nextFloat() : récupérer les réels
- nextLine() : récupérer les chaines de caractère
- …
La syntaxe de récupération de l‘information saisie est la suivante :
variable = nomduScanneur.Methode() ; //
I.2.6. Objet

Un objet est un élément spécifique de la classe. Il a donc toutes

les propriétés et toutes les méthodes définies dans la classe. C‘est une
variable (presque) comme les autres mais dont le type est la classe.
Le type d‘un objet est un type complexe (par opposition aux types
primitifs entier, caractère, …) qu‘on appelle une classe. L’objet est
19
coincé par sa classe, même s’il s’y sent parfois à l’étroit. Dans les
langages OO, la classe est le modèle à respecter stricto sensu, comme
une maison le fait du plan de l’architecte, et la robe du patron du
couturier.
En résumé, les objets contiennent des attributs et des méthodes. Les
attributs sont des variables ou des objets nécessaires au fonctionnement
de l'objet. En java, une application est un objet. La classe est la
description d'un objet. Un objet est une instance d'une classe. Pour
chaque instance d'une classe, le code est le même, seul les données sont
différentes à chaque objet.
Instanciation
Un objet est une instance (anglicisme signifiant « cas » ou «
exemple ») d‘une classe et est référencé par une variable ayant un état
(ou valeur). Pour créer un objet, il est nécessaire de déclarer une
variable dont le type est la classe à instancier puis de faire appel à un
constructeur de cette classe ou faire ces deux opérations dans une seule
instruction.
L'opérateur new se charge de créer une instance de la classe et de
l'associer à la variable
I.2.7. Méthode constructeur
Chaque classe doit définir une ou plusieurs méthodes particulières
appelées des constructeurs. Un constructeur est une méthode invoquée
lors de la création d‘un objet. Cette méthode, qui peut être vide,
effectue les opérations nécessaires à l‘initialisation d‘un objet. Chaque

constructeur doit avoir le même nom que la classe où il est défini et n‘a
aucune valeur de retour (c‘est l‘objet créé qui est renvoyé) et peut être
avec ou sans paramètres. Pour ce faire, on utilise le mot clé new.
Sommes toutes, Un constructeur est une méthode (ou méthode
d'instance, vu qu'elle interagit avec une instance de votre classe) qui va
20
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 dire à la JVM de réserver de l'allocation
mémoire pour notre futur objet et donc, par extension, d'en réserver
pour toutes les variables d'instances et variables de classes de cette
dernière !
Remarque: - 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 !
- Si le programmeur ne définit pas de constructeur, le
langage de programmation définit un constructeur par
défaut pour la classe.
- Pour référencer l‘objet « courant » (celui dans lequel se
situe la ligne de code), le langage Java fournit le mot-clé
This. Celui-ci n‘a pas besoin d‘être instancié et s‘utilise
comme une variable désignant l‘objet courant.
Syntaxe
NomClasse nomobjet ;
nomobjet =new Constructeur() ;
ou
NomClasse nomobjet=new Constructeur()
Exemple

Créons l‘objet « etud1 » à partir de la classe Etudiant en appelant le

constructeur par défaut.
Etudiant etud1 ;
etud1=new Etudant() ;
ou 21
Etudiant etud1=new Etudant() ;

Accès aux variables et aux méthodes
Pour accéder à une variable ou une méthode associée à un objet,
il faut préciser l‘objet qui la contient. Le symbole ‘.’ sert à séparer
l‘identificateur de l‘objet de l‘identificateur de la variable:
nomobjet.propriété ;
nomobjet.méthode(valeurs des paramètres) ;
Pour qu‘un tel appel soit possible, il faut que trois conditions soient
remplies:
La propriété (variable) ou la méthode appelée existe.
Une variable désignant l‘objet visé existe et soit instanciée.
L‘objet, au sein duquel est fait cet appel, ait le droit d‘accéder à
la méthode ou à la variable
Implémentation d’une classe en Java
Avant de commencer, vous devez savoir que tous les programmes Java
sont composés d'au moins une classe.
Cette classe doit contenir une méthode main. Celle-ci est la méthode
principale du programme, c'est elle que la JVM va chercher afin de lancer
votre programme. Pour faire court, c'est le point de départ du
programme. (Vous voyez donc son importance !). Autrement dit, une
classe ne peut être exécutée que si elle contient une méthode main()
correctement définie.
Rappelons qu’une classe est une collection d’éléments ayant les
propriétés et méthodes communes. Les propriétés étant de données

membres de la classe, elles doivent être déclarées en spécifiant le type

de données à stocker.
Et pour qu'on se comprenne bien, une méthode est une suite
d'instructions à exécuter. Une méthode contient :
- un entête : celle-ci va être un peu comme la carte d'identité de la
22
méthode. Nous y reviendrons.

- un corps : le contenu de la méthode, en fait, l’algorithme
délimité par des accolades {}.
- une valeur de retour : le résultat que la méthode va retourner.
SAUF pour les méthodes de type void qui ne renvoient rien.
Allons à la pratique, par cet exemple :
Supposons que la classe Etudiant a deux données membres (Matricule
et Année de naissance) et une méthode (calcul de l’âge). Le matricule
est de type alpha numérique, l’année de naissance est du type entier et
calcul de l’âge prends une entier représentant l’année en cours en
paramètre et retourne un entier.
Les étapes à suivre sont les suivantes :
1. Créez un programme avec votre IDE et nommez-le ClassePrincipale
: File/New/Java project. C’est cette classe principale qui contient
la méthode main.
2. Ajoutez la classe « Etudiant» en procédant comme suit :
Fichier(File)/Nouveau Fichier (New File)/Java/JavaClass
Vous obtenez :
package classeprincipale;
public class Etudiant {

//les propriétés
String matricule;
int anneeNaissance;

//la méthode
int calculAge(int anneeCours){
return anneeCours-this.anneeNaissance;
}
23
}
Vous constatez la présence du mot clé public qui s’ajoute par défaut.
C’est le principe d’encapsulation (nous y reviendrons dans les lignes
suivantes). A fait, Une variable, méthode ou classe déclarée public est
visible par tous les autres objets.
Utilisation de méthodes « constructeurs » en Java
A titre de rappel, la déclaration d'un objet est suivie d'une sorte
d'initialisation par le moyen d'une méthode particulière appelée
constructeur pour que les variables aient une valeur de départ. Elle n'est
systématiquement invoquée que lors de la création d'un objet.
Le constructeur suit la définition des autres méthodes excepté que son
nom doit obligatoirement correspondre à celui de la classe et qu'il n'est
pas typé, pas même void, donc il ne peut pas y avoir d'instruction return
dans un constructeur. On peut surcharger un constructeur. La définition
d'un constructeur est facultative. Si elle n'est pas définie, la machine
virtuelle appelle un constructeur par défaut vide créé automatiquement.
Dès qu'un constructeur est explicitement défini, Java considère que le
programmeur prend en charge la création des constructeurs et que le
mécanisme par défaut, qui correspond à un constructeur sans
paramètres, est supprimé. Si on souhaite maintenir ce mécanisme, il faut
définir explicitement un constructeur sans paramètres.
Une classe peut contenir plusieurs constructeurs. Ceux-ci doivent porter
le nom de la classe et être distincts par leurs arguments (nombre et/ou
types).

Syntaxe Java
public NomClasse()
{ //Constructeur par defaut
this.Propriété1=valeur1;
this.Propriété2=valeur2 ;
24
…
this.Propriétén=valeurn
}
ou on peut créer le constructeur parametré comme ceci:
public NomClasse(type param1,type param2,…,type paramn) {
this.propriété1 = param1;
this.propriété2 = param2;
…
this.propriétén = paramn;
}
Exemple Pratique:
Ajoutons les constructeurs (par défaut ainsi que celui avec
paramètre) pour la classe Etudiant, créée précédemment. On obtient :
public class Etudiant {
//les proprietes
String matricule;
int anneeNaissance;
//la methode
int calculAge(int anneeCours){
return anneeCours-this.anneeNaissance;
}
/*Les méthodes constructeurs
* ****************************

*/
//Constructeur par défaut
public Etudiant(){
this.matricule="";
this.anneeNaissance=2019;
25
}
//Constructeur paramétré
public Etudiant(String mat,int an){
this.matricule=mat;
this.anneeNaissance=an;
}
}
L’opération d’Instanciation
Rappelons que l’instanciation est l’opération par laquelle on crée
des objets à partir d’une classe. Pour ce faire, il est nécessaire de
déclarer une variable dont le type est la classe à instancier puis de faire
appel à un constructeur de cette classe ou faire ces deux opérations dans
une seule instruction.
La syntaxe est :
NomClasse NomObj=new NomConstructeur
Cas pratique : créons un objet « Etudiant » ayant le matricule Y.1458/18
et est né en 1985. Le programme devra afficher son âge sur l’exécution
de la méthode « calculAge » en fonction d’une année considérée comme
année en cours (2000). Sous forme d’un message du type : « Votre
matricule est : Y.1458/18 et en 2000 vous aviez 15 ans. » Pour ce faire,
rendez vous dans la méthode principale (main) de la classe principale,
et appelez le constructeur paramétré comme ceci :
public class ClassePrincipale {

public static void main(String[] args) {

// TODO code application logic here
Etudiant unEtudiant=new Etudiant("Y.1458/18 ",1985);
System.out.println("Vos coordonnees\nVotre matricule est
:"+unEtudiant.matricule+" et en 2000 vous aviez
26
"+unEtudiant.calculAge(2000)+" ans");
}
Il y a lieu de spécifier l’année en cours comme année système c’est-à-
dire l’année récupéré à partir de l’ordinateur sur lequel le script
s’exécute. Pour ce faire, utilisez la méthode now de la classe Year du
package java.time (à importer en cas de nécessité) comme suit :
Year.now().getValue(); ou LocalDate.now.getYear() ;
Il est aussi possible d’instancier le constructeur par défaut, c’est-à-dire
les parenthèses resterons vides sans paramètres. En retenant 2019
comme année en cours, vous obtenez ceci :
//Etudiant unEtudiant=new Etudiant("Y.1458/18 ",1985);
Etudiant unEtudiant=new Etudiant();
System.out.println("Vos coordonnees\nVotre matricule est
:"+unEtudiant.matricule+" et vous avez "+unEtudiant.calculAge(2019)+"
ans");

}
Vous constatez que le matricule est vide et l’âge retourné est 0 ans
I.2.8. Héritage
La notion d’héritage est une relation entre différentes classes
permettant de définir une nouvelle classe en se basant sur les classes
27
existantes. On parle d’héritage simple lorsqu’une classe fille ne possède

qu’une classe mère.
L'héritage est un mécanisme qui facilite la réutilisation du code et la
gestion de son évolution.
Grace à l'héritage, les objets d'une classe ont accès aux données et aux
méthodes de la classe parent et peuvent les étendre. Les sous classes
peuvent redéfinir les variables et les méthodes héritées. Pour les
variables, il suffit de les redéclarer sous le même nom avec un type
différent. Les méthodes sont redéfinies avec le même nom, les mêmes
types et le même nombre d'arguments, sinon il s'agit d'une surcharge.
L'héritage successif de classes permet de définir une hiérarchie de classe
qui ce compose de super classes et de sous classes. Une classe qui hérite
d'une autre est une sous classe et celle dont elle hérite est une super
classe. Une classe peut avoir plusieurs sous classes. Une classe ne peut
avoir qu'une seule classe mère : il n'y a pas d'héritage multiple en java.
Object est la classe parente de toutes les classes en java. Toutes les
variables et méthodes contenues dans Object sont accessibles à partir
de n'importe quelle classe car par héritage succéssif toutes les classes
héritent d'Object.
On peut imaginer une classe de base Véhicule (un véhicule désigne
un engin à roues) et une classe dérivée Automobile. La classe Automobile
constitue une spécialisation (par son moteur notamment) de la classe
Véhicule. Une automobile a les caractéristiques générales d’un véhicule
mais aussi des caractéristiques propres à une automobile.

Une classe VoitureFormuleUn pourrait être une classe dérivée

d’Automobile : une voiture de course a, en effet, les caractéristiques
d’une automobile classique (un volant, quatre roues, etc.) mais aussi des
caractéristiques propres à une voiture de course.
Dans la classe dérivée, on peut ajouter de nouvelles méthodes et
28
de nouveaux champs (par exemple Cylindrée pour la classe Automobile,

ce qui n’aurait pas de sens dans une classe aussi générale que Véhicule).
On peut également déclarer des champs et des méthodes qui portent le
même nom que dans la classe mère. Cette technique est très utilisée car
elle permet de modifier le comportement des classes de base.
Pour invoquer une méthode d'une classe parent, il suffit d'indiquer la
méthode préfixée par super. Pour appeler le constructeur de la classe
parent il suffit d'écrire super(paramètres) avec les paramètres
adéquats. Pour dire à un programme que la classe fille hérite de la
classe mère, on utilise extends en Java.
Le lien entre une classe fille et une classe parent est géré par le langage
: une évolution des règles de gestion de la classe parent conduit à
modifier automatiquement la classe fille dès que cette dernière est
recompilée.
En java, il est obligatoire dans un constructeur d'une classe fille de faire
appel explicitement ou implicitement au constructeur de la classe mère.
Les variables et méthodes définies avec le modificateur d'accès
public restent publiques à travers l'héritage et toutes les autres classes.
Une variable d'instance définie avec le modificateur private est bien
héritée mais elle n'est pas accessible directement mais via les méthodes
héritées. Si l'on veut conserver pour une variable d'instance une
protection semblable à celle assurée par le modificateur private, il faut
utiliser le modificateur protected. La variable ainsi définie sera héritée

dans toutes les classes descendantes qui pourront y accéder librement

mais ne sera pas accessible hors de ces classes directement.
En modélisation informatique, la relation d’héritage est représentée par
une flèche fermée (triangle) du côté de la super classe :
Des conseils pratiques sur l'héritage
29
Lors de la création d'une classe « mère » il faut tenir compte des points
suivants :
- la définition des accès aux variables d'instances, très souvent
privées, doit être réfléchie entre protected et private
- pour empêcher la redéfinition d'une méthode (surcharge) il faut
la déclarer avec le modificateur final
Lors de la création d'une classe fille, pour chaque méthode héritée qui
n'est pas final, il faut envisager les cas suivant :
- la méthode héritée convient à la classe fille : on ne doit pas la
redéfinir
- la méthode héritée convient mais partiellement du fait de la
spécialisation apportée par la classe fille : il faut la redéfinir voir
la surcharger. La plupart du temps une redéfinition commencera
par appeler la méthode héritée (via super) pour garantir
l’évolution du code
- la méthode héritée ne convient pas : il faut redéfinir ou surcharger
la méthode sans appeler la méthode héritée lors de la redéfinition.
Exemple Pratique :
Soit la classe Personne et la classe Etudiant. Un étudiant est
d’abord une personne. Donc la classe Etudiant hérite toutes les
caractéristiques et tous les comportements de la classe Personne au quel
elle ajoute les autres attributs et méthodes spécifiques. Une personne
est caractérisée par un nom, un post nom, une adresse, un genre et une
année de naissance. Si la classe Etudiant hérite de la classe Personne

alors on dira qu’un étudiant est une personne, donc a automatiquement

un nom, une adresse, un genre et une année de naissance. En plus de
caractéristiques héritées, un étudiant a un matricule, une promotion et
une option. Ces dernières caractéristiques sont spécifiques à la classe
Etudiant, car ce n’est pas toute personne qui est étudiant. On pourra
30
calculer l’âge de la personne et le montant total de frais à payer par

l’étudiant.
Résolution :
1. classe mère (la super classe : Personne)
import java.time.Year;
/**
*
* @author NGAINGAI
*/
public class Personne {
/*Les propriétés
* *****************
*/
public String nom;
public String postnom;
public String adresse;
public String genre;
public int anneeNaiss;
/*Les méthodes
* ******************
*/
//1. methode pour calculer l'age
public int calculAge(int anneeEnCours) {

return anneeEnCours - this.anneeNaiss;

}
//2. constructeur par defaut
public Personne()
{
31
this.nom = "Nouveau";
this.postnom = "Nouveau";
this.adresse = "Nouveau";
this.genre = "Masculin";
this.anneeNaiss =Year.now().getValue();
}
//3.Constructeur avec parametres
public Personne(String sonNom, String sonPostNom,String
sonAdresse, String sonGenre, int sonAnnee){
this.nom = sonNom;
this.postnom = sonPostNom;
this.adresse = sonAdresse;
this.genre = sonGenre;
this.anneeNaiss = sonAnnee;
}
//4. methode afficher la personne
public void afficher(){
System.out.println("Le nom est "+this.nom+"\nLe postnom
est:"+this.postnom+"\nVotre adresse:"+this.adresse+"\nVous etes du
genre:"+this.genre+"\nL'annee de naissance est "+this.anneeNaiss+"\n
Donc vous etes age de "+this.calculAge(2019)+" ans");
}
}

2. classe fille (la classe dérivée :Etudiant) qui hérite de la classe

Personne
/**
*
32
* @author NGAINGAI
*/
public class Etudiant extends Personne {
//les proprietes
String matricule;
String promotion;
String option;
/*Les méthodes
* **********************
*/
//1. méthode pour trouver le total de frais à payer
public int payer()
{
int tot = 0;
if (this.option.equals("Sciences commerciales"))
{
if (this.promotion.equals("G1") ||
this.promotion.equals("G2") || this.promotion.equals("G3"))
tot = 280;
else
tot = 380;
}
else
{
if (this.promotion.equals("G1") ||
this.promotion.equals("G2") || this.promotion.equals("G3"))
tot = 300;
else
tot = 400;
}
return tot;
}
//Constructeur
public Etudiant(String pn, String psn,String pad, String pgr, int
pan, String mat, String prom, String opt){
super(pn,psn, pad, pgr, pan);

this.matricule = mat;
this.promotion = prom;
this.option = opt;
}
System.out.println("Le matricule est "+this.matricule+"\nLe
33
nom est "+super.nom+"\nLe postnom est:"+super.postnom+"\nVotre
adresse:"+super.adresse+"\nVous etes du genre
"+super.genre+"\nVous etes inscrit en:"+this.promotion+"
"+this.option+"\nL'annee est "+super.anneeNaiss+" Donc vous etes
Age de "+super.calculAge(2019)+" ans");
}
}
3. Instanciation des classes pour affichage : dans la classe

principale (main)
/**
* @author NGAINGAI
*/
/**
* @param args the command line arguments
*/
//Instanciation d'une personne
Personne pers=new Personne("SOKI", "NGANZULE","NTONY",
"FEMININ", 1996);
//Instanciation d'un etudiant
Etudiant unEtudiant=new Etudiant("SOKI",
"NGANZULE","NTONY", "FEMININ", 1996, "X.2456/17", "G3", "GI");
//affichage de la personne
pers.afficher();
//affichage de l'etudiant
unEtudiant.afficher();

}
Découvrez le résultat !
Vous venez de constater que toutes les deux classes ont une méthode
« afficher » mais qui ne s’appelle pas de la même manière selon que
l’on veut afficher une personne ou un étudiant. C’est la notion du
polymorphisme.
34
I.2.9. Polymorphisme
Il est possible de donner le même nom à deux méthodes différentes
à condition que les signatures de ces deux méthodes soient différentes.
La signature d'une méthode comprend le nom de la classe, le nom de la
méthode et les types des paramètres. Cette facilité permet de mettre
en œuvre le polymorphisme.
Le terme polymorphisme issu du grec signifie la faculté de prendre
plusieurs formes. Une entité est polymorphe si à l’exécution elle peut
se référer à des instances de classe différentes. Le polymorphisme est
un mécanisme qui permet à une sous classe de redéfinir une méthode
dont elle a hérité tout en gardant la même signature de la méthode.
La signature d’une méthode représente la précision de son nom, du
type de ses arguments et du type de donnée retournée. Toutefois, le
polymorphisme est une surcharge d’une méthode. En effet, Plusieurs
méthodes sont généralement déclarées dans une classe et certaines
d’entre elles peuvent porter le même nom. Elles doivent alors se
distinguer par le nombre ou le type de leurs arguments. On parle alors
de « surcharge » de méthode (overloading en anglais). Deux méthodes
d’une même classe ne peuvent cependant pas porter le même nom,
accepter les mêmes arguments et être seulement distinctes par le type
de la valeur de retour.
La surcharge facilite l'utilisation des propriétés ou des méthodes, car elle
propose un choix de divers types de données disponibles. Au moment de
l'exécution, Java appelle la procédure correcte en fonction des types de
données des paramètres spécifiés.

Le polymorphisme est la capacité, pour un même message de

correspondre à plusieurs formes de traitements selon l'objet auquel ce
message est adressé. La gestion du polymorphisme est assurée par la
machine virtuelle dynamiquement à l'exécution
Illustration : soit une classe Nageur ayant comme attributs nom et type
35
et deux autres classes Personne et Poisson héritant de la classe Nageur.

Les deux (Personne et Poisson) ne nagent pas de la même façon, d’où il
faut définir deux méthodes nager ()
La redéfinition d'une méthode héritée doit impérativement conserver la
déclaration de la méthode parent (type et nombre de paramètres, la
valeur de retour et les exceptions propagées doivent être identique).
Si la signature de la méthode change, ce n'est plus une redéfinition mais
une surcharge. Cette nouvelle méthode n'est pas héritée : la classe mère
ne possède pas de méthode possédant cette signature.
Exemple pratique :
A. Dans l’illustration des notions sur l’héritage, vous avez constaté
que toutes les deux classes ont une méthode « afficher » mais qui
ne s’appelle pas de la même manière selon que l’on veut afficher
une personne ou un étudiant. C’est la redéfinition de la méthode.
Il est temps de voir comment on peut surcharger une méthode.
B. Créons tout de suite dans la classe étudiant un constructeur
surchargé pour vous monter ce que cela implique:
//les proprietes
String matricule;

String promotion;
String option;
/*Les méthodes
* **********************
*/
36

public int payer()
{
int tot = 0;
{
if (this.promotion.equals("G1") || this.promotion.equals("G2") ||
this.promotion.equals("G3"))
tot = 280;
else
tot = 380;
}
else
{
tot = 300;
else
tot = 400;
}
return tot;
}
//Constructeurs
public Etudiant(){

super.nom = "";
super.postnom = "";
super.adresse = "";
super.genre = "Masculin";
super.anneeNaiss =Year.now().getValue();
37
this.matricule = "";
this.promotion = "G1";
this.option = "Sciences commerciales";
}
public Etudiant(String pn, String psn,String pad, String pgr, int pan,
String mat, String prom, String opt){
this.option = opt;
}
System.out.println("Le matricule est "+this.matricule+"\nLe nom est
"+super.nom+"\nLe postnom est:"+super.postnom+"\nVotre
adresse:"+super.adresse+"\nVous etes du genre "+super.genre+"\nVous
etes inscrit en:"+this.promotion+" "+this.option+"\nL'annee est
"+super.anneeNaiss+" Donc vous etes Age de "+super.calculAge(2019)+"
ans\nVotre montant total de frais a payer est de "+this.payer() +" $");
}
}
Ici j'ai donc déclaré dans ma classe Etudiant, 2 constructeurs différents,
j'ai donc surchargé le constructeur. Deux fonctions avec des arguments
de type différent apportent aussi une surcharge.

Pour surcharger une méthode de la classe mère, la technique est presque

la même. Il va juste falloir rajouter le mot clé @Override devant la
méthode de la classe fille.
L'annotation @Override doit être utilisée lorsqu'une méthode redéfinit
la méthode de la super classe. Celle-ci existe dans la classe mère mais
38
on redéfinit son contenu dans la classe fille.

Cependant Eclipse rajoute automatiquement cette annotation, mais, si
vous redéfinissez une méthode d'une classe mère manuellement, vous
pouvez l'ajouter vous même, tout en sachant que ceci n'est pas
obligatoire !
/**
*
* @author NGAINGAI
*/
//les proprietes
String matricule;
String promotion;
String option;
/*Les méthodes
* **********************
*/
public int payer()
{
int tot = 0;

{
tot = 280;
39
else
tot = 380;
}
else
{
tot = 300;
else
tot = 400;
}
return tot;
}
//Constructeurs
public Etudiant(){
super.nom = "";
super.postnom = "";
super.adresse = "";
}

40
this.option = opt;
}
@Override
System.out.println("-----------------AFFICHAGE DE L'ETUDIANT----------
----\nLe matricule est "+this.matricule+"\nLe nom est "+super.nom+"\nLe
postnom est:"+super.postnom+"\nVotre
adresse:"+super.adresse+"\nVous etes du genre "+super.genre+"\nVous
etes inscrit en:"+this.promotion+" "+this.option+"\nL'annee est
"+super.anneeNaiss+" Donc vous etes Age de "+super.calculAge(2019)+"
ans\nVotre montant total de frais a payer est de "+this.payer() +" $");
}
}
I.2.10. Les Interfaces (Il ne s'agit pas ici d'interfaces graphiques...)
Avec l'héritage multiple, une classe peut hériter en même temps
de plusieurs super classes. Ce mécanisme n'existe pas en java. Les
interfaces permettent de mettre en œuvre un mécanisme de
remplacement.
Une interface est un ensemble de constantes et de déclarations de
méthodes correspondant un peu à une classe abstraite. C'est une sorte
de standard auquel une classe peut répondre. Tous les objets qui se
conforment à cette interface (qui implémentent cette interface)
possèdent les méthodes et les constantes déclarées dans celle−ci.

Plusieurs interfaces peuvent être implémentées dans une même classe.

Rappelons qu’une classe abstraite est une classe ne pouvant pas être
instanciée, autrement dit on ne peut pas créer d’objets à partir de ce
moule. Elle sert à créer des classes dérivées, en clair, cette classe va
seulement servir de base (une classe mère) pour des classes qui vont lui
41
dériver.
Les trois rôles que ces interfaces sont appelées à jouer : forcer
l’implémentation de leurs méthodes, permettre le multihéritage,
faciliter et stabiliser la décomposition de l’application logicielle.
Les interfaces se déclarent avec le mot clé interface et sont intégrées
aux autres classes avec le mot clé implements. Une interface est
implicitement déclarée avec le modificateur abstract.
Toutes les méthodes d'une interface sont publiques et abstraites : elles
sont implicitement déclarées comme telles.
Une interface peut être d'accès public ou package. Si elle est publique,
toutes ses méthodes sont publiques même si elles ne sont pas déclarées
avec le modificateur public. Si elle est d'accès package, il s'agit d'une
interface d'implémentation pour les autres classes du package et ses
méthodes ont le même accès package : elles sont accessible à toutes les
classes du packages.
Les seules variables que l'on peut définir dans une interface sont des
variables de classe qui doivent être constantes : elles sont donc
implicitement déclarées avec le modificateur static et final même si
elles sont définies avec d'autres modificateurs.
Le mot clé static
Le mot clé static s'applique aux variables et aux méthodes. Les
variables d'instance sont des variables propres à un objet. Il est possible
de définir une variable de classe qui est partagée entre toutes les
instances d'une même classe : elle n'existe donc qu'une seule fois en

mémoire. Une telle variable permet de stocker une constante ou une

valeur modifiée tour à tour par les instances de la classe. Elle se définit
avec le mot clé static.
Le mot clé final
Le mot clé final s'applique aux variables de classe ou d'instance ou
42
locales, aux méthodes, aux paramètres d'une méthode et aux classes. Il

permet de rendre l'entité sur laquelle il s'applique non modifiable une
fois qu'elle est déclarée pour une méthode ou une classe et initialisée
pour une variable.
Une variable qualifiée de final signifie que la valeur de la variable ne
peut plus être modifiée une fois que celle ci est initialisée.
Toute classe qui implémente cette interface doit au moins posséder les
méthodes qui sont déclarées dans l'interface.
L'interface ne fait que donner une liste de méthodes qui seront à définir
dans les classes qui implémentent l'interface.
Les méthodes déclarées dans une interface publique sont implicitement
publiques et elles sont héritées par toutes les classes qui implémentent
cette interface. Une telle classe doit, pour être instanciable, définir
toutes les méthodes héritées de l'interface.
Une classe peut implémenter une ou plusieurs interfaces tout en
héritant de sa classe mère.
L'implémentation d'une interface définit un cast : l'implémentation d'une
interface est une forme d'héritage. Comme pour l'héritage d'une classe,
l'héritage d'une classe qui implémente une interface définit un cast
implicite de la classe fille vers cette interface. Il est important de noter
que dans ce cas il n'est possible de faire des appels qu'à des méthodes
de l'interface. Pour utiliser des méthodes de l'objet, il faut définir un
cast explicite : il est préférable de contrôler la classe de l'objet pour
éviter une exception ClassCastException à l'exécution.

NB : Lorsque vous implémentez une ou plusieurs interfaces, vous DEVEZ

OBLIGATOIREMENT redéfinir leurs méthodes !
En résumé :
- Une interface est une classe 100 % abstraite.
- Toutes les méthodes d'une interface n'ont pas de corps.
- Une interface sert à définir un super type et à utiliser le 43
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 les
interfaces) dans votre classe.
Déclaration d'une interface :
[public] interface nomInterface [extends nomInterface1, nomInterface2
... ] {
// insérer ici des méthodes ou des champs static
}
Implémentation d'une interface :
Modificateurs class nomClasse [extends superClasse]
[implements nomInterface1, nomInterface 2, ...] {
//insérer ici des méthodes et des champs
}
Pour ajouter une nouvelle interface java, suivez la procédure suivante :
menu fichier\Nouveau Fichier puis sélectionner Java Interface. Enfin
cliquez le bouton suivant, dans l’écran suivant donnez le nom de
l’interface et cliquez le bouton terminer.
Exemple pratique
Nous créons deux interfaces :
1. Une interface pour salutation

package essaieinterface;
/**
*
* @author NGAINGAI
*/
44
public interface salutaion {

public void saluer();
}
2. Une interface qui retourne un texte
/**
*
* @author NGAINGAI
*/
public interface AfficherType {
public String afficher();
}
Implémentons ces interfaces dans la classe essaie :
/**
*
* @author NGAINGAI
*/
public class Essaie implements salutaion,AfficherType{
String nom;
public Essaie(String n){
this.nom=n;
}
public Essaie(){

}
public void saluer(){
System.out.println("Bonjour mes amis");
}
public String afficher(){
45
String msg="Je vous aime"+this.nom;

return msg;
}
}
3. Test dans la méthode main
/**
*
* @author NGAINGAI
*/
public class EssaieInterface {
/**
*/
Essaie test=new Essaie(" Alphee "); //Instanciation de la classe
salutaion sal=new Essaie();//polymorphisme
sal.saluer();//Avec cette référence, vous pouvez utiliser de façon
polymorphe les méthodes de l'interface salutaion
//test.saluer();
System.out.println(test.afficher());

}
I.1.11. Les accesseurs et les mutateurs
Un accesseur est une méthode qui va nous permettre d'accéder aux
46
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. Un accesseur est une méthode qui va nous permettre
d’accéder aux variables de nos objets en lecture et un mutateur, en
écriture. Pour question de convention de nommage, les accesseurs
commencent par get et les mutateurs par set. On parle d’ailleurs de
Getters et de Setters.
Exemple d’utilisation des setters et getters
Soit la classe Ville définie comme suit :
public class Ville{
String nomVille;
String nomPays;
int nbreHabitants;
}
1. Ajoutons le constructeur par défaut :
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;

public Ville(){
System.out.println("Création d'une ville !");
nomVille = "Inconnu";
nomPays = "Inconnu";
nbreHabitants = 0;
47
}
}
2. Ajoutons le constructeur avec paramètres
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;
public Ville(){
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;
48
}
}
3. Ajoutons les Accesseurs et mutateurs :

//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)
49
{
nomPays = pPays;
}
//Définit le nombre d'habitants
public void setNombreHabitants(int nbre)
{
nbreHabitants = nbre;
}
}
4. À présent, testez 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");
//Affichage des villes
System.out.println("\n v = "+v.getNom()+" ville de
"+v.getNombreHabitants()+ " habitants se situant en "+v.getNomPays());
/*
Nous allons maintenant modifier 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");
Utilisation de la classe Scanner
50
A titre de rappel, pour que Java puisse lire ce que l‘utilisateur tape
au clavier, le programmeur peut utiliser la classe Scanner du package
Java.util. Comme ce package n‘est pas importé par défaut, le
programmeur doit d‘abord l‘importer (import Java.util.* ou import
Java.util.Scanner). Une fois que l‘importation a été faite, l‘utilisation
de cette classe se fait avec la syntaxe suivante :
1. Déclaration de la variable du type Scanner
Scanner nomduScanneur = new Scanner ( System .in);
2. Invitation de l’utilisateur à la saisie
System .out. println (" Message :"); //
3. Récuperer de l’information saisie et stockage dans la variable
La classe Scanner a plusieurs méthodes permettant de récuperer
l‘information saisie en fonction du type de la variable de stockage.
La méthode est de la forme
Next<Type de variable commençant par une majuscule>. Nous
pouvons en citer :
- nextInt() : récupérer les entiers
- nextFloat() : récupérer les réels
- nextLine() : récupérer les chaines de caractère
- …
La syntaxe de récupération de l‘information saisie est la suivante :
variable = nomduScanneur.Methode() ; //
Exemple suivant met en œuvre la méthode saisir dans la classe Etudiant:

/**
*
* @author NGAINGAI
*/
51
import java.util.Scanner; //Importation de la classe Scanner à partir du

package java.util
//les proprietes
String matricule;
String promotion;
String option;
/*Les méthodes
* **********************
*/
public int payer()
{
int tot = 0;
{
tot = 280;
else
tot = 380;
}
else

{
tot = 300;
else
52
tot = 400;
}
return tot;
}
//Constructeurs
public Etudiant(){
super.nom = "";
super.postnom = "";
super.adresse = "";
}
this.option = opt;
}
/*Les accesseurs et les mutateurs

*************************************
*/
//accesseur pour retourne le matricule
public String getMatricule(){ return this.matricule;}
//accesseur pour retourne le nom
53
public String getNom(){ return this.nom;}

//accesseur pour retourne le postnom
public String getPostNom(){ return this.postnom;}
//accesseur pour retourne l'adresse
public String getAdresse(){ return this.adresse;}
//accesseur pour retourne le genre
public String getGenre(){ return this.genre;}
public int getAnneeNaissance(){ return this.anneeNaiss;}
//accesseur pour retourne la promotion
public String getPromotion(){ return this.promotion;}
//accesseur pour retourne l'option
public String getOption(){return this.option;}
//mutateur pour definir le matricule
public void setMatricule(String mat){this.matricule=mat;}
//mutateur pour definir le nom
public void setNom(String n){this.nom=n;}
//mutateur pour definir le postnom
public void setPostNom(String pn){this.postnom=pn;}
//mutateur pour definir l'adresse
public void setAdresse(String ad){this.adresse=ad;}
//mutateur pour definir le genre
public void setGenre(String gr){this.genre=gr;}
//mutateur pour definir l'annee de naissance
public void setAnneeNaissance(int an){this.anneeNaiss=an;}

//mutateur pour definir la promotion

public void setPromotion(String prom){this.promotion=prom;}
//mutateur pour definir l'option
public void setOption(String opt){this.option=opt;}
/*Methode pour afficher les coordonnees
54
***************************************
*/
@Override
System.out.println("-----------------AFFICHAGE DE L'ETUDIANT----------
----\nLe matricule est "+this.getMatricule()+"\nLe nom est
"+this.getNom()+"\nLe postnom est:"+this.getPostNom()+"\nVotre
adresse:"+this.getAdresse()+"\nVous etes du genre
"+this.getGenre()+"\nVous etes inscrit en:"+this.getPromotion()+"
"+this.getOption()+"\nL'annee est "+this.getAnneeNaissance()+" Donc
vous etes Age de "+super.calculAge(Year.now().getValue())+" ans\nVotre
montant total de frais a payer est de "+this.payer() +" $");
}
/*Methode pour effectuer la saisie de donnees
*********************************************
*/
public void saisir(){
Scanner sc=new Scanner(System.in),sci=new Scanner(System.in);
System.out.print("Entrez votre Matricule SVP: ");
this.matricule=sc.nextLine();
System.out.print("Entrez votre Nom SVP: ");
this.nom=sc.nextLine();
System.out.print("Entrez votre PostNom SVP: ");
this.postnom=sc.nextLine();

System.out.print("Entrez votre Adresse SVP: ");

this.adresse=sc.nextLine();
System.out.print("Entrez votre Genre SVP: ");
this.genre=sc.nextLine();
System.out.print("Entrez votre Annee de naissance SVP: ");
55
this.anneeNaiss=sci.nextInt();
System.out.print("Entrez votre Promotion SVP: ");
this.promotion=sc.nextLine();
System.out.print("Entrez votre Option SVP: ");
this.option=sc.nextLine();
}
}
L’instanciation dans la classe principale (cf. méthode main)
/**
*
* @author NGAINGAI
*/
/**
*/
//Instanciation d'un etudiant
Etudiant unEtudiant=new Etudiant();
//saisie de donnees de l'etudiant

unEtudiant.saisir();
//affichage de l'etudiant
unEtudiant.afficher();
}
56
}
En résumé, nos accesseurs sont des méthodes, et sont public pour que
vous puissiez y accéder dans une autre classe que celle-ci (la classe
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 en jour.
Exercice
Soit le programme permettant de calculer l’age de la personne et décide
de sa catégorie. Implémentez la classe en Java en appliquant les
concepts suivants : classe, propriétés, méthode, constructeurs,
accesseurs et mutateurs. Demandez les valeurs à l’utilisateur et afin
dans la classe principale instanciez cette classe aux constructeurs. La
catégorie est fonction de l’âge : de 0 à 5 ans : bébé, de 5 à 12 ans :
enfant, de 12 à 18 ans : adolescent, de 18 à 25 ans : Jeune, de 25 à 50
ans : adulte et de 50 ans et plus : vieux.
Eh…Oui ! Mettez la main à la charrue.
I.1.12. Les méthodes et variables de classe
1) Les méthodes de classe
Maintenant que vous commencez à écrire de vrais programmes,
vous vous rendez sûrement compte qu'il y a certaines choses que vous

effectuez souvent. Plutôt que de recopier sans arrêt les mêmes

morceaux de code, vous pouvez écrire une méthode...
Cette section aura pour but de vous faire découvrir la notion de méthode
(on l'appelle «fonction» dans d'autres langages).
Le principal avantage des méthodes est de pouvoir factoriser le code :
57
grâce à elles, vous n'avez qu'un seul endroit où effectuer des

modifications lorsqu'elles sont nécessaires. J'espère que vous comprenez
mieux l'intérêt de tout cela, car c'est ce que nous allons aborder ici.
Cependant, cette section ne serait pas drôle si nous ne nous amusions
pas à créer une ou deux méthodes pour le plaisir...
Et là, vous aurez beaucoup de choses à retenir !
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
 toLowerCase()
Cette méthode 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 !"
 toUpperCase()

Celle-là 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"
58
 length()
Celle-ci 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
 equals()
Cette méthode 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.
 charAt()
Le résultat de cette méthode sera un caractère : il s'agit d'une
59
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
 substring()
Cette méthode 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"
 indexOf() — lastIndexOf()
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. 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
60
n = mot.lastIndexOf("ti"); //n vaut 12

n = mot.indexOf('x'); //n vaut -1
Des méthodes concernant les mathématiques
Les méthodes listées ci-dessous 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
Les méthodes de classe permettent de gérer, éditer, afficher…faire
61
tout ce que vous voudrez avec vos objets.

Nous pouvons maintenant différencier les différentes méthodes déjà
étudiées :
- Les constructeurs: méthodes servant à créer des objets
- Les accesseurs : méthodes servant à accéder aux données de nos

objets
- Les méthodes de classe: méthodes servant à la gestion de nos

objets.
Avec nos objets Ville (cf. ex sur les accesseurs et mutateurs), 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 catégorie. 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.
Nous voulons que la classe Ville gère de façon de déterminer la catégorie
elle-même et non que cette action puisse être opérée de l’extérieur. La
méthode qui fera ceci sera donc déclarée private.

Voici tout d'abord le code de notre classe Ville en entier, c'est-à-dire

comportant les méthodes dont on vient de parler :
private String nomVille;
private String nomPays;
62
private int nbreHabitants;

private char categorie;
public Ville(){
nbreHabitants = 0;
this.setCategorie();
}
{
System.out.println("Création d'une ville avec des paramètres
!");
nomVille = pNom;
nomPays = pPays;
nbreHabitants = pNbre;
}
//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
63
public void setNomPays(String pPays) { nomPays = pPays; }

//Définit le nombre d'habitants
public void setNombreHabitants(int nbre) {
nbreHabitants = nbre;
}
//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)
64
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;
}
}
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é
65
en paramètre pour nous dire quelle ville est la plus peuplée!

Et si nous faisions un petit test ?
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));
Exécutez et constatez le résultat !
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 dit aux sections précédentes, 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 :
66
//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.
}
{
//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
67
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 :
System.out.println("Le nombre d'instances de la classe Ville est : " +
Ville.nbreInstances);
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.
En résumé :
- Une classe permet de définir des objets. Ceux-ci ont des
attributs (variables d'instance) et des méthodes (méthodes
68
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.
Exercices d’application :
1. Écrire en Java une classe nommé Produit qui est caractérisée par
le nom de l’article, le prix hors taxe de l’article, le nombre
d’articles et le taux de TVA. Les données sont demandées à

l’utilisateur. Ajoutez soigneusement les propriétés, les méthodes

et les constructeurs. Instanciez le Produit calculez et affichez le
prix TTC. Implémentez une interface de calcul de TVA.
Concepts à utiliser : Classe, propriétés, méthodes, Interface,
Constructeurs et accesseurs et mutateurs.
69
2. Réalisez le diagramme de classe modélisant la gestion du personnel

(permanent et journalier) d’une entreprise X, ainsi qu’une ébauche
de code en Java y ajoutant soigneusement les propriétés,
méthodes, constructeurs, accesseurs et mutateurs. N’oubliez pas
les relations entre les classes. Le programme devra permettre :
 La saisie des coordonnées de chaque membre du personnel ;
 Calculer l’ancienneté (en année) de chacun ;
 Calculer le salaire de base de chacun selon les catégories du
personnel tout en connaissant que les journaliers n’ont pas
de salaire de base ;
 Calculer le salaire net de chacun en fonction des avantages
dû à l’état civil et au nombre d’enfants : les avantages sont
libellés de la manière suivante :
 Une prime de 5% du salaire de base est accordée par
enfant ;
 Les célibataires n’ont aucun avantage tandis que : les
mariés bénéficient d’un avantage de 2%, les divorcé(e)s
1% et les veuf (ve)s 3% du salaire de base.
 Une prime de 4% du salaire de base est accordée aux
employés ayant une ancienneté de plus de 10 ans.
Concepts à utiliser : Classe, propriétés, méthodes, Héritage, Surcharge
(classe mère), Redéfinition (classe fille), Constructeur et accesseurs et
mutateurs.
I.13. Association

Une association est une relation entre deux classes (association binaire)
ou plus (association n-aire), qui décrit les connexions structurelles entres
leurs instances. Autrement dit, une association traduit une relation de
dépendance ou d’appartenance des objets des classes associées. Une
association est représentée par un trait continu liant les classes. Chaque
70
association peut être identifié par son nom.

Les multiplicités (ou cardinalités) renseignent le nombre d’instance
(minimal et maximal) qu’une classe participe dans l’association. Elles
s’expriment différemment dans le diagramme de classes, elles sont
inversées par rapport à la Méthode MERISE. Dans le diagramme de
classes, les multiplicités sont placées à l’endroit, alors qu’en MERISE,
elles se placent à l’envers.
Voici un tableau donnant des éléments de comparaison :
MERISE UML Description
0,1 0..1 Zéro ou Un
1,1 1 Un et un Seul
0, n 0..* Plusieurs (zéro ou plusieurs)
1, n 1,..* Un ou plusieurs
Ex : Un véhicule appartient à un Propriétaire ou un Propriétaire a un ou
plusieurs Véhicules
Pour mettre en œuvre une association en P.O.O (Java), on crée un
attribut dont le type est la classe de multiplicité 1 dans la classe de
multiplicité plusieurs (ou un ou plusieurs).
I.14. Agregation/Composition
L’agrégation est une association qui permet de représenter un lien
de type « ensemble » comprenant des « éléments ». Il s’agit d’une
relation entre une classe représentant le niveau « ensemble » et 1 à n
classes de niveau « élément ». Elle traduit la relation du type « est
partie de ». L’ensemble est appelé agrégat et les éléments sont des

composants. L’agrégation est représentée par une flèche fermée par un

losange à l’extrémité su côté de l’agrégat.
Ex : un ordinateur est composé du clavier, de l’unité centrale et de
l’écran.
La composition (ou agrégation forte) est une relation agrégation
71
dans laquelle il existe une contrainte de durée de vie entre la classe

« composant » et la ou les classe (s) « Composé ». Autrement dit, la
suppression ou la destruction de la classe « composé » implique la
suppression ou la destruction de la classe « Composant ».
Ex : une commance est composé des lignes commandes. Chaque ligne
concerne un produit.
L’agrégation/Composition peut avoir de multiplicité du côté
« Composant », elle donne le nombre de composant dans l’agrégation ou
la composition.
La composition est représentée par une flèche fermée par un
losange plein à l’extrémité su côté du composé.
Pour mettre en œuvre une agrégation/Composition, on crée un
tableau ou une liste du type composant comme attribut dans
l’agrégat ou le composé.
I.2. Les bases du langage Java
Nous commençons maintenant sérieusement la programmation.
Dans ce chapitre, nous allons découvrir les fondamentaux de la
programmation Java. On les retrouve dans la quasi-totalité des langages
de programmation.
1. Les variables
Une variable est un élément qui stocke des informations de toute
sorte en mémoire : des chiffres, des résultats de calcul, des tableaux,
des renseignements fournis par l'utilisateur…

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
72
langage).
Ensuite, on l'initialise en entrant une valeur.
En Java, nous avons deux types de variables : des variables de type
simple ou « primitif » et 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.
2. Les entrées/sorties
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.
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 « 73
Import 'Scanner' java.util » (figure suivante). Et là, l'erreur disparaît !

Importer la classe Scanner
Maintenant, regardez au-dessus de la déclaration de votre classe, vous
devriez voir cette ligne:
import java.util.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.
Un package est un ensemble de classes. En fait, c'est un ensemble
de dossiers et de sous-dossiers contenant une ou plusieurs classes, mais
nous verrons ceci plus en détail lorsque nous ferons nos propres
packages.
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
//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 :
System.out.println("Veuillez saisir un mot :");
String str = sc.nextLine();
74
System.out.println("Vous avez saisi : " + str);

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).
int i = sc.nextInt();
double d = sc.nextDouble();
long l = sc.nextLong();
byte b = sc.nextByte();
//Etc.
Attention : il y a un type de variables primitives qui n'est pas pris en
compte par la classe Scanner : il s'agit du type char.
Voici comment on pourrait récupérer un caractère :
System.out.println("Saisissez une lettre :");
String str = sc.nextLine();
char carac = str.charAt(0);
System.out.println("Vous avez saisi le caractère : " + carac);
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 ...
3. Les conditions
75
Nous abordons ici l'une des sections les plus importantes : les
conditions sont une autre notion fondamentale de la programmation. En
effet, ce qui va être développé ici s'applique à énormément de langages
de programmation, et pas seulement à Java. Dans une classe, la lecture
et l'exécution se font de façon séquentielle, c'est-à-dire ligne par ligne.
Avec les conditions, nous allons pouvoir gérer différents cas de figure
sans pour autant lire tout le code. Vous vous rendrez vite compte que
tous vos projets ne sont que des enchaînements et des imbrications de
conditions et de boucles (notion que l'on abordera au chapitre suivant).
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 cette section.
Comme je vous l'ai dit dans le chapitre précédent, les opérations en Java
76
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.
En fait, les accolades sont présentes dans la structure « normale » des
77
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)
78
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 !");
Explicitons :
- 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é.
Il faut absolument donner une condition au else if pour qu'il fonctionne.
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.
Avant de passer à la suite, vous devez savoir qu'on ne peut pas tester
l'égalité de chaînes de caractères ! Du moins, pas comme je vous l'ai
montré ci-dessus. Nous aborderons ce point plus tard.
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.
79
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 ». Avec l'opérateur « && », la
clause est remplie si et seulement si les conditions la constituant sont
toutes remplies ; si l'une des conditions n'est pas vérifiée, la clause sera
considérée comme fausse.
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
80
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, oui !
 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*/:) 81
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 .");
}
Je n'ai écrit qu'une ligne de code par instruction case, mais rien ne vous
empêche d'en mettre plusieurs. Si vous avez essayé ce programme en
82
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.

Un ternaire est une condition condensée qui fait deux choses sur une
seule ligne :
 on teste la valeur d'une variable dans une condition ;
 on affecte une valeur à une variable selon que la condition est vraie
ou non. Sur ce, on utilise l’opérateur ? 83
L’opérateur ? permet de remplacer avantageusement une instruction

if...else en évaluant une expression et en attribuant à une variable une
première valeur si la condition est vraie ou une autre valeur si elle est
fausse.
Sa syntaxe est la suivante :
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 :
84
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
 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
En résumé
Les conditions vous permettent de n'exécuter que certains morceaux de
85
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.
4. Les structures itératives
Le rôle des boucles est de répéter un certain nombre de fois les
mêmes opérations. Tous les programmes, ou presque, ont besoin de ce
type de fonctionnalité. Nous utiliserons les boucles pour permettre à un
programme de recommencer depuis le début, pour attendre une action
précise de l'utilisateur, parcourir une série de données, etc. Une boucle
s'exécute tant qu'une condition est remplie. Nous réutiliserons donc des
notions de la section précédente !
1. 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
86
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
?");
87
// 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. Cette boucle n'est exécutée que lorsque la condition est remplie
: ici, nous avons initialisé la variable reponse à « O » pour que la boucle
s'exécute. Si nous ne l'avions pas fait, nous n'y serions jamais entrés.
Normal, puisque nous testons la condition avant d'entrer dans 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;
88
char reponse = 'O';
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)
{
89
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)
{
a++;
}
Une petite astuce : lorsque vous n'avez qu'une instruction dans votre
boucle, vous pouvez enlever les accolades, car elles deviennent
superflues, tout comme pour les instructions if, else if ou else.
Vous auriez aussi pu utiliser cette syntaxe :
int a = 1, b = 15;
while (a++ < b)
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)
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
90
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!
2. 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 soeurs. 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 soeur. 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 = ' ';


do{
System.out.println("Donnez un prénom : ");
prenom = sc.nextLine();
System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
91
do{
System.out.println("Voulez-vous réessayer ? (O/N)");
}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 !
3. 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);

}
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
92
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");
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.
En résumé
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.
93
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.
Exercice d’application (utilisez la boucle au choix [for, while ou
do…while])
1. Ecrire un programme Java qui demande à l’utilisateur de lui fournir
la valeur d’un capital qu’il souhaite placer, ainsi que le taux
(mensuel) auquel sera effectué le placement. Il affiche l’évolution
mensuelle de ce capital jusqu’à ce qu’il ait atteint ou dépassé le
double du capital initial.
2. Réécrire le programme de dédoublement (1) du capital en y
ajoutant l’aspect de remboursement avant l’échéance. Cette
opération réduirait la valeur du capital placé. Toutefois, l’absence
du remboursement à l’échéance entraine l’évolution du capital au
triple.
5. Les tableaux
Comme tout langage de programmation qui se respecte, Java
travaille avec des tableaux. Vous verrez que ceux-ci s'avèrent bien
pratiques. Vous vous doutez (je suppose) que les tableaux dont nous
parlons n'ont pas grand-chose à voir avec ceux que vous connaissez ! En
programmation, un tableau n'est rien d'autre qu'une variable un peu
particulière. Nous allons en effet pouvoir lui affecter plusieurs valeurs
ordonnées séquentiellement que nous pourrons appeler au moyen d'un
indice (ou d'un compteur, si vous préférez). Il nous suffira d'introduire

l'emplacement du contenu désiré dans notre variable tableau pour la

sortir, travailler avec, l'afficher…
1. 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
94
tableaux que de types de variables ? Je crois voir quelques gouttes de

sueur perler sur vos fronts… 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
"
};
Le premier élément d’un tableau a toujours pour index, zéro. L’index
maximum d’un tableau est spécifié au moment de la création du
tableau. Le nombre d’éléments d’un tableau est donc égal au plus grand
index plus un.
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
95
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…
2. 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 ! 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.
Exemple : Utiliser et rechercher dans un tableau

Avant d'attaquer, je dois vous rappeler 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 :
96
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. Une très grande partie des erreurs sur les
tableaux sont dues à un mauvais indice dans celui-ci. Donc prenez garde
! 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]);
}
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 = ' ';
97

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

}while(reponse != 'N' && reponse != 'O');

}while (reponse == 'O');
System.out.println("Au revoir !");
Le résultat c’est à vous !
Explications sur la recherche
98
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.
Vous avez dû remarquer la présence d'un i = 0; dans une boucle. Ceci est
primordial, sinon, lorsque vous reviendrez au début de celle-ci, i ne
vaudra plus 0, mais la dernière valeur à laquelle il aura été affecté après
les différentes incrémentations. Si vous faites une nouvelle recherche,

vous commencerez par l'indice contenu dans i ; ce que vous ne voulez

pas, puisque le but est de parcourir l'intégralité du tableau, donc depuis
l‘indice 0. En travaillant avec les tableaux, vous serez confrontés, un
jour ou l'autre, au message suivant :
java.lang.ArrayIndexOutOfBoundsException
99
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 ci-contre :

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
100
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 [] = {" Resultat ", " ali ", " masi", " tete ", " tonton "};
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
101
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 !
En résumé
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).
6. Les exceptions
Il existe trois types d’erreurs dans un programme :
Les erreurs de syntaxes
Les erreurs de logique
Les exceptions
Les exceptions sont des erreurs se produisant dans un programme
puisque ce dernier a rencontré une situation inhabituelle non prévue.

Le fait de gérer les exceptions s'appelle aussi « la capture d'exception

».
Exemple :
Si un programme prévoit d’ouvrir un fichier se trouvant dans le
répertoire C :\Exemple et que sur la machine ce répertoire n’existe pas,
102
il se produira une erreur d’exception.

Java prévoit la gestion des exceptions par un bloc d’instructions spécial:
Le bloc try{...} catch{...}
Java dispose d’une liste d’exceptions qu’il peut retourner à l’utilisateur.
Illustration:
Soit une classe java avec la méthode main permettant de calculer le
quotient de deux nombres. C’est la classe division.
Implémentation ci-dessous :
public class ClasseDivision {
System.out.println("Entrez le Premier Nombre: ");
Scanner s1=new Scanner(System.in);
int a=s1.nextInt();
System.out.println("Entrez le Deuxieme Nombre");
int b=s2.nextInt();
float c=a/b;
System.out.println("Le quotient est "+c);
}
}
A vous le résultat après exécution !

Gestion des exceptions

Rappelons qu’une Exception est une erreur se produisant dans un
programme conduisant le plus souvent à l'arrêt de celui-ci. La gestion
des exceptions s'appelle aussi la capture d'exception ! Le principe
consiste à repérer un morceau de code qui pourrait générer une
103
exception (une division par zéro, par exemple), de capturer l'exception

correspondante, et enfin de gérer celle-ci, c'est-à-dire d'afficher un
message personnalisé et de continuer le traitement.
Java contient une classe nommée Exception, où sont répertoriés
différents cas d'erreurs.
1. le bloc try{....} catch{...}
Le bloc try rassemble les appels de méthodes susceptibles de

produire des erreurs ou des exceptions. L'instruction try est suivie
d'instructions entre des accolades.
Si un événement indésirable survient dans le bloc try, la partie
éventuellement non exécutée de ce bloc est abandonnée et le premier
bloc catch est traité. Si catch est défini pour capturer l'exception issue
du bloc try alors elle est traitée en exécutant le code associé au bloc.
Si le bloc catch est vide (aucunes instructions entre les accolades) alors
l'exception capturée est ignorée.
S’il y a plusieurs types d'erreurs et d'exceptions à intercepter, il faut
définir autant de bloc catch que de type d’événement.
Par type d'exception, il faut comprendre « qui est du type de la classe
de l'exception ou d'une de ces sous classes». Ainsi dans l'ordre séquentiel
des clauses catch, un type d'exception de ne doit pas venir après un type
d'une exception d'une super classe. Il faut faire attention à l'ordre des
clauses catch pour traiter en premier les exceptions les plus précises

(sous classes) avant les exceptions plus générales. Un message d'erreur

est émis par le compilateur dans le cas contraire.
N.B : L'exécution totale du bloc try et d'un bloc d'une clause catch sont
mutuellement exclusives : si une exception est levée, l'exécution du bloc
try est arrêtée et si elle existe, la clause catch adéquate est exécutée.
104
Capturons l’exception de l’exemple précédent :

public class ClasseDivision {
/**
*/
System.out.println("Entrez le Premier Nombre: ");
int a=s1.nextInt();
System.out.println("Entrez le Deuxieme Nombre");
int b=s2.nextInt();
try{
float c=a/b;
System.out.println(a+"/"+b+" ="+c);
}
catch(ArithmeticException e){
System .out.println("Erreur !On ne divise pas par
zero"+e);
}
}
}

Java a une classe de base pour le traitement des erreurs. C’est la classe
Throwable Cette classe possède deux constructeurs : Throwable() et
Throwable(String). La chaine en paramètre permet de définir un
message qui décrit l'exception et qui pourra être consultée dans un bloc
catch. Les principales méthodes de la classe Throwable sont :
105
Méthodes Rôle
String getMessage( ) lecture du message
void printStackTrace( ) affiche l'exception et l'état de
la pile d'exécution au moment
de son appel
void printStackTrace(PrintStream s) Idem mais envoie le résultat
dans un flux
Illustration:
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (ArithmeticException e) {
System.out.println("getmessage");
System.out.println(e.getMessage());
System.out.println(" ");
System.out.println("toString");
System.out.println(e.toString());
System.out.println(" ");
System.out.println("printStackTrace");

e.printStackTrace();
}
}
}
Résultat :
106
getmessage
/ by zero
toString
java.lang.ArithmeticException: / by zero
printStackTrace
java.lang.ArithmeticException: / by zero
at tests.TestException.main(TestException.java:24)
2. Les exceptions personnalisées
Il y a lieu de créer ses propres exceptions au lieu d’utiliser les

exceptions systèmes. Pour ce faire, il faut créer une classe d’exception
qui hérite de la classe principale Exception. Il suffit d'utiliser le mot clé
throw, suivi d'un objet dont la classe dérive de Thowable. Si l'on veut
générer une exception dans une méthode avec throw, il faut l'indiquer
dans la déclaration de la méthode, en utilisant le mot clé throws.
C’est-à-dire il faut appeler cette classe dans le constructeur de la classe
par le mot clé throws et l’instancier chaque fois qu’on en a besoin avec
le mot clé throw.
Il est préférable (par convention) d'inclure le mot « Exception » dans le
nom de la nouvelle classe.
 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é).
Exemple : Créons une exception pour la classe Personne qui gère le fait
qu’une personne doit avoir nécessairement un nom et un âge positif.
107
1. Creation du projet PersonneException

2. Ajout de la classe Personne
public class Personne {
private String nom;
private int age;
//constructeur par defaut
public Personne() {
System.out.println("Creation d'une personne");
nom="inconnu";
age=0;
}
//constructeur avec parametres
public Personne(String pnom, int page) throws
NomPersonneException,AgePersonneException {
if(page<0)
throw new AgePersonneException(page);
if(pnom.equals(""))
throw new NomPersonneException("La personne doit avoir
necessairement un nom");
nom=pnom;
age=page;
}
//accesseurs et mutateurs
//retourne le nom de la personne

public String getNom()

{
return nom;
}
//retoune l'age de la personne
108
public int getAge()

{
return age;
}
//definie le nom de la personne
public void setNom(String pnom){
nom=p nom;
}
public void setAge(int page)
{
age=page;
}
}
3. Création de la classe NomPersonneException qui hérite de la classe
principale Exception
public class NomPersonneException extends Exception {
public NomPersonneException(String message)
{
super(message);
}
}
4. Création de la classe AgePersonneException qui hérite de la classe
principale Exception
public class AgePersonneException extends Exception {

public AgePersonneException(int age)

{
System.out.println("Vous essayez d'instancier une peronne
avec age négatif !");
System.out.println("\t => " + age);
109
}
}
5. Gestion des exceptions dans la méthode main du projet (1)
public class PersonneException {
/**
*/
Personne p=null;
try{
p=new Personne("",10);
System.out.println("Votre nom est "+p.getNom()+" Votre age est
"+p.getAge());
}
//Gestion Exception sur le nom
catch(NomPersonneException e)
{
}
//Gestion Exception sur l’age
catch(AgePersonneException e1){
System.out.println(e1.getMessage());
}

}
}
Je vous demande d’exécuter ces instructions et de constater les
résultats.
Exercice d’application
110
Ecrire une classe de conversion de monnaie (de FC à Dollars et vice

versa) dans un bureau de change. Le programme doit permettre à
l’utilisateur de saisir le montant à convertir et le taux de conversion.
Une fois les valeurs saisies, le programme devra effectuer la conversion
et afficher le résultat en chiffre et en toutes lettres. Je vous demande
de capturer l’exception qui se produirait si l’utilisateur ne renseigne pas
le taux de conversion et s’il ne spécifie pas la devise (de départ).

CHAPITRE II
LA PROGRAMMATION EVENEMENTIELLE
Par programmation événementielle on sous-entend
111
programmation d’interface graphique, ou IHM, ou encore GUI et les

événements qui en découlent. Pour arriver à écrire ce genre
d‘interfaces, nous utiliserons essentiellement les classes des package
swing et AWT présentes dans Java. Dans ce cours, nous allons
développer des interfaces avec les composants des classes swing
(javax.swing) mais aussi quelques-uns des objets awt (java.awt).
Il est fortement recommandé de ne pas mélanger les composants swing
et awt pour cause de conflit. Si vous faites ceci vous aurez des très
grandes difficultés à faire une IHM stable et valide. En effet, pour faire
simple, swing et awt se basent sur les mêmes fondements mais différent
sur l‘utilisation de ces fondements…
AWT utilise des composants "lourds", c'est-à-dire des ressources du
système d'exploitation.
SWING utilise des composants "légers" qui ne se réfèrent pas aux
ressources système.
 Le Swing est plus robuste que l'AWT,
 Le Swing est plus portable, et plus facile à utiliser.
 Le Swing ne remplace pas complètement AWT
 Le Swing fournit des composants d'interface plus
performants.

Quelques composants usuels

Un composant peut-être un bouton, une zone de texte, une case à cocher
… Bref, tout ce qui peut interagir avec vous! Ce tableau reprend
quelques composants et les classes java pour les créer.
112
COMPOSANTS CLASSES
Fenêtre JFrame
Bouton JButton
Zone de texte JTextField
Zone de liste JList
Zone de liste JComboBox
deroulante
Bouton radio JRadioButton
Case à cocher JCheckBox
Conteneur JPanel
Menu JMenu
Barre de menu JMenuBar
Sous menu JMenuItem
Barre d’outils JToolBar
Boîte de dialogue JDialog
CREATION DE L’INTEFACE GRAPHIQUE
La création de l’interface graphique en Java peut se faire de deux
manières :
a) En utilisant la boite à outils fourni avec l‘IDE
b) En écrivant le code instanciant les composants.
A. Création de l’interface graphique en utilisant la boite à outils
fourni avec l’IDE
La première des choses à faire est de créer un projet de la manière
suivante :
Fichier\ Nouveau Projet\ java\ java Application.
Passez à l’écran suivant dans lequel vous indiquez le nom du projet et
éventuellement spécifier son emplacement et cliquez le bouton
« Terminer »

Le projet « MaFenetre » est bien crée.

Ensuite vous ajouter une nouvelle classe du package javax.swing
(catégorie Swing GUI Forms)ou java.awt (catégorie QWT GUI Forms) en
vous positionnant sur le menu Fichier\ Nouveau Fichier\ dans la zone
catégorie sélectionnez Swing GUI Forms\ dans la zone type
113
sélectionnez JFrame Form:

Passez à l’écran suivant pour spécifier le nom de la classe et enfin
cliquez le bouton « Terminer »
Eh…..Oui ! Ma première fenêtre est bien créée.
Ajouter les contrôles par glisser-déplacer de la boite à outils au
formulaire ;
Renommez les contrôles à partir de la fenêtre de propriétés (utilisez la
propriété text ou faites un menu contextuel puis sélectionnez éditer le
texte). Pour nommer les variables, faites un menu contextuel sur le
contrôle, puis sélectionnez changer le nom de la variable ;
Dans la boite de dialogue qui s’affiche, écrivez le nom de la variable
dans la zone de saisie puis cliquez le bouton « OK »
Pour accéder aux événements des contrôles, faites un clic-droit sur le

contrôle puis sélectionnez évènements et enfin faites votre choix selon
vos besoins.
Maintenant que notre fenêtre est prête à l’emploi, nous allons mettre
les instructions dans l’événement click du bouton ‘valider’. L’instruction
va afficher dans une zone étiquette (label) « Bonjour et va placer le nom
tapé dans la zone de texte ». Le bouton « Effacer » va nous aider à
initialiser la zone de texte à vide.
private void btnValiderMouseClicked(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
lblAfficher.setText("Bonjour "+txtNom.getText());

}
private void btnEffacerMouseClicked(java.awt.event.MouseEvent
evt) {
114
txtNom.setText("");
lblAfficher.setText("");
}
Le bouton effacer remet les contrôles à vide.
Pour exécuter votre fenêtre au bon format, instancier la classe dans la

méthode principale du projet principale comme ceci :
package mafenetre;
/**
*
* @author NGAINGAI
*/
public class MaFenetre {
/**
*/
MaPremièreFenetre fen=new MaPremièreFenetre();
fen.setVisible(true);
}

}
Dans ce cours nous nous intéressons à la création des interfaces
graphiques en écrivant le code instanciant les composants.
B. Création de l’interface graphique en écrivant le code
instanciant les composants.
115
1) Le JFrame
Pour utiliser une fênetre de type JFame, vous devez instancier celui-ci.
Exemple
import javax.swing.JFrame;
public class Fenetre {
JFrame fen=new JFrame();
}
}
Vous pouvez aussi créer votre classe qui hérite de la classe JFrame du
package javax.swing :
public class MaPremièreFenetre extends javax.swing.JFrame {
}
Lorsqu’on executer ce code, rien ne s’affiche! Parce que par défaut,

votre JFrame n’est pas visible. Pour pouvoir l’afficher à l’écran, vous
devez lui dire « Sois visible », comme ceci :
}
}

En exécutant, vous avez une fenêtre toute minuscule, comme ceci :

Pour avoir une fenêtre plus conséquente, il faudrait :
 Qu’elle ait une taille considérable
 Qu’elle ait un titre
 Au besoin être centrée à l’écran etc.
116
Par contre, vous ne l’avez peut-être pas remarqué, mais, lorsque vous
cliquez sur le bouton de fermeture (pour fermer votre fenêtre), cette
action ne termine pas le processus !
Pour réellement terminer le processus de l’application, vous devrez
ajouter une autre instruction.
Pour chacune de ces choses énumérées, il y aura une méthode à appeler
pour que votre JFrame sache à quoi s’en tenir !
Voici un code qui reprend toutes ces doléances :
//Création de l'objet JFrame
//Définir un titre pour la fenêtre
fen.setTitle("Ma première fenêtre Java");
//Définir la taille de la fenêtre: 400px de large et 300px de
haut
fen.setSize(400, 300);
//Nous allons maintenant dire à notre objet de se
positionner au centre
fen.setLocationRelativeTo(null);
//Teminer le processus lorsqu'on clique sur "Fermer"
fen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Rendre la fenêtre visible
}
}
Découvrez le résultat de vous-même.

POSITIONNER LA FENETRE A L’ECRAN

Déjà, nous avons centré notre fenêtre, mais vous auriez peut-être
voulu la positionner ailleurs. Pour faire ceci, vous avez la méthode
setLocation(int x, int y).
Avec cette méthode, vous pouvez spécifier où doit se situer votre fenêtre
117
sur votre écran. Les coordonnées, exprimées en pixels, sont basées sur
un repère prenant le coin supérieur gauche comme origine.
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, et les valeurs négatives vous font sortir de l’écran vers la
gauche. La même règle s’applique pour les valeurs Y, excepté que les
valeurs positives font descendre la fenêtre en commençant par l’origine,
et les valeurs négatives font sortir la fenêtre par le haut !
Ex. fen.setLocation(200, 100);
EMPECHER LE REDIMENSIONNEMENT DE LA FENETRE
Pour empêcher le redimensionnement de la fenêtre, il vous suffit
d’invoquer la méthode setResizable(false) ; et de repasser la méthode
à true pour le rendre actif !
FAIRE QUE VOTRE FENETRE SOIT TOUJOURS AU PREMIER PLAN
Il s’agit là encore d’une méthode qui prend un booléen en paramètre.
Passer true mettre la fenêtre au premier plan quoi qu’il advienne, et
passer false annulera le statut. Cette méthode est
setAlwaysOnTop(boolean b).
RETIRER LES CONTOURS ET LES BOUTONS DE CONTROLES
Pour ce faire, il vous suffit d’utiliser la méthode
setUndercorated(boolean b).
CREER UN CONTENEUR POUR LA FENETRE
Nous allons utiliser un JPanel, composant de type conteneur, dont
la vocation est d’acceuillir d’autres objets de même type, ou des objets

de type composant (bouton, case à cocher…). Mais dans l’absolu,

n’importe quel composant peut acceuillir un autre composant!
Marche à suivre
Nous allons importer la classe javax.swing.JPanel dans notre
classe
118
Nous allons instancier un JPanel, lui spécifier une couleur de fond

pour pouvoir mieux le voir.
Dire à notre JFrame que ce sera notre JPanel qui sera son
ContentPane
Code :
//importation de la classe pour la couleur
import java.awt.Color;
//importation de la classe pour la fenetre
//importation de la classe pour le conteneur
import javax.swing.JPanel;
//Création de l'objet JFrame
//Définir un titre pour la fenêtre
fen.setTitle("Ma première fenêtre Java");
//Définir la taille de la fenêtre: 400px de large et 300px de haut
//Positionnement de la fenêtre
fen.setLocation(200, 100);
//Instanciation d'un objet JPanel
JPanel pan=new JPanel();
//Definir la couleur de fond du JPanel

pan.setBackground(Color.LIGHT_GRAY);
/*
* On prévient notre JFrame que ce sera notre JPanel qui
* sera son conteneur
*/ fen.setContentPane(pan);
119
//Teminer le processus lorsqu'on clique sur "Fermer"

//Rendre la fenêtre visible
}
}
2) LE COMPOSANT JLabel
Le composant JLabel permet d'afficher un texte et/ou une icône en
précisant leur alignement. L'icône doit être au format GIF et peut être
une animation dans ce format.
Constructeurs Rôle
JLabel() Création d'une instance sans texte
ni image
JLabel(Icon) Création d'une instance en
précisant l'image
JLabel(Icon, int) Création d'une instance en
précisant l'image et l'alignement
horizontal
JLabel(String) Création d'une instance en
précisant le texte
JLabel(String, Icon, int) Création d'une instance en
précisant le texte, l'image et
l'alignement horizontal
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 de la manière suivante :
JLabel label1 = new JLabel();
label1.setText("Mon premier JLabel");

//Ou encore
JLabel label2 = new JLabel("Mon deuxième JLabel");
La classe JLabel définit plusieurs méthodes pour modifier l'apparence du
composant :
Méthodes Rôle 120
setText() Permet d'initialiser ou de modifier le texte
affiché
setOpaque() Indique si le composant est transparent
(paramètre false) ou opaque (true)
setBackground() Indique la couleur de fond du composant
(setOpaque doit être à true)
setFont() Permet de préciser la police du texte
setForeGround() Permet de préciser la couleur du texte
setHorizontalAlignmen Permet de modifier l'alignement horizontal
t() du texte et de l'icône
setVerticalAlignment() Permet de modifier l'alignement vertical
du texte et de l'icône
setHorizontalTextAlign Permet de modifier l'alignement horizontal
ment() du texte uniquement
setVerticalTextAlignm Permet de modifier l'alignement vertical
ent() du texte uniquement
Exemple :
jLabel.setVerticalTextPosition(SwingConst
ants.TOP);
setIcon() Permet d'assigner une icône
setDisabledIcon() Permet d'assigner une icône dans un état
désactivée
//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);

3) LE COMPOSANT JButton
L’objet JButton se trouve aussi dans le package javax.swing. Dans notre
classe, nous allons créer une variable d’instance de type JPanel et une
de type JButton
Code :
121
//importation de la classe pour le bouton
import javax.swing.JButton;
public class FenetreBouton {
fen.setTitle("Fenêtre avec bouton");
//Création d'un bouton
JButton btn=new JButton();
//Ajout d'un nom au bouton
btn.setText("Bouton1");
//Ajout du bouton au contentPane
pan.add(btn);
fen.setContentPane(pan);
}
}

QUELQUES PROPRIETES DES BOUTONS

L’exemple ci-dessous reprend certaines propriétés des boutons et leur
explication dans les commentaires
import java.awt.Dimension;
122
import java.awt.Font;
//importation de la classe pour le bouton
public class FenetreBouton {
fen.setTitle("Fenêtre avec bouton");
//Création d'un bouton
//Ajout d'un nom au bouton
//Couleur du bouton
btn.setBackground(Color.orange );
//Couleur de police du bouton
btn.setForeground(Color.RED);
//Dimension du bouton
btn.setPreferredSize(new Dimension(150,50));
//Police du bouton

btn.setFont(new Font("Arial",Font.BOLD,26));
//Rendre le bouton visible ou invisible
btn.setVisible(true);
//Activer ou Desactiver le bouton
btn.setEnabled(true);
123
//Ajout du bouton au contentPane

pan.add(btn);
}
}
INTERACTIONS BOUTON(S)-APPLICATION
Le concept d'événement
La programmation événementielle se base sur la conception du
comportement d'un programme:
 Un programme a un déroulement permanent, en interaction

et au service d'un utilisateur.
 Le programme ne "fait rien" tant que l'utilisateur ne lui

demande "rien".
Dans la programmation événementielle existe une "boucle

d'attente", qui permet au processeur d'attribuer du temps à
d'autres programmes (fonction d'interruption du système
d'exploitation).
Lorsqu'un utilisateur intervient, il envoie un "événement" au

programme.

L'événement est un "objet" passé à une fonction particulière du

programme, chargée de son acheminement vers le logiciel qui est
sensé le traiter.
Déclencher une action

Afin de gérer les différentes actions à effectuer selon le bouton sur 124
lequel on clique, nous allons ajouter un ActionListener à notre bouton.

Exemple
Code :
import javax.swing.JLabel;
//Classes pour les événements
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class InteractionBouton {
static int nbre=0;
fen.setTitle("Interaction avec le bouton");
//Label
final JLabel lbl=new JLabel();

lbl.setText("Cliquez sur votre bouton");

lbl.setPreferredSize(new Dimension(250,50));
lbl.setFont(new Font("Times New Roman",Font.ITALIC,24));
//Bouton
125
btn.setBackground(Color.orange );
btn.setForeground(Color.RED);
btn.setPreferredSize(new Dimension(150,50));
btn.setFont(new Font("Arial",Font.BOLD,26));
//Ajout des composants au contentPane
pan.add(lbl);
pan.add(btn);
//CLIC SUR LE BOUTON btn
//***********************
btn.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent argo){
lbl.setText("Vous avez cliqué "+(nbre+1)+ " fois");
nbre++;
}
});
}
}
Remarque

Vous avez probablement remarqué la présence de deux mots clé : static

et final. Les mots clés static ne sont pas tout en fait nouveaux, car nous
en avons parlé dans la section concernant « les variables et méthodes
de classe ».
4) LE COMPOSANT JTextField
126
La classe javax.Swing.JTextField est un composant qui permet la saisie

d'une seule ligne de texte simple.
Exemple :
package fen;
/**
*
* @author NGAINGAI
*/
import java.awt.BorderLayout;
import javax.swing.*;
public class Fen {
/**
*/

static int nbre=0;

//Fenêtre
JFrame f = new JFrame("Fenêtre avec zone de texte");
127
f.setSize(400, 300);
f.setLocationRelativeTo(null);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Contenaire
JPanel pan = new JPanel();
//Etiquette
JLabel lbl=new JLabel();
lbl.setText("Texte1:");
lbl.setPreferredSize(new Dimension(100,30));
lbl.setHorizontalAlignment(JLabel.LEFT);
//Création de la zone de texte
JTextField txt = new JTextField ();
//Dimension de la zone de texte
txt.setPreferredSize(new Dimension(200,30));
//Police du texte de la zone
txt.setFont(new Font("Arial",Font.ITALIC,14));
//Ajout des composants au contenaire
pan.add(lbl);
pan.add(txt);
f.getContentPane().add(pan);
f.setVisible(true);
}
}
Récupérer le contenu d’une zone de texte

Pour récupérer le contenu d’une zone de texte, on utilise la méthode

getText()
Exemple
package fen;
/** 128
*
* @author NGAINGAI
*/
import java.awt.BorderLayout;
public class Fen {
/**
*/
static JLabel lblResultat=new JLabel("");
static JLabel lblNbre1=new JLabel("Nombre 1");
static JLabel lblNbre2=new JLabel("Nombre 2");
static JTextField txtNbre1=new JTextField();
static JTextField txtNbre2=new JTextField();
//Fenêtre
fen.setTitle("Calculatrice minimale");

//Dimension des Labels et des zones de texte
lblResultat.setPreferredSize(new Dimension(300,50));
lblNbre1.setPreferredSize(new Dimension(90,30));
lblNbre2.setPreferredSize(new Dimension(90,30));
txtNbre1.setPreferredSize(new Dimension(200,30));
129
txtNbre2.setPreferredSize(new Dimension(200,30));
lblResultat.setFont(new Font("Arial",Font.BOLD,26));
lblResultat.setHorizontalAlignment(JLabel.CENTER);
lblResultat.setBorder(BorderFactory.createLineBorder(Color.black));
//les Boutons
JButton btnPlus=new JButton("+");
btnPlus.setPreferredSize(new Dimension(70,30));
btnPlus.setFont(new Font("Arial",Font.BOLD,26));
JButton btnMoins=new JButton("-");
btnMoins.setPreferredSize(new Dimension(70,30));
btnMoins.setFont(new Font("Arial",Font.BOLD,26));
JButton btnMultiplication=new JButton("x");
btnMultiplication.setPreferredSize(new Dimension(70,30));
btnMultiplication.setFont(new Font("Arial",Font.BOLD,26));
JButton btnDivision=new JButton("/");
btnDivision.setPreferredSize(new Dimension(70,30));
btnDivision.setFont(new Font("Arial",Font.BOLD,26));
JButton btnEffacer=new JButton("Effacer");
btnEffacer.setPreferredSize(new Dimension(145,30));
btnEffacer.setFont(new Font("Arial",Font.ITALIC,26));
JButton btnQuitter=new JButton("Quitter");
btnQuitter.setPreferredSize(new Dimension(145,30));
btnQuitter.setFont(new Font("Arial",Font.ITALIC,26));
//Ajout des composants au contentPane
pan.add(lblResultat);
pan.add(lblNbre1);
pan.add(txtNbre1);
pan.add(lblNbre2);
pan.add(txtNbre2);
pan.add(btnPlus);

pan.add(btnMoins);
pan.add(btnMultiplication);
pan.add(btnDivision);
pan.add(btnEffacer);
pan.add(btnQuitter);
130
/*
* EVENEMENTS
* **********
*/
//CLIC SUR LE BOUTON btnPlus
//**************************
btnPlus.addActionListener(new ActionListener(){
lblResultat.setText(String.valueOf((Double.valueOf(txtNbre1.getText()
)+(Double.valueOf(txtNbre2.getText())))));
}
});
//CLIC SUR LE BOUTON btnMoins
//***************************
btnMoins.addActionListener(new ActionListener(){
)-(Double.valueOf(txtNbre2.getText())))));
}
});
//CLIC SUR LE BOUTON btnMultiplication
//************************************
btnMultiplication.addActionListener(new ActionListener(){
)*(Double.valueOf(txtNbre2.getText())))));

}
});
//CLIC SUR LE BOUTON btnDivision
//******************************
btnDivision.addActionListener(new ActionListener(){
131
)/(Double.valueOf(txtNbre2.getText())))));
}
});
//CLIC SUR LE BOUTON btnEffacer
//*****************************
btnEffacer.addActionListener(new ActionListener(){
txtNbre1.setText("");
txtNbre2.setText("");
lblResultat.setText("");
}
});
//CLIC SUR LE BOUTON btnQuitter
//*****************************
btnQuitter.addActionListener(new ActionListener(){
System.exit(0);
}
});
}
}
Découvrez le résultat par vous-même.
5) LE COMPOSANT JList
Le composant JList (Zone de liste) permet de choisir une ou plusieurs
valeurs dans une liste prédéfinie.
package fen;
/**

*
* @author NGAINGAI
*/
132
public class Promotion extends JFrame {

public Promotion(){
this.setTitle("Zone de Liste");
this.setSize(280,230);
JPanel pn=new JPanel();
//Tableau des promotions
String[] promotion={"G1","G2","G3","L1","L2"};
//Creation de la liste
JList lst=new JList(promotion);
lst.setPreferredSize(new Dimension(240,150));
pn.add(lst);
this.setContentPane(pn);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
Pour afficher la fenêtre, instanciez la classe dans le projet principal (cf.
méthode main)
package fen;
/**
*
* @author NGAINGAI
*/

public class Fen {

Promotion fen=new Promotion();
}
}
133
6) LE COMPOSANT JComboBox
Le JComboBox (Zone de liste déroulante ou boîte de liste combinée)
associe un champ de texte et une boîte de liste à sélection simple. Tant
que le composant n'est pas sélectionné, seul le champ de texte s'affiche.
Lorsque l'utilisateur sélectionne le champ de texte, la boîte de liste
s'affiche. L'utilisateur peut choisir une valeur dans la boîte de liste qui
s'affiche alors dans le champ de texte.
package fen;
/**
*
* @author NGAINGAI
*/
public Promotion(){
this.setTitle("Zone de Liste");
//Tableau des promotions

//Creation de la zone de liste deroulante

JComboBox cbo=new JComboBox(promotion);
cbo.setPreferredSize(new Dimension(240,30));
pn.add(cbo);
134
}
}
Vous pouvez aussi utiliser la méthode addItem() pour ajouter les
éléments à la zone de liste déroulante:
JComboBox cbo=new JComboBox();
cbo.addItem("G1");
cbo.addItem("G2");
cbo.addItem("G3");
cbo.addItem("L1");
cbo.addItem("L2");
7) LE COMPOSANT JCheckBox (les cases à cocher)
La case à cocher de type JCheckBox permet à l’utilisateur d’effectuer
un ou plusieurs choix de type oui/non.
Exemple
package fen;
/**
*
* @author NGAINGAI
*/

public Promotion(){
this.setTitle("Choix");
135
JCheckBox chk=new JCheckBox("Case à cocher");
pn.add(chk);
}
}
NB:
 Par défaut, une case à cocher est construite dans l’état non coché
(false).
 La méthode isSelected de la classe AbstractButton permet de
connaître l’état (true ou false).
 La méthode setSelected de la classe AbstractButton permet de
modifier l’état d’une case à cocher.
Exemple: MaCase.setSelected(true) ;
8) LE COMPOSANT JRadioButton (les boutons radio)

Le principe est d’avoir deux (ou plus) choix distincts, mais qu'un seul
soit sélectionné à la fois... C'est-à-dire que pour un choix oui / non, le
choix oui étant présélectionné, lorsque nous choisirons non, l'autre choix
se désélectionnera tout seul. Dans un groupe de boutons radio un seul
choix oui est sélectionné et les autres choix sont non, on dit alors : “Les
boutons radio sont exclusifs”.
package fen;

/**
*
* @author NGAINGAI
*/
136
public Promotion(){
JFrame fn=new JFrame();
fn.setTitle("Boutons radio");
fn.setSize(250, 200);
JRadioButton rb1=new JRadioButton("Radio 1");
pn.add(rb1);
pn.add(rb2);
fn.setContentPane(pn);
fn.setVisible(true);
}
Vous pouvez voir que nos boutons radio ne répondent pas encore au
principe. Les deux boutons sont tous sélectionnés. Pour qu'un seul bouton
radio soit sélectionné à la fois, nous devons définir un groupe de boutons,
ButtonGroup. Dans celui-ci, nous ajouterons nos boutons radio et ainsi
seul un bouton sera sélectionné à la fois !
Code :
package fen;
/**
*
* @author NGAINGAI
*/

public Promotion(){
JFrame fn=new JFrame();
fn.setTitle("Boutons radio");
137
fn.setSize(250, 200);
pn.add(rb1);
pn.add(rb2);
//Groupe de boutons
ButtonGroup bg=new ButtonGroup();
bg.add(rb1);
bg.add(rb2);
//Nous cochons rb1 par defaut
rb1.setSelected(true);
fn.setContentPane(pn);
fn.setVisible(true);
}
}
9) LE COMPOSANT JOptionPane (les boîtes de dialogue)
Une boîte de dialogue est une mini-fenêtre pouvant servir à plusieurs
choses :
 afficher une information (message d'erreur, warning...) ;
 demander une validation, une réfutation ou une annulation ;
 demander à l'utilisateur de saisir une information dont le système
a besoin ;
 ...
Vous pouvez voir que ces dernières peuvent servir à beaucoup de choses.
Il faut toutefois les utiliser avec parcimonie : il est, au final, assez

pénible qu'une application ouvre une boîte de dialogue à chaque

notification, car toute boîte ouverte doit être fermée !
Les boîtes d'information
Voici à quoi ressemblent des boîtes de dialogues "informatives" :
Code :
138
package boitededialogue;
/**
*
* @author NGAINGAI
*/
import javax.swing.JOptionPane;
public class BoiteDeDialogue {
/**
*/
//Déclaration des objets
JOptionPane jop1, jop2, jop3;
//Boîte du message d'information
//-------------------------------
jop1 = new JOptionPane();
jop1.showMessageDialog(null, "Message informatif", "Information",
JOptionPane.INFORMATION_MESSAGE);
//Boîte du message préventif

//-------------------------------
jop2.showMessageDialog(null, "Message préventif", "Attention",
JOptionPane.WARNING_MESSAGE);
//Boîte du message d'erreur
//-------------------------------

jop3.showMessageDialog(null, "Message d'erreur", "Erreur",

JOptionPane.ERROR_MESSAGE);
}
}
Constatez le résultat par vous-même.
139
Ces trois boîtes ne s'affichent pas en même temps...
Pourquoi ça ? Tout simplement parce qu'en Java, mais aussi dans les
autres langages, les boîtes de dialogue sont dites modales. Ceci signifie
que lorsque qu'une boîte fait son apparition, celle-ci bloque toute
interaction possible avec un autre composant que ceux présents sur la
boîte. Ceci, tant que l'utilisateur n'a pas mis fin au dialogue !
Les types de boîtes
Voici les types de boîtes que vous pouvez utiliser :
 JOptionPane.ERROR_MESSAGE
 JOptionPane.INFORMATION_MESSAGE
 JOptionPane.PLAIN_MESSAGE
 JOptionPane.QUESTION_MESSAGE
 JOptionPane.WARNING_MESSAGE
Les boîtes de confirmation
Comme leur nom l'indique, ces dernières permettent de valider,
de réfuter ou d'annuler une décision. Nous utiliserons toujours l'objet
JOptionPane mais, cette fois, avec la méthode showConfirmDialog() .
Cette méthode retourne un entier qui correspond à l'option que vous
aurez choisie dans cette boîte :
 Yes ;
 No ;
 Cancel.

/**
*
* @author NGAINGAI
*/
140
/**
*/
JOptionPane jop = new JOptionPane();
int option = jop.showConfirmDialog(null, "Cliquez sur le bouton",
"Clic", JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
if(option==JOptionPane.YES_OPTION){
JOptionPane.showMessageDialog(null, "Vous avez cliqué sur
OK","Confirmation",JOptionPane.INFORMATION_MESSAGE);
}
if(option==JOptionPane.NO_OPTION){
Non","Confirmation",JOptionPane.INFORMATION_MESSAGE);
}
if(option==JOptionPane.CANCEL_OPTION){
Annuler","Confirmation",JOptionPane.INFORMATION_MESSAGE);
}
}
Les boîtes de saisie

/**
*

* @author NGAINGAI
*/
/**
141
*/
JOptionPane jop = new JOptionPane(), jop2 = new JOptionPane();
String nom = jop.showInputDialog(null, "Veuillez saisir votre nom
!", "Nom", JOptionPane.QUESTION_MESSAGE);
jop2.showMessageDialog(null, "Votre nom est " + nom, "Identité",
JOptionPane.INFORMATION_MESSAGE);
}
}
Voyons comment on incorpore une liste dans une boîte de dialogue :
Exemple
Code :
/**
*
* @author NGAINGAI
*/
/**
*/
String[] sexe = {"masculin", "féminin"};
JOptionPane jop = new JOptionPane(), jop2 = new JOptionPane();

String nom = (String)jop.showInputDialog(null, "Veuillez

sélectionner le genre
!","Genre",JOptionPane.QUESTION_MESSAGE,null,sexe,sexe[1]);
jop2.showMessageDialog(null, "Vous êtes du genre "+nom, "Etat
civil", JOptionPane.INFORMATION_MESSAGE);
}
142
}
A vous de découvrir le résultat.
Exercices
Nous allons écrire un programme qui permettra d’afficher dans une boîte
de dialogue le nom de l’étudiant, son pourcentage et les cours qu’il doit
passer à la seconde session. Ces éléments sont sélectionnés à partir de
la fenêtre principale. Quand l’utilisateur clique sur le bouton afficher,
ils s’affichent alors dans la boîte de dialogue.
Code :
package enregistrement;
/**
*
* @author NGAINGAI
*/
import javax.swing.JLabel;
import javax.swing.JComboBox;
import javax.swing.JRadioButton;
import javax.swing.JCheckBox;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
public class Enregistrement {

/**
*/
final JFrame fen=new JFrame();
143
fen.setTitle("Enregistrement");
//LABEL
JLabel lblEtudiant=new JLabel("Etudiant");
lblEtudiant.setPreferredSize(new Dimension (70,30));
//COMBOBOX
final JComboBox cboEtudiant=new JComboBox();
cboEtudiant.setPreferredSize(new Dimension (200,30));
//AJOUT DES ELEMENTS DANS LE COMBOBOX
cboEtudiant.addItem("Mathe");
cboEtudiant.addItem("Germaine");
cboEtudiant.addItem("Lusenge");
cboEtudiant.addItem("Esperance");
cboEtudiant.addItem("Freddy");
//PANEL POUR LES POURCENTAGES
JPanel pourc=new JPanel();
pourc.setPreferredSize(new Dimension(380,90));
pourc.setBorder(BorderFactory.createTitledBorder("Pourcentage"));
//BOUTONS RADIO
final JRadioButton pourcMoins40;
final JRadioButton pourc40_50;
final JRadioButton pour50_70;
final JRadioButton pourcPlus90;
pourcMoins40=new JRadioButton("Moins de 40%");
pourc40_50=new JRadioButton("Entre 40 et 50%");
pour50_70=new JRadioButton("Entre 50 et 70%");


pourcPlus90=new JRadioButton("Plus de 90%");
//Bouton coché par defaut
pourcMoins40.setSelected(true);
//GROUPE DES BOUTONS
144
bg.add(pourcMoins40);
bg.add(pourc40_50);
bg.add(pour50_70);
bg.add(pourc70_80);
bg.add(pourc80_90);
bg.add(pourcPlus90);
//AJOUT DES BOUTONS RADIO AU PANEL POURCENTAGE
pourc.add(pourcMoins40);
pourc.add(pourc40_50);
pourc.add(pour50_70);
pourc.add(pourcPlus90);
//PANEL POUR LES COURS
JPanel cours=new JPanel();
cours.setPreferredSize(new Dimension(380,210));
cours.setBorder(BorderFactory.createTitledBorder("Cours"));
//LES CASES A COCHER
final JCheckBox crs1;
crs1=new JCheckBox("Langage de programmation");
crs2=new JCheckBox("Algorithmique et methode de
programmation");
crs3=new JCheckBox("Laboratoire 2");
crs4=new JCheckBox("Système d'exploitation");
crs5=new JCheckBox("Statistique");
crs1.setPreferredSize(new Dimension(300,30));

//AJOUT DES CASES A COCHER AU PANEL COURS
cours.add(crs1);
cours.add(crs2);
145
cours.add(crs3);
cours.add(crs4);
cours.add(crs5);
//BOUTONS
JButton btnAfficher=new JButton("Afficher");
JButton btnFermer=new JButton("Fermer");
JButton btnQuitter=new JButton("Quitter");
//AJOUT DU LABEL ET DU COMBOBOX AU CONTENAIRE PRINCIPAL
pan.add(lblEtudiant);
pan.add(cboEtudiant);
pan.add(pourc);
pan.add(cours);
pan.add(btnAfficher);
pan.add(btnFermer);
pan.add(btnQuitter);
//AJOUT DE L'EVENEMENT AU BOUTON AFFICHER
btnAfficher.addActionListener(new ActionListener(){
JOptionPane.showMessageDialog(null,"Etudiant: " +
cboEtudiant.getSelectedItem()+ "\n" + getPourcentage() + "\n" +
getCours());
}
public String getPourcentage()
{
String pourcentage ="";
if (pourcMoins40.isSelected()){
pourcentage="Pourcentage: " + pourcMoins40.getText();

}
if (pourc40_50.isSelected()){
pourcentage="Pourcentage: " + pourc40_50.getText();
}
if (pour50_70.isSelected()){
pourcentage="Pourcentage: " + pour50_70.getText();
146
}
}
}
if (pourcPlus90.isSelected()){
pourcentage="Pourcentage: " + pourcPlus90.getText();
}
return pourcentage;
}
public String getCours()
{
String crs="Cours:\n";
if(crs1.isSelected())
{
crs +=" - " + crs1.getText() + "\n";
}
{
crs +=" - " + crs2.getText() + "\n";
}
{
crs +=" - " + crs3.getText() + "\n";
}
{
crs +=" - " + crs4.getText() + "\n";
}

{
crs +=" - " + crs5.getText() + "\n";
}
return crs;
}
147
});
//AJOUT DE L'EVENEMENT AU BOUTON FERMER
btnFermer.addActionListener(new ActionListener(){
fen.dispose();
}
});
//AJOUT DE L'EVENEMENT AU BOUTON QUITTER
btnQuitter.addActionListener(new ActionListener(){
System.exit(0);
}
});
}
}
10) Les menus
Une barre de menus située au sommet de la fenêtre contient les noms
des menus déroulants. Il suffit de cliquer dessus pour les ouvrir, ce qui
fait apparaître des options de menu et de sous-menus. Lorsque
l’utilisateur clique sur une option de menu, tous les menus sont fermés
et un message est envoyé au programme.
Le composant JMenuBar constitue le conteneur qui va accueillir les
menus représentés par des JMenu qui euxmêmes vont contenir des
éléments de menus représentés par des JMenuItem. Le composant
JMenuBar se comporte comme un conteneur pour les JMenu. Les JMenu
vont eux aussi se comporter comme un conteneur pour des JMenuItem
ou d’autres JMenu. La conception d’un menu va donc consister à créer
des instances de ces différentes classes puis de les associer les unes aux

autres. Au final le JMenuBar obtenu est placé sur son conteneur qui n’est
autre que la JFrame de l’application. Il faut bien sûr également penser
à traiter les événements déclenchés par ces différents éléments. En
général, seuls les JMenuItem sont associés à des écouteurs. Ils se
comportent comme des JButton. Ils ont d’ailleurs un ancêtre commun
148
puisque tous deux héritent de la classe AbstractButton. La conception

d’un menu n’est pas très complexe. La seule difficulté réside dans la
quantité de code relativement importante nécessaire.
Création d’un menu
La création de menus est une opération assez simple. On commence par
créer une barre de menus:
JMenuBar menuBar = new JMenuBar();
Une barre de menus est un simple composant que vous pouvez ajouter
n’importe où. Le plus souvent, elle est placée au sommet d’un cadre.
Pour cela, la méthode setJMenuBar est appelée:
frame.setJMenuBar(menuBar);
Pour chaque menu, vous devez créer un objet menu :
JMenu editMenu = new JMenu("Edit");
Vous ajoutez les menus principaux à la barre de menus :
menuBar.add(editMenu);
Vous ajoutez ensuite à l’objet menu les options du menu, les séparateurs
et les sous-menus :
JMenuItem pasteItem = new JMenuItem("Paste");
editMenu.add(pasteItem);
editMenu.addSeparator();
JMenu optionsMenu = . . .; // un sous-menu
editMenu.add(optionsMenu);
Vous pouvez voir les séparateurs sous les éléments "Paste" et "Read-only".

Lorsque l’utilisateur sélectionne un menu, un événement d’action est

déclenché. Vous devez installer un écouteur d’action pour chaque option
de menu :
ActionListener listener = . . .;
pasteItem.addActionListener(listener);
149
Il existe une méthode, JMenu.add(String s), qui ajoute une option à la

fin d’un menu, par exemple:
editMenu.add("Paste");
La méthode add renvoie l’option de menu créée, afin que vous puissiez
la capturer et lui associer un écouteur, de la façon suivante :
JMenuItem pasteItem = editMenu.add("Paste");
pasteItem.addActionListener(listener);
Il arrive fréquemment que des options de menu lancent des commandes
qui peuvent aussi être activées par le biais d’autres éléments de
l’interface utilisateur, comme les boutons de la barre d’outils.
Dans cette section, vous avez vu comment spécifier des commandes par
l’intermédiaire des objets Action. Vous définissez une classe qui
implémente l’interface Action, généralement par dérivation de la classe
AbstractAction. Vous spécifiez le libellé de l’option de menu dans le
constructeur de l’objet AbstractAction, puis vous surchargez la méthode
actionPerformed pour qu’elle contienne le gestionnaire d’action du
menu. Par exemple :
Action exitAction = new
AbstractAction("Exit") // texte de l’option de menu ici
{
public void actionPerformed(ActionEvent event)
{
// code de l’action ici
System.exit(0);

}
};
Vous pouvez alors ajouter l’action au menu : JMenuItem exitItem =
fileMenu.add(exitAction);
Cette commande ajoute une option au menu, à l’aide du nom de
150
l’action. L’objet action devient son écouteur. C’est un raccourci

pratique pour :
JMenuItem exitItem = new JMenuItem(exitAction);
fileMenu.add(exitItem);
• JMenu(String label) Construit un menu avec le label
donné.
• JMenuItem add(JMenuItem Ajoute une option de menu (ou un
option) menu).
• JMenuItem add(String label) Ajoute une option au menu avec
le label donné et renvoie
l’élément.
• JMenuItem add(Action a) Ajoute une option de menu avec
l’action donnée et renvoie
l’élément.
• void addSeparator() Ajoute une ligne de séparation
dans le menu.
• JMenuItem insert(JMenuItem Ajoute une nouvelle option (ou
menu, int index) sous-menu) dans le menu à la
position donnée par l’indice.
• JMenuItem insert(Action a, int Ajoute une nouvelle option au
index) menu avec l’action donnée, à
l’indice spécifique.
• void insertSeparator(int index) Ajoute un séparateur au menu.
Paramètres : index Emplacement
où ajouter le séparateur.
• void remove(int index) Suppriment une option spécifique
du menu.
• void remove(JMenuItem item)
• JMenuItem(String label) Construit un élément de menu
avec un intitulé donné.
• JMenuItem(Action a) Construit un élément de menu
pour l’action donnée.

• void setAction(Action a) Définit l’action pour ce bouton ou

élément de menu.
• void setJMenuBar(JMenuBar Définit la barre de menus de la
menubar) fenêtre.
Exemple :
import javax.swing.*; 151
import javax.swing.border.TitledBorder;
import java.awt.EventQueue;
import java.awt.event.*;
public class Enregistrement extends JFrame{
//Declaration des composants
private JComboBox cboPromotion;
private JLabel
lblNom,lblPostNom,lblPromotion,lblFaculte,lblFraisTot,lblDejaPayer,l
blSolde,lblTot,lblSold;
private JTextField txtNom,txtPostNom,txtDejaPayer;
private JRadioButton optM,optF;
private JCheckBox chkFrIns,chkFrLabo,chkFrBib;
private JList lstFaculte;
private JMenuBar menuBar = new JMenuBar();
private JMenu test1 = new JMenu("Fichier");
private JMenu test2 = new JMenu("Edition");
private JMenu ouvrir = new JMenu("Ouvrir");
private JMenuItem fermer = new JMenuItem("Quitter");
private JMenuItem calculatrice = new JMenuItem("Calculatrice");
private JMenuItem ouv2 = new JMenuItem("Etudiant");

public Enregistrement(){
//creation de la fenetre
this.setTitle("Gestion Etudiant");
//taille de la fenetre
this.setSize(400, 570);
152
//fermer le processus avec le bouton fermer

//empecher de redimensionner la fenetre
this.setResizable(false);
//center la fenetre
//Instanciation des composants
lblNom=new JLabel("Nom:");
lblPostNom=new JLabel("Postnom:");
lblPromotion=new JLabel("Promotion:");
lblFaculte=new JLabel("Faculte:");
lblFraisTot=new JLabel("Total:");
lblDejaPayer=new JLabel("Deja Payer:");
lblSolde=new JLabel("Votre Solde:");
lblSold=new JLabel();
lblTot=new JLabel();
//lblTitre=new JLabel("Informations concernant l'etudiant");
txtNom=new JTextField();
txtPostNom=new JTextField();
txtDejaPayer=new JTextField();
optM=new JRadioButton("Masculin");
optF=new JRadioButton("Feminin");
cboPromotion=new JComboBox(promotion);

String [] faculte={"Gestion
Informatique","Psychologie","Theologie","Agronomie","Education"};
lstFaculte=new JList(faculte);
chkFrIns=new JCheckBox("Frais Inscription");
chkFrLabo=new JCheckBox("Frais Laboratoire Inforamatique");
153
chkFrBib=new JCheckBox("Frais Bibliotheque");

//dimension des composants
lblNom.setPreferredSize(new Dimension(100,30));
lblPostNom.setPreferredSize(new Dimension(100,30));
lblPromotion.setPreferredSize(new Dimension(100,30));
lblFaculte.setPreferredSize(new Dimension(100,30));
lblFraisTot.setPreferredSize(new Dimension(100,30));
lblDejaPayer.setPreferredSize(new Dimension(100,30));
lblSolde.setPreferredSize(new Dimension(100,30));
lblSold.setPreferredSize(new Dimension(100,30));
lblTot.setPreferredSize(new Dimension(100,30));
lstFaculte.setPreferredSize(new Dimension(387,110));
txtNom.setPreferredSize(new Dimension(280,30));
txtPostNom.setPreferredSize(new Dimension(280,30));
Font police=new Font("Times New Roman",Font.ITALIC,22);
Font polic=new Font("Times New Roman",Font.ITALIC,20);
lstFaculte.setBorder(BorderFactory.createTitledBorder(null,"Faculte",
TitledBorder.DEFAULT_JUSTIFICATION,TitledBorder.DEFAULT_POSITIO
N,polic,Color.orange));
// lblTitre.setFont(polic);
lblNom.setFont(police);
lblPostNom.setFont(police);
txtNom.setFont(police);
txtPostNom.setFont(police);

optM.setFont(polic);
optF.setFont(polic);
lstFaculte.setFont(polic);
JPanel panlbl=new JPanel(),pantxt=new JPanel(),panAutres=new
JPanel(),pansex=new JPanel(),panlst=new JPanel();
154
// pantitre.setPreferredSize(new Dimension(400,30));
panlbl.setPreferredSize(new Dimension(100,30));
pantxt.setPreferredSize(new Dimension(387,80));
pansex.setPreferredSize(new Dimension(387,50));
panAutres.setPreferredSize(new Dimension(1,30));
// pantitre.setBorder(BorderFactory.createLineBorder(Color.BLUE));
//pantitre.add(lblTitre);
panlbl.add(lblNom);
panlbl.add(txtNom);
panlbl.add(lblPostNom);
panlbl.add(txtPostNom);
pantxt.add(optM);
pantxt.add(optF);
panlst.add(lstFaculte);
//Groupe de boutons
bg.add(optM);
bg.add(optF);
bg.add(optM);
bg.add(optF);
optM.setSelected(true);
pantxt.setBorder(BorderFactory.createTitledBorder(null, "Sexe de
l'etudiant", TitledBorder.DEFAULT_JUSTIFICATION,
TitledBorder.DEFAULT_POSITION, police, Color.BLUE));

// this.add("North", pantitre);
this.setContentPane(panlbl);
this.add("Center", pantxt);
this.add(panlst, rootPane);
this.add("East", panAutres);
155
//On initialise nos menus

this.setJMenuBar(menuBar);
menuBar.add(test1);
menuBar.add(test2);
//sous menus
test1.add(ouvrir);
// ajouter le separateur
test1.addSeparator();
test1.add(fermer);
//sous sous-menu
ouvrir.add(calculatrice);
ouvrir.addSeparator();
ouvrir.add(ouv2);
//mnemonic
//test1.setMnemonic('F');
test2.setMnemonic('E');
//Declarer une action fermer
Action exitAction=new AbstractAction("fermer"){
public void actionPerformed(ActionEvent event){
System.exit(0);
}
};
//ajout de l'action
fermer.setAction(exitAction);

Action ouvAction=new AbstractAction("Calculer"){

Cal c=new Cal();
}
};
156
calculatrice.setAction(ouvAction);
menuBar.setFont(polic);
//rendre visible
}
}
L'action attachée au JMenutItem « Fermer » permet de quitter
l'application.
Découvrez le résultat en exécutant le code.
Les raccourcis clavier
À nouveau, il est très simple d'insérer des raccourcis clavier. Pour
ajouter un « accélérateur » (raccourcis clavier des éléments de
menu) sur un JMenu, nous appellerons la méthode setAccelerator(); et
pour ajouter un mnémonique (raccourcis permettant de simuler le clic
sur un point de menu) sur un JMenuItem, nous nous servirons de la
méthode setMnemonic();.
Attribuons le mnémonique « F » au menu « Fichier » et le mnémonique
« E » pour le menu «Edition ». Vous allez voir, c'est très simple : il vous
suffit d'invoquer la méthode setMnemonic(char mnemonic); sur le JMenu
que vous désirez.
Ce qui nous donne, dans notre cas :
//mnemonic
//test1.setMnemonic('F');
test2.setMnemonic('E');

Nous avons à présent les lettres correspondant au mnémonique

soulignées dans nos menus. Et il y a mieux : si vous tapez ALT + <la
lettre>, le menu correspondant se déroule ! La figure suivante
correspond à ce que j'obtiens.
Sachez que vous pouvez aussi mettre des mnémoniques sur les objets
157
JMenuItem.
Pour ajouter des accélérateurs, c'est quasiment pareil, si ce n'est que
nous devrons utiliser un nouvel objet : KeyStroke.
Cet objet permet de déterminer la touche utilisée ou à utiliser. C'est
grâce à cet objet que nous allons pouvoir construire des combinaisons de
touches pour nos accélérateurs ! Nous allons commencer par attribuer
un simple caractère comme accélérateur à notre JMenuItem « Calculer
» en utilisant la méthode getKeyStroke(char caracter); de l'objet
KeyStroke.
(vous aurez besoin des packages javax.swing.KeyStroke et
java.awt.event.ActionEvent) :
//Cette instruction ajoute l'accélérateur 'c' à notre objet
Calculatrice.setAccelerator(KeyStroke.getKeyStroke('c'));
Testez votre application, un petit « c » est apparu à côté du menu «
Lancer ».
La figure suivante illustre le phénomène.
Appuyez sur la touche « c » de votre clavier : celle-ci a le même effet
qu'un clic sur le menu « Lancer » !
Attention : si vous mettez le caractère « C », vous serez obligés
d'appuyer simultanément sur SHIFT + c ou d'activer la touche MAJ !
Si le principe est bon, dites-vous aussi que maintenant, presser la touche
c lancera systématiquement votre animation !

C'est l'une des raisons pour laquelle les accélérateurs sont, en général,
des combinaisons de touches du genre CTRL + c ou encore CTRL + SHIFT
+ S.
Pour cela, nous allons utiliser une méthode getKeyStroke() un peu
différente : elle ne prendra pas le caractère de notre touche en
158
argument, mais son code ainsi qu'une ou plusieurs touche(s) composant

la combinaison. Pour obtenir le code d'une touche, nous utiliserons
l'objet KeyEvent, un objet qui stocke tous les codes des touches !
Dans le code qui suit, je crée un accélérateur CTRL + L pour le menu «
Lancer » et un accélérateur CTRL + SHIFT + A pour le menu « Arrêter »:
lancer.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_L,
KeyEvent.CTRL_MASK));
animation.add(lancer);
//Ajout du listener pour arrêter l'animation
arreter.addActionListener(new StopAnimationListener());
arreter.setEnabled(false);
arreter.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,
KeyEvent.CTRL_DOWN_MASK + KeyEvent.SHIFT_DOWN_MASK));
animation.add(arreter);
Menus contextuels
Un menu contextuel est un menu qui n’est pas attaché à une barre de
menus, mais qui flotte à l’intérieur d’une fenêtre.
Vous créez un menu contextuel comme n’importe quel autre menu,
sachant qu’il ne possède pas de titre :
JPopupMenu popup = new JPopupMenu();
Vous ajoutez ensuite les options comme à l’accoutumée :
JMenuItem item = new JMenuItem("Cut");

Nous avons parfaitement le droit de le faire : plusieurs objets peuvent

écouter un même composant et plusieurs composants peuvent avoir le
même objet qui les écoute !
Vous êtes presque prêts à créer votre menu contextuel, il ne vous
manque que ces informations :
159
 comment indiquer à notre panneau quand et où afficher le menu

contextuel ;
 comment lui spécifier qu'il doit le faire uniquement suite à un clic
droit.
Le déclenchement de l'affichage du pop-up doit se faire lors d'un clic de
souris. Vous connaissez une interface qui gère ce type d'événement:
l'interface MouseListener. Nous allons donc indiquer à notre panneau
qu'un objet du type de cette interface va l'écouter !
Tout comme dans le chapitre sur les zones de saisie, il existe une classe
qui contient toutes les méthodes de ladite interface : la classe
MouseAdapter. Vous pouvez implémenter celle-ci afin de ne redéfinir
que la méthode dont vous avez besoin ! C'est cette solution que nous
allons utiliser.
Si vous préférez, vous pouvez utiliser l'événement mouseClicked, mais je
pensais plutôt à mouseReleased(), pour une raison simple à laquelle
vous n'avez peut-être pas pensé : si ces deux événements sont quasiment
identiques, dans un certain cas, seul l'événement mouseClicked() sera
appelé. Il s'agit du cas où vous cliquez sur une zone, déplacez votre souris
en dehors de la zone tout en maintenant le clic et relâchez le bouton de
la souris. C'est pour cette raison que je préfère utiliser la méthode
mouseReleased(). Ensuite, pour préciser où afficher le menu
contextuel, nous allons utiliser la méthode show(Component invoker,
int x, int y); de la classe JPopupMenu.

Component invoker : désigne l'objet invoquant le menu contextuel,

dans notre cas, l'instance de Panneau.
int x : coordonnée x du menu.
int y : coordonnée y du menu.

160
Souvenez-vous que vous pouvez déterminer les coordonnées de la souris
grâce à l'objet passé en paramètre de la méthode
mouseReleased(MouseEvent event).
Je suis sûr que vous savez comment vous y prendre pour indiquer au
menu contextuel de s'afficher et qu'il ne vous manque plus qu'à détecter
le clic droit. C'est là que l'objet MouseEvent va vous sauver la mise !
En effet, il possède une méthode isPopupTrigger() qui renvoie vrai s'il
s'agit d'un clic droit.
Vous avez toutes les cartes en main pour élaborer votre menu contextuel
(rappelez-vous que nous ne gérons pas encore les nouvelles
fonctionnalités).
Procédure :
Importer JPopupMenu: import javax.swing.JPopupMenu;
Instancier les composants
//La déclaration pour le menu contextuel
private JPopupMenu jpm = new JPopupMenu();
private JMenu background = new JMenu("Couleur de fond");
private JMenu couleur = new JMenu("Couleur de texte");
private JMenuItem launch = new JMenuItem("Lancer l'animation");
private JMenuItem stop = new JMenuItem("Arrêter l'animation");
11) La JProgressBar
Ce composant est utilisé pour informer l’utilisateur sur la progression
d’une action lancée dans l’application. Il affiche cette information sous

la forme d’une zone rectangulaire, qui sera plus ou moins remplie en

fonction de l’état d’avancement de l’action exécutée.
La position de la barre de progression est contrôlée par la méthode
setValue. Cette méthode accepte un argument pouvant évoluer entre les
deux extrêmes indiqués par les méthodes setMinimum et setMaximum.
161
Elle vous permet de réaliser une barre de progression pour des

traitements longs.
Voici le code source :
//CTRL + SHIFT + O pour générer les imports nécessaires
public class Progress extends JFrame{
private Thread t;
private JProgressBar bar;
private JButton launch ;
public Progress(){
this.setSize(300, 80);
this.setTitle("*** JProgressBar ***");
t = new Thread(new Traitement());
bar = new JProgressBar();
bar.setMaximum(500);
bar.setMinimum(0);
bar.setStringPainted(true);
this.getContentPane().add(bar, BorderLayout.CENTER);
launch = new JButton("Lancer");
launch.addActionListener(new ActionListener(){
t = new Thread(new Traitement());
t.start();

}
});
this.getContentPane().add(launch, BorderLayout.SOUTH);
t.start();
162
}
class Traitement implements Runnable{
public void run(){
launch.setEnabled(false);
for(int val = 0; val <= 500; val++){
bar.setValue(val);
try {
t.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
}
}
launch.setEnabled(true);
}
}
public static void main(String[] args){
Progress p = new Progress();
}
}
Exercices d’application
Réalisez de manière événementielle le diagramme de classe modélisant
la gestion du personnel (permanent et journalier) d’une entreprise X,
ainsi qu’une ébauche de code en Java y ajoutant soigneusement les

propriétés, méthodes, constructeurs, accesseurs et mutateurs.

N’oubliez pas les relations entre les classes. Le programme devra
permettre :
 La saisie des coordonnées de chaque membre du personnel ;
 Calculer l’ancienneté (en année) de chacun ;
163
 Calculer le salaire de base de chacun selon les catégories du

personnel tout en connaissant que les journaliers n’ont pas
de salaire de base ;
 Calculer le salaire net de chacun en fonction des avantages
dû à l’état civil et au nombre d’enfants : les avantages sont
libellés de la manière suivante :
 Une prime de 5% du salaire de base est accordée par
enfant ;
 Les célibataires n’ont aucun avantage tandis que : les
mariés bénéficient d’un avantage de 2%, les divorcé(e)s
1% et les veuf (ve)s 3% du salaire de base.
 Une prime de 4% du salaire de base est accordée aux
employés ayant une ancienneté de plus de 10 ans.
CHAPITRE III
JAVA ET LES BASES DE DONNEES
Dans ce chapitre, nous ferons nos premiers pas avec Java DataBase
Connectivity, communément appelé JDBC. Il s'agit en fait de classes
Java permettant de se connecter et d'interagir avec des bases de
données. Mais avant toute chose, il nous faut une base de données ! Nous
allons donc nous pencher sur l'utilité d'une base de données et verrons
comment en installer une que nous utiliserons afin d'illustrer la suite de

cette partie. Pour commencer, je pense qu'un petit rappel sur le

fonctionnement des bases de données s'impose.
3.1 Rappels sur les bases de données et accès aux bases de données
Lorsque vous réalisez un logiciel, un site web ou quelque chose
d'autre, vous êtes confrontés tôt ou tard à cette question : « Comment
164
vais-je procéder pour sauvegarder mes données ? Pourquoi ne pas tout

stocker dans des fichiers ? » Les bases de données (BDD) permettent de
stocker des données. Mais concrètement, comment cela fonctionne-t-il?
En quelques mots, il s'agit d'un système de fichiers contenant les données
de votre application. Cependant, ces fichiers sont totalement
transparents pour l'utilisateur d'une base de données, donc totalement
transparents pour vous ! La différence avec les fichiers classiques se
trouve dans le fait que ce n'est pas vous qui les gérez : c'est votre BDD
qui les organise, les range et, le cas échéant, vous retourne les
informations qui y sont stockées. De plus, plusieurs utilisateurs peuvent
accéder simultanément aux données dont ils ont besoin, sans compter
que de nos jours, les applications sont amenées à traiter une grande
quantité de données, le tout en réseau. Imaginez-vous gérer tout cela
manuellement alors que les BDD le font automatiquement… Les données
sont ordonnées par « tables », c'est-à-dire par regroupements de
plusieurs valeurs. C'est vous qui créerez vos propres tables, en spécifiant
quelles données vous souhaiterez y intégrer. Une base de données peut
être vue comme une gigantesque armoire à tiroirs dont vous spécifiez les
noms et qui contiennent une multitude de fiches dont vous spécifiez
aussi le contenu.
Si on compare un peu en imaginaire, la BDD symbolise l'armoire, chaque
table représente un tiroir et chaque ligne de la table correspond à une
fiche de ce tiroir ! De plus, ce qui est formidable avec les BDD, c'est que
vous pouvez les interroger en leur posant des questions via un langage

précis. Vous pouvez interroger votre base de données en lui donnant les
instructions suivantes :
 « Donne-moi la fiche de la table Personne pour le nom Alphée»;
 « Donne-moi la fiche de la table Pays pour le pays RDC» ;
 etc.
165
Une base de données est une collection des fichiers dans lesquels sont
stockées des données relatives à un sujet donné. Ces fichiers sont
communément appelés tables. La création et la gestion d’une base de
données sont réalisées par un logiciel appelé SGBD (Système de Gestion
des Bases de Données). Selon les relations qui existent entre les tables
d’une base de données, on peut distinguer :
 les bases de données relationnelles;
 les bases de données hiérarchiques
 etc.
A chaque type de base de données correspond un SGBD. Dans ce cours,
nous allons nous intéresser aux SGBD relationnelles. Il existe plusieurs
SGBD relationnelles dont nous citons : MS Access, MySQL, MS SQL Server,
Oracle, Dbase, PostgreSQL, … Chacune de ces bases de données possède
des spécificités : certaines sont payantes (Oracle), d'autres sont plutôt
permissives avec les données qu'elles contiennent (MySQL), d'autres
encore sont dotées d'un système de gestion très simple à utiliser
(MySQL), etc. C'est à vous de faire votre choix en regardant par exemple
sur Internet ce qu'en disent les utilisateurs. Pour cette partie traitant
des bases de données, mon choix s'est porté sur MySQL qui est gratuit et
complet.
Si vous voulez créer une application de gestion, vous aurez besoin de
deux logieciels :
 Un langage de programmation à l’estar de C++, JAVA, Visual Basic,
PHP, C#, Python, Delphi, Mathab, F#, J#, …

 Un SGBD qui vous permettra de créer et de gérer la base de

données en vue d’assurer la persistance des données.
Une fois qu’une base de données est créée par le biais d’un SGBD, il faut
créer la connexion de cette base de données avec votre interface. En
java, nous nous connectons aux bases de données avec Java Database 166
Connectivity (JDBC). Il s’agit d’une classe java permettant de se

connecter et d’interagir avec les bases de données. Il existe un JDBC
java pour chaque SGBD. Ceci veut dire que si vous voulez vous connecter
à une base de données, il faut connaître le SGBD qui l’a crée et disposer
du JDBC approprié. Les JDBC java ne sont pas fournis par defaut avec le
JDK ni avec les IDE.
En sommes, rappelons que le langage permettant d'interroger des
bases de données est le langage SQL (Structured Query Language ou, en
français, « langage de requête structurée »). Grâce aux BD, vos données
sont stockées, classées par vos soins et identifiables facilement sans
avoir à gérer votre propre système de fichiers. Pour utiliser une BD, vous
avez besoin de deux éléments : la base de données et ce qu'on appelle
le SGBD (Système de Gestion de Base de Données). Cette partie ne
s'intéresse pas au langage SQL (ou algèbre relationnelle, Cf. cours de
techniques de banque de données et/ou Méthodologie d’analyse
informatique).
Il faut les télécharger avant de les utiliser. Rappelons que dans le cadre
de ce cours, nous allons travailler avec le SGBD MySQL.
3.2. Connexion java -MySQL
Voici les taches que nous ferons pour connecté java à MySQL :
1. Création de notre base de données, dans notre SGBD en utilisant
son interface graphique qui est le PhpMyAdmin.
2. Création de la connexion à partir entre Netbeans et MySQL

3. Nous allons maintenant faire des instructions SQL comme select,

insert, update dans la base de donnée à partir de Netbeans.
Outils à avoir:
1) Nous dévons avoir une connexion MySQL et java, qu’on appelle
MySQL connector/J, il est gratuit en téléchargement
167
2) Netbeans avec un JRE (Java runtime Environment)

Je suppose qu’un étudiant de G3 sait déjà créer une base de données
MYSQL. Pour ajouter le connecteur en son projet, il procedera comme
suit :
Au niveau du menus librairies (Bibliothèques), faisons y un clic droit et
sélectionnons « add a jar/folder » (Ajouter un fichier JAR ou un
Dossier) et parcourrons le chemin où se trouve notre petit fichier qui
nous servira de connecteur « mysql-connector-java-5.1.23-bin.jar». Et
vous verrez que votre fichier est ajouté dans la liste de la librairie. Ou
si vous n‘avez pas ce fichier, faite un clic droit sur « librairie » puis
sélectionnez « add a library »(Ajouter une Bibliothèque) et portez-
vous sur « Mysql JDBC Driver » (Pilotes JDBC MySQL) et cliquez enfin
« add library » (Ajouter une Bibliothèque)
Soit la base de données nommée « Ges_Inscription » ayant les tables
suivantes, conformément au MPD suivant (conception en PowerAMC) :

168
Pour illustrer la création de notre projet au complet, nous avons trois

couches :
La couche métier matérialisée par la classe Personne (une
classe abstraite), la classe Etudiant, Section, Option, Inscription,
Promotion et Année académique et éventuellement l’interface
(pour les opérations distribuées) ;
La couche interface utilisateur pour saisir et afficher les
données ;
La couche base de données permettant de stocker et récupérer
les données de la base de données.
A. Couche métier
A cette occasion, rappelons qu’une classe abstraite est une classe ne

pouvant pas être instanciée, autrement dit on ne peut pas créer d’objets
à partir de ce moule. Elle sert à créer des classes dérivées, en clair,
cette classe va seulement servir de base (une classe mère) pour des
classes qui vont lui dériver.
Le mot clé abstract sert à dire qu’une classe est abstraite.

Comme pour notre exemple sur la gestion des inscriptions, un Etudiant

est une Personne et nous aurons besoin des objets Etudiant dans notre
programme ; mais nous n’aurons pas à utiliser les objets Personne, car
la classe abstraite est non instanciable. Donc, notre classe Personne va
nous aider à rassembler les propriétés de la classe Etudiant, comme elle
169
hérite de la classe Personne.

Ci-dessous, les instructions JAVA de création de la couche métier, pour
les classes Personne et Etudiant héritant de la classe Personne:
1. Classe Personne
package basededonnees;
import java.time.LocalDate;
import java.util.Date;
public abstract class Personne {
/*Les propriétés
* *****************
*/
private String nom;
private String postnom;
private String prenom;
private String genre;
private LocalDate dateNaiss;
private String nationalite;
/*Les méthodes
* ******************
*/
//1. methode pour calculer l'age
public int calculAge(int anneeEnCours)
{
return anneeEnCours - this.getDateNaissance().getYear();
}
//Constructeurs
public Personne() { }
public Personne(String n, String postn, String pren, String gr,
LocalDate daten,String nat)

{
this.nom = n;
this.postnom= postn;
this.prenom = pren;
this.dateNaiss = daten;
this.genre = gr;
170
this.nationalite = nat;
}
//Accesseurs
public String getNom()
{
// TODO: implement
return this.nom;
}
public String getPostNom()

{
// TODO: implement
return this.postnom;
}
public String getPrenom()

{
// TODO: implement
return this.prenom;
}
public String getGenre() { return this.genre; }
public String getNationalite() { return this.nationalite; }
public LocalDate getDateNaissance()
{
// TODO: implement
return this.dateNaiss;
}
//Mutateurs
public void setNom(String sonNom)
{

// TODO: implement
this.nom = sonNom;
}
public void setPostNom(String sonPostNom)

{
171
// TODO: implement
this.postnom = sonPostNom;
}
public void setPrenom(String sonPrenom)

{
// TODO: implement
this.prenom = sonPrenom;
}
public void setGenre(String genre) { this.genre = genre; }
public void setNationalite(String natio) { this.nationalite = natio;
}
public void setDateNaissance(LocalDate saDateNaiss)
{
// TODO: implement
this.dateNaiss = saDateNaiss;
}
//Methode qui retourne la categorie
public String trouverCategorie(int age){
String categ="";
int lesages[]={0,5,12,18,25,50};
String
tabcat[]={"Bébé","Enfant","Adolescent","Jeune","Adulte","Vieux"};
int i=0;
while(i<lesages.length && age>=lesages[i]){
categ=tabcat[i];
i++;
}
return categ;
}

}
2. Classe Etudiant
public class Etudiant extends Personne{

172
// TODO: implement les propriétés
private String matricule;
private String institutOrigine;
private String sectionOrigine;
private String optionOrigine;
//Constructeur
public Etudiant() {
super.setNom("");
super.setPostNom("");
super.setPrenom("");
super.setGenre("Masculin");
super.setNationalite("");
}
public Etudiant(String n, String postn, String pren, String
gr,LocalDate daten,String nat,String mat,String inst,String sec,String
opt)
{
super(n,postn,pren,gr,daten,nat);
this.institutOrigine = inst;
this.sectionOrigine = sec;
this.optionOrigine = opt;
}
//accesseurs
public String getMatricule()
{
// TODO: implement
return this.matricule;
}

public String getInstitutOrigine()

{
// TODO: implement
return this.institutOrigine;
}
173
public String getSectionOrigine()
{
// TODO: implement
return this.sectionOrigine;
}
public String getOptionOrigine()

{
// TODO: implement
return this.optionOrigine;
}
public void setMatricule(String mat)

{
// TODO: implement
this.matricule=mat;
}
public void setInstitutOrigine(String institutOr)

{
// TODO: implement
this.institutOrigine=institutOr;
}
public void setSectionOrigine(String sectionOr)

{
// TODO: implement
this.sectionOrigine=sectionOr;
}
public void setOptionOrigine(String optionOr)

{
// TODO: implement
this.optionOrigine=optionOr;
}
}
174
Exercice :
Créez les autres classes pour compléter la couche métier.
B. Couche interface utilisateur
Dans cette section, je vous présente l’interface utilisateur

correspondant à la classe « Etudiant » avec toutes les propriétés et
méthodes de cette classe et celles de la classe parente (Personne).
Notons que la classe implémente une interface pour la manipulation de
nos données.
Voici l’IHM (Interface Homme-Machine) de la classe Etudiant :
C. Couche Base de données
Commençons maintenant la création de notre connexion. Importons

d’abord la classe SQL et swing juste en dessous de notre package :

import java.sql.*;
N.B : par défaut MySQL utilise le nom d‘utilisateur « root » et cela sans
mot de passe. Si vous en avez besoin, vous pouvez toujours le créer dans
PhpMyAdmin, privilège. Nous aurons besoin de cela pour la création de
175
notre base de données.

Sélection des données :
Pour sélectionner les données nous allons utiliser l‘instruction sql «
select »
Comme suit : select * from table. Avant de faire notre instruction SQL,
commençons par déclarer deux variables : L‘un contiendra notre
instruction et l‘autre contiendra le résultat de notre requête.
Statement Requete;
ResultSet Resultat;
Après cela créons notre instruction
// on affecte la connexion a notre instruction
Requete=con.createStatement();
// on affecte notre instruction au resultat
Resultat=Requete.executeQuery("select * from Personne");
// on fait une boucle pour tout sélectionner
while(Resultat.next()){
//on affiche le résultat
System.out.println("Id:"+Resultat.getString("numero")+"Nom:"+Resultat
.getString("nom")+"Postnom:"+Resultat.getString("postnom"));
}
N.B : dans l‘affichage de donnée, ce qui est dans le cote « " " » sont des
étiquettes, donc vous pouvez écrire n‘importe quoi, mais ce qui est dans
« ("") » sont les noms de champs de notre table « Personne », donc si
vous l‘écrivez trop mal il y aura une erreur qui sera affiché.

Insertion des données

Pour insérer les données, il faut utiliser la requête sql « insert into table
values(‘valeur1’, ‘valeur2’, …) ».
NB : Nous utilisons ici la commande executeUpdate qui est appropriée
pour les instructions INSERT, UPDATE et DROP.
176
Nous utilisons le patron de conception « Singleton » dans la création de

notre objet connexion.
1. Classe qui crée la connexion
La classe suivante permet de nous connecter à la base de données :
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnexBD {
private static Connection con;
static JOptionPane msgbox= new JOptionPane();
static Connection meConnecter(){
try{
// appel a la classe qui gere la connexion
Class.forName("com.mysql.jdbc.Driver");
//Etablir la connexion
con=DriverManager.getConnection("jdbc:mysql://localhost/ges_Inscrip
tion?user=root&password=");
}catch(ClassNotFoundException ex){
msgbox.showMessageDialog(null,ex.getMessage());
}catch(SQLException e){
msgbox.showMessageDialog(null, e.getMessage());

}return con;
}
}
2. Interface des opérations à réaliser sur l’étudiant
177
import java.util.List;
/**
*
* @author power tech
*/
public interface iOperation {
//Opérations sur l'inculpe
public void ajouter(Etudiant et);//pour enregistrer un étudiant
public void modifier(Etudiant et);//pour mise à jour des données d'un
étudiant
public void supprimer(Etudiant et);//pour supprimer un étudiant
public Etudiant rechercher(int matricule);//ppur rechercher un
étudiant
public List<Etudiant>ListerEtudiants(); //pour afficher la liste des
étudiants
}
3. Implémentation de l’interface
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
178
import java.util.logging.Level;
import java.util.logging.Logger;
public class Implementation implements iOperation{
Connection connex = ConnexBD.meConnecter();
JOptionPane msg= new JOptionPane();
ResultSet result;
Statement sql;
@Override
public void ajouter(Etudiant et) {
try{
try (PreparedStatement ps = connex.prepareStatement("INSERT
INTO
Etudiant(matricule,nom,postnom,prenom,datenaissance,sexe,nationali
te,institutorigine,sectionorigine,optionorigine)
VALUES(?,?,?,?,?,?,?,?,?,?)")) {
ps.setString(1,et.getMatricule());
ps.setString(2, et.getNom());
ps.setString(3,et.getPostNom());
ps.setString(4, et.getPrenom());
ps.setDate(5, Date.valueOf(et.getDateNaissance()));
ps.setString(6, et.getGenre());
ps.setString(7, et.getNationalite());

ps.setString(8, et.getInstitutOrigine());
ps.setString(9, et.getSectionOrigine());
ps.setString(10, et.getOptionOrigine());
179
if (ps.executeUpdate()==1)
msg.showMessageDialog(null,"L'étudiant "+et.getNom()+"
"+et.getPostNom()+" "+et.getPrenom()+" est enregistré(e) avec
succès!");
else
msg.showMessageDialog(null,"Echec d'enregistrement",
"Echec", JOptionPane.WARNING_MESSAGE);
}
}catch(SQLException ex){
msg.showMessageDialog(null,ex.getMessage(),"Erreur",JOptionPane.ER
ROR_MESSAGE);
}
}
@Override
public void modifier(Etudiant et) {
try {
PreparedStatement ps = connex.prepareStatement("UPDATE
Etudiant SET
nom=?,postnom=?,prenom=?,datenaissance=?,sexe=?,nationalite=?,instit
utorigine=?,sectionorigine=?,optionorigine=? WHERE matricule=?");

ps.setString(10,et.getMatricule());
ps.setString(1, et.getNom());
ps.setString(2,et.getPostNom());
ps.setString(3, et.getPrenom());
ps.setDate(4, Date.valueOf(et.getDateNaissance()));
180
ps.setString(5, et.getGenre());
ps.setString(6, et.getNationalite());
ps.setString(7, et.getInstitutOrigine());
ps.setString(8, et.getSectionOrigine());
ps.setString(9, et.getOptionOrigine());
msg.showMessageDialog(null,"La modification est faite avec
succès!");
else
msg.showMessageDialog(null,"Echec de modification", "Echec",
ps.close();
} catch (SQLException ex) {
ROR_MESSAGE);
}
}
@Override
public void supprimer(Etudiant et) {
try{
PreparedStatement ps= connex.prepareStatement ("DELETE FROM
Etudiant WHERE matricule=?");
ps.setString(1,et.getMatricule() );

msg.showMessageDialog(null,"Suppression effectuée avec
succès!");
else
msg.showMessageDialog(null,"Echec de Suppression", "Echec",
181
ps.close();
ROR_MESSAGE);
}
}
@Override
public Etudiant rechercher(String matricule) {
Etudiant unEtudiant=null;
try{
PreparedStatement ps= connex.prepareStatement ("SELECT * FROM
Etudiant WHERE matricule=?");
ps.setString(1, matricule);
ResultSet rps = ps.executeQuery();
if (rps.next()){
unEtudiant=new Etudiant
(rps.getString("matricule"),
rps.getString("nom"),
rps.getString("postnom"),
rps.getString("prenom"),
rps.getDate("datenaissance").toLocalDate(),

rps.getString("sexe"),
rps.getString("nationalite"),
rps.getString("institutOrigine"),
rps.getString("sectionOrigine"),
rps.getString("optionOrigine")
182
);
}
ps.close();
ROR_MESSAGE);
}
if (unEtudiant==null) throw new RuntimeException
("L'étudiant dont le matricule est "+matricule+" n'existe
pas.\nVeuillez entrer un Numero matricule valide!");
return unEtudiant;
}
@Override
public List<Etudiant> ListerEtudiants() {
List<Etudiant> lesEtudiants =new ArrayList<Etudiant>();
try{
sql=connex.createStatement();
result=sql.executeQuery("SELECT * FROM Etudiant");
while(result.next()){
Etudiant unEtudiant=new Etudiant

(result.getString("matricule"),

result.getString("nom"),
result.getString("postnom"),
result.getString("prenom"),
result.getDate("datenaissance").toLocalDate(),
result.getString("sexe"),
183
result.getString("nationalite"),
result.getString("institutOrigine"),
result.getString("sectionOrigine"),
result.getString("optionOrigine")
);
lesEtudiants.add(unEtudiant);
}
sql.close();
ROR_MESSAGE);
return lesEtudiants;
}
}
4. Instanciation et découverte personnelle des résultats

public class frmEtudiant extends javax.swing.JFrame {

public frmEtudiant() {
initComponents();
}
//Declaration des objets essentiels
184
iOperation metier=new Implementation();

JOptionPane msg=new JOptionPane();
Etudiant etud=new Etudiant();
@SuppressWarnings("unchecked")
private void initComponents() {
buttonGroup1 = new javax.swing.ButtonGroup();
jLabel1 = new javax.swing.JLabel();
jPanel1 = new javax.swing.JPanel();
optM = new javax.swing.JRadioButton();
optF = new javax.swing.JRadioButton();
txtMatricule = new javax.swing.JTextField();
txtNom = new javax.swing.JTextField();
txtPostnom = new javax.swing.JTextField();

txtInstOr = new javax.swing.JTextField();

txtNationalite = new javax.swing.JTextField();
txtSecOr = new javax.swing.JTextField();
txtOpOr = new javax.swing.JTextField();
dtpDateNaissance = new javax.swing.JFormattedTextField();
185
txtPrenom = new javax.swing.JTextField();

lblAge = new javax.swing.JLabel();
lblCateg = new javax.swing.JLabel();
btnAjouter = new javax.swing.JButton();
btnModifier = new javax.swing.JButton();
btnSupprimer = new javax.swing.JButton();
btnRechercher = new javax.swing.JButton();
txtRecherche = new javax.swing.JTextField();
jScrollPane2 = new javax.swing.JScrollPane();
dgEtudiant = new javax.swing.JTable();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON
_CLOSE);
setTitle("Gestion des inscriptions");
addComponentListener(new
java.awt.event.ComponentAdapter() {
public void
componentShown(java.awt.event.ComponentEvent evt) {
formComponentShown(evt);
}
});
jLabel1.setFont(new java.awt.Font("Tahoma", 1, 14)); //

NOI18N

jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CEN
TER);
jLabel1.setText("IDENTIFICATION DES ETUDIANTS");
186
jLabel1.setBorder(javax.swing.BorderFactory.createLineBorder(n
ew java.awt.Color(0, 0, 0)));

NOI18N
jLabel2.setText("Matricule");

NOI18N
jLabel3.setText("Nom");

NOI18N
jLabel4.setText("Postnom");

NOI18N
jLabel5.setText("Prenom");

NOI18N
jLabel6.setText("Date de naissance");


NOI18N
jLabel7.setText("Nationalite");
jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder
(null, "Genre",
187
javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION,
javax.swing.border.TitledBorder.DEFAULT_POSITION, new
java.awt.Font("Tahoma", 1, 12))); // NOI18N
buttonGroup1.add(optM);
optM.setFont(new java.awt.Font("Tahoma", 1, 11)); //
NOI18N
optM.setText("Masculin");
optM.addActionListener(new
java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent
evt) {
optMActionPerformed(evt);
}
});
buttonGroup1.add(optF);
optF.setFont(new java.awt.Font("Tahoma", 1, 12)); //
NOI18N
optF.setText("Feminin");
javax.swing.GroupLayout jPanel1Layout = new

javax.swing.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alig
nment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
188
.addContainerGap(103, Short.MAX_VALUE)
.addComponent(optM)
.addGap(18, 18, 18)
.addComponent(optF)
.addContainerGap())
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alig
nment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addContainerGap()
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.Group
Layout.Alignment.BASELINE)
.addComponent(optM)
.addComponent(optF))
.addContainerGap(18, Short.MAX_VALUE))
);

NOI18N
jLabel8.setText("Institut d'origine");


NOI18N
jLabel9.setText("Section d'origine");
NOI18N
189
jLabel10.setText("Option d'origine");
NOI18N
jLabel11.setText("Age");
NOI18N
jLabel12.setText("Catégorie");
txtMatricule.setBorder(javax.swing.BorderFactory.createLineBor
der(new java.awt.Color(0, 0, 0)));
txtNom.setBorder(javax.swing.BorderFactory.createLineBorder(n
ew java.awt.Color(0, 0, 0)));
txtPostnom.setBorder(javax.swing.BorderFactory.createLineBord
er(new java.awt.Color(0, 0, 0)));
txtInstOr.setBorder(javax.swing.BorderFactory.createLineBorder(
new java.awt.Color(0, 0, 0)));

txtNationalite.setBorder(javax.swing.BorderFactory.createLineB
order(new java.awt.Color(0, 0, 0)));
190
txtSecOr.setBorder(javax.swing.BorderFactory.createLineBorder(
txtOpOr.setBorder(javax.swing.BorderFactory.createLineBorder(
dtpDateNaissance.setBorder(javax.swing.BorderFactory.createLin
eBorder(new java.awt.Color(0, 0, 0)));
dtpDateNaissance.setFormatterFactory(new
javax.swing.text.DefaultFormatterFactory(new
javax.swing.text.DateFormatter(new
java.text.SimpleDateFormat("yyyy-MM-dd"))));
txtPrenom.setBorder(javax.swing.BorderFactory.createLineBorde
r(new java.awt.Color(0, 0, 0)));
lblAge.setHorizontalAlignment(javax.swing.SwingConstants.RIGH
T);

lblAge.setBorder(javax.swing.BorderFactory.createLineBorder(ne
w java.awt.Color(0, 0, 0)));
191
lblCateg.setHorizontalAlignment(javax.swing.SwingConstants.CE
NTER);
lblCateg.setBorder(javax.swing.BorderFactory.createLineBorder(
btnAjouter.setText("Ajouter");
btnAjouter.addMouseListener(new
java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt)
{
btnAjouterMouseClicked(evt);
}
});
btnModifier.setText("Modifier");
btnModifier.addMouseListener(new
{
btnModifierMouseClicked(evt);
}
});

btnSupprimer.setText("Supprimer");
btnSupprimer.addMouseListener(new
{
192
btnSupprimerMouseClicked(evt);
}
});
btnRechercher.setText("Rechercher");
btnRechercher.addMouseListener(new
{
btnRechercherMouseClicked(evt);
}
});
txtRecherche.setText("Tapez ici le matricule");

txtRecherche.setToolTipText("Tapez ici le matricule");
txtRecherche.addMouseListener(new
{
txtRechercheMouseClicked(evt);
}
public void mouseEntered(java.awt.event.MouseEvent
evt) {
txtRechercheMouseEntered(evt);

}
public void mouseExited(java.awt.event.MouseEvent evt)
{
txtRechercheMouseExited(evt);
}
193
});
jScrollPane2.setViewportView(dgEtudiant);
javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.
LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(18, 18, 18)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.
Alignment.LEADING)
.addComponent(jLabel1,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
Alignment.LEADING)

Alignment.TRAILING, false)
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
194
layout.createSequentialGroup()
.addComponent(jLabel2)
.addGap(85, 85, 85)
.addComponent(txtMatricule))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement
.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(txtPrenom,
javax.swing.GroupLayout.PREFERRED_SIZE, 144,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(114, 114, 114)
.addComponent(txtNom,

Short.MAX_VALUE)
195
.addComponent(txtPostnom,
Short.MAX_VALUE)
.addComponent(dtpDateNaissance,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addGap(2, 2, 2)
Alignment.LEADING, false)
Alignment.LEADING)

.addComponent(jLabel10))
.addGap(32, 32, 32)
196
.addComponent(txtNationalite)
.addComponent(txtInstOr)
.addComponent(txtSecOr)
.addComponent(txtOpOr,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addComponent(jPanel1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(60, 60, 60)
Alignment.TRAILING)
.addGap(18, 18, 18)
Alignment.LEADING)

.addComponent(lblAge,
.addComponent(lblCateg,
197
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))))))
.RELATED)
Alignment.LEADING)
.addComponent(btnAjouter,
.RELATED)
.addComponent(btnModifier,
javax.swing.GroupLayout.DEFAULT_SIZE, 93, Short.MAX_VALUE))
.addComponent(txtRecherche))

.UNRELATED)
198
.addComponent(btnRechercher,
.addComponent(btnSupprimer,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(0, 0, Short.MAX_VALUE))
.addComponent(jScrollPane2,
javax.swing.GroupLayout.DEFAULT_SIZE, 555,
Short.MAX_VALUE))))
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.
LEADING)
.addContainerGap()
.addComponent(jLabel1,
.addGap(18, 18, 18)

Alignment.TRAILING)
199
Alignment.BASELINE)
.addComponent(txtMatricule,
.addGap(7, 7, 7)
Alignment.BASELINE)
.addComponent(txtNom,
.addGap(5, 5, 5)
Alignment.LEADING)
.addComponent(txtPostnom,

.RELATED)
200
Alignment.BASELINE)
.addComponent(txtPrenom,
.RELATED)
Alignment.LEADING)
.addComponent(dtpDateNaissance,
.addGap(18, 18, 18)
.addComponent(jPanel1,
.UNRELATED)

Alignment.BASELINE)
.addComponent(txtNationalite,
201
.RELATED)
Alignment.BASELINE)
.addComponent(txtInstOr,
.RELATED)
Alignment.BASELINE)
.addComponent(txtSecOr,

.RELATED)
202
Alignment.BASELINE)
.addComponent(txtOpOr,
.RELATED)
Alignment.BASELINE)
.addComponent(lblAge,
.addComponent(jLabel11)))
.addComponent(jScrollPane2,
Alignment.LEADING)

.RELATED)
203
Alignment.BASELINE)
.addComponent(lblCateg,
.addComponent(jLabel12)))
.addGap(39, 39, 39)
Alignment.BASELINE)
.addComponent(btnAjouter)
.addComponent(btnModifier)
.addComponent(btnSupprimer))
.UNRELATED)
Alignment.BASELINE)
.addComponent(btnRechercher)
.addComponent(txtRecherche,
javax.swing.GroupLayout.PREFERRED_SIZE))))

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);
204
pack();
}// </editor-fold>
private void optMActionPerformed(java.awt.event.ActionEvent

evt) {
}
private void
formComponentShown(java.awt.event.ComponentEvent evt) {
//Appel de la méthode qui affiche la liste des étudiants dans
la grille de données
this.afficherGrille();
}
//Clic sur le bouton Ajouter
private void
btnAjouterMouseClicked(java.awt.event.MouseEvent evt) {
try{
etud.setNom(txtNom.getText());
etud.setMatricule(txtMatricule.getText());
etud.setPostNom(txtPostnom.getText());

etud.setPrenom(txtPrenom.getText());
etud.setDateNaissance(LocalDate.parse(String.valueOf(dtpDateN
aissance.getText())));
if(optM.isSelected())
205
etud.setGenre(optM.getText());
else
etud.setGenre(optF.getText());
etud.setNationalite(txtNationalite.getText());
etud.setInstitutOrigine(txtInstOr.getText());
etud.setSectionOrigine(txtSecOr.getText());
etud.setOptionOrigine(txtOpOr.getText());
lblAge.setText(String.valueOf(etud.calculAge(LocalDate.now().ge
tYear()))+" Ans");
lblCateg.setText(String.valueOf(etud.trouverCategorie(etud.calc
ulAge(LocalDate.now().getYear()))));
metier.ajouter(new
Etudiant(etud.getNom(),etud.getPostNom(),etud.getPrenom(),et
ud.getGenre(),etud.getDateNaissance(),etud.getNationalite(),etu
d.getMatricule(),etud.getInstitutOrigine(),etud.getSectionOrigin
e(),etud.getOptionOrigine()));
}catch(Exception ex){
msg.showMessageDialog(null, ex.getMessage());
}
}

private void
txtRechercheMouseEntered(java.awt.event.MouseEvent evt) {
206
private void
txtRechercheMouseClicked(java.awt.event.MouseEvent evt) {
if(!txtRecherche.getText().equals(""))
txtRecherche.setText("");
}
private void
txtRechercheMouseExited(java.awt.event.MouseEvent evt) {
if(txtRecherche.getText().equals(""))
txtRecherche.setText("Tapez ici le Matricule...");
}
//CLIC SUR LE BOUTON RECHERCHER
private void
btnRechercherMouseClicked(java.awt.event.MouseEvent evt) {
try{
etud=metier.rechercher(txtRecherche.getText());
txtNom.setText(etud.getNom());
txtMatricule.setText(etud.getMatricule());
txtPostnom.setText(etud.getPostNom());

txtPrenom.setText(etud.getPrenom());
dtpDateNaissance.setText(String.valueOf(etud.getDateNaissance(
)));
if(etud.getGenre().equals(optM.getText()))
207
else
txtNationalite.setText(etud.getNationalite());
txtInstOr.setText(etud.getInstitutOrigine());
txtSecOr.setText(etud.getSectionOrigine());
txtOpOr.setText(etud.getOptionOrigine());
tYear()))+" Ans");
}
}
//CLIC SUR LE BOUTON SUPPRIMER
private void
btnSupprimerMouseClicked(java.awt.event.MouseEvent evt) {
try{

String mat=msg.showInputDialog(null,"Entrez le Numero

matricule de l'étudiant à supprimer");
etud.setMatricule(mat);
if(metier.rechercher(mat)!=null)
{
208
int rps=msg.showConfirmDialog
(null,"Voulez-vous vraiment supprimer
"+metier.rechercher(mat).getNom()+"
"+metier.rechercher(mat).getPostNom()+" ?",
"Confirmer",JOptionPane.YES_NO_OPTION);
if(rps==JOptionPane.YES_OPTION){
metier.supprimer(etud);
}
}
}
}
//CLIC SUR LE BOUTON MODIFIER
private void
btnModifierMouseClicked(java.awt.event.MouseEvent evt) {
try{
etud.setNom(txtNom.getText());
etud.setMatricule(txtMatricule.getText());
etud.setPostNom(txtPostnom.getText());
etud.setPrenom(txtPrenom.getText());

etud.setDateNaissance((LocalDate)
dtpDateNaissance.getValue());
if(optM.isSelected())
etud.setGenre(optM.getText());
else
209
etud.setGenre(optF.getText());
etud.setNationalite(txtNationalite.getText());
etud.setInstitutOrigine(txtInstOr.getText());
etud.setSectionOrigine(txtSecOr.getText());
etud.setOptionOrigine(txtOpOr.getText());
tYear()))+" Ans");
metier.modifier(new
Etudiant(etud.getNom(),etud.getPostNom(),etud.getPrenom(),et
ud.getGenre(),etud.getDateNaissance(),etud.getNationalite(),etu
d.getMatricule(),etud.getInstitutOrigine(),etud.getSectionOrigin
e(),etud.getOptionOrigine()));
}
}
//Méthode qui affiche la liste des étudiants dans la grille de
données
public void afficherGrille(){

List<Etudiant>liste=metier.ListerEtudiants();
dgEtudiant.setModel(new
javax.swing.table.DefaultTableModel(new String[]{ "Matricule",
"Nom", "Postnom", "Prenom", "Date de naissance", "Genre",
"Nationalite", "Institut d'origine", "Section d'origine", "Option
210
d'origine"}, liste.size()));
for(int i=0; i<liste.size();i++){
dgEtudiant.setValueAt(liste.get(i).getMatricule(), i,
0);
dgEtudiant.setValueAt((liste.get(i).getNom()), i, 1);
dgEtudiant.setValueAt(liste.get(i).getPostNom(), i, 2);
dgEtudiant.setValueAt(liste.get(i).getPrenom(), i,3);
dgEtudiant.setValueAt(liste.get(i).getDateNaissance(),
i, 4);
dgEtudiant.setValueAt(liste.get(i).getGenre(), i, 5);
dgEtudiant.setValueAt(liste.get(i).getNationalite(), i,
6);
dgEtudiant.setValueAt(liste.get(i).getInstitutOrigine(),
i, 7);
dgEtudiant.setValueAt(liste.get(i).getSectionOrigine(),
i, 8);
dgEtudiant.setValueAt(liste.get(i).getOptionOrigine(),
i, 9);
}
}
/**
*/
public static void main(String args[]) {

/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel
setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay
with the default look and feel.
211
* For details see

http://download.oracle.com/javase/tutorial/uiswing/lookandfe
el/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(frmEtudiant.class.getName())
.log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
} catch (IllegalAccessException ex) {

} catch (javax.swing.UnsupportedLookAndFeelException ex) {
212
}
//</editor-fold>
/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new frmEtudiant().setVisible(true);
}
});
}
// Variables declaration - do not modify

private javax.swing.JButton btnAjouter;
private javax.swing.JButton btnModifier;
private javax.swing.JButton btnRechercher;
private javax.swing.JButton btnSupprimer;
private javax.swing.ButtonGroup buttonGroup1;
private javax.swing.JTable dgEtudiant;
private javax.swing.JFormattedTextField dtpDateNaissance;
private javax.swing.JLabel jLabel1;


213

private javax.swing.JPanel jPanel1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JLabel lblAge;
private javax.swing.JLabel lblCateg;
private javax.swing.JRadioButton optF;
private javax.swing.JRadioButton optM;
private javax.swing.JTextField txtInstOr;
private javax.swing.JTextField txtMatricule;
private javax.swing.JTextField txtNationalite;
private javax.swing.JTextField txtNom;
private javax.swing.JTextField txtOpOr;
private javax.swing.JTextField txtPostnom;
private javax.swing.JTextField txtPrenom;
private javax.swing.JTextField txtRecherche;
private javax.swing.JTextField txtSecOr;
// End of variables declaration
}

Exercice : Implémentez les auters couches métiers du projet de

gestion des inscriptions
Voilà ! Finie la partie des écrans de saisies et leur interaction avec la
base de données MySQL en JAVA.
TP : Faites des recheches et créer les états de sorties personnalisés 214
en se servant de l’outil JasperReport téléchargeable sur

http://sourceforge.net/project/showfiles.php? group_id=36382&package_id=28579
Ou pdfbox. Intégrez les états de sorties dans votre projet initial de
recherche pour ce cours.
Positionnement dans un ResultSet

L’objet ResultSet gère un pointeur d’enregistrement déterminant
sur quel enregistrement vont intervenir les méthodes exécutées sur le
ResultSet lui-même.
Cet enregistrement est parfois appelé enregistrement actif ou
enregistrement courant. L’objet ResultSet contient toujours deux
enregistrements fictifs servant de repère pour le début du ResultSet
(BOF) et pour la fin du ResultSet (EOF). Le pointeur d’enregistrement
peut être positionné sur l’un de ces deux enregistrements mais jamais
avant l’enregistrement BOF ni après l’enregistrement EOF. Ces
enregistrements ne contiennent pas de données et une opération de
lecture ou d’écriture sur ces enregistrements déclenche une exception.
À la création du ResultSet le pointeur est positionné avant le premier
enregistrement (BOF). De nombreuses méthodes sont disponibles pour
gérer le pointeur d’enregistrements :
 boolean absolute(int position) : déplace le pointeur
d’enregistrement sur l’enregistrement spécifié. La numérotation
des enregistrements débute à 1. Si la valeur de l’argument position
est négative, le déplacement est effectué en partant de la fin du

ResultSet. Si le numéro d’enregistrement n’existe pas lepointeur

est positionné sur l’enregistrement BOF si la valeur est négative et
inférieure au nombre d’enregistrements ou sur l’enregistrement
EOF si la valeur est positive et supérieure au nombre
d’enregistrements. Cette méthode retourne true si le pointeur est
215
positionné sur un enregistrement valide et false dans le cas

contraire (BOF ou EOF).
 boolean relative(int deplacement) : déplace le curseur du

nombre d’enregistrements spécifié par l’argument deplacement.
Si la valeur de cet argument est positive le curseur descend dans
le jeu d’enregistrements et si la valeur est négative le curseur
remonte dans le jeu d’enregistrements. Cette méthode retourne
true si le pointeur est positionné sur un enregistrement valide et
false dans le cas contraire (BOF ou EOF).
 void beforeFirst() : déplace le pointeur d’enregistrements avant

le premier enregistrement (BOF).
 void afterLast() : déplace le pointeur d’enregistrements après le

dernier enregistrement (EOF).
 boolean first() : déplace le pointeur d’enregistrements sur le

premier enregistrement. Cette method retourne true s’il y un
enregistrement dans le ResultSet et false dans le cas contraire.
 boolean last() : déplace le pointeur d’enregistrements sur le

dernier enregistrement. Cette method retourne true s’il y un
enregistrement dans le ResultSet et false dans le cas contraire.
 boolean next() : déplace le pointeur d’enregistrements sur

l’enregistrement suivant l’enregistrement courant. Cette méthode

retourne true si le pointeur est sur un enregistrement valide et

false dans le cas contraire (EOF).
 boolean previous() : déplace le pointeur d’enregistrements sur

l’enregistrement précédant l’enregistrement courant. Cette
méthode retourne true si le pointeur est sur un enregistrement 216
valide et false dans le cas contraire (BOF).
Pour toutes ces méthodes sauf pour la méthode next, il faut

obligatoirement que le ResultSet soit de type SCROLL_SENSITIVE ou
SCROLL_INSENSIVE. Si le ResultSet est de type FORWARD_ONLY, seule la
méthode next fonctionne et dans ce cas les autres méthodes déclenchent
une exception. Les méthodes suivantes permettent de tester la position
du pointeur d’enregistrements :
 boolean isBeforeFirst() : retourne true si le pointeur est placé
avant le premier enregistrement (BOF).
 boolean isAfterLast() : retourne true si le pointeur est placé après
le dernier enregistrement (EOF).
 boolean isFirst() : retourne true si le pointeur est placé sur le
premier enregistrement.
 boolean isLast() : retourne true si le pointeur est placé sur le
dernier enregistrement.
 int getRow() : retourne le numéro de l’enregistrement sur lequel
se trouve le pointeur d’enregistrements. La valeur 0 est retournée
s’il n’y a pas d’enregistrement courant (BOF ou EOF).

Langage de Programmation - 2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Langage de Programmation - 2022

Transféré par

Droits d'auteur :

Formats disponibles

Cours de Langage de programmation, G3 Gestion Informatique, I.S.C.

ENSEIGNEMENT SUPERIEUR ET UNIVERSITAIRE

INSTITUT SUPERIEUR DE COMMERCE DE BENI

LANGAGE DE PROGRAMMATION III

Contacts: +243 992 433 801 / aiglengaingai@gmail.com

ANNEE ACADEMIQUE 2021-2022

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

La prise de décision assistée par ordinateur et l'optimisation

Songer à la source en buvant l'eau.

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

données constituent la partie passive du programme. Les procédures et

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

Avec les objets se sont les données qui deviennent prépondérantes. On

Dans le programme de cours en département de gestion informatique à

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

écrit. Notons que les services de l’Internet sont à sa portée pour

débat du groupe dans les présentations orales.

exercices en UML 2. ÉDITIONS EYROLLES 61, bd Saint-

Germain 75240 Paris Cedex05

Cysboy et John-John (2011). Apprenez à programmer en Java. Disponible

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

Fisher, T. R. (2009). Java L'essentiel du code et des commandes. Paris:

Boichat, J.-B. (2008). Apprendre Java et C++ en parallèle. Paris:

DELANNOY, C. (2008). Programmer en JAVA. Paris: Eyrolles.

Goncalves, A. (2008). Les cahiers du programmeur Java EE 5. Paris:

Delanoy, C. (2006). Exercices en Java. Paris: Eyrolles.

Divay, M. (2006). La programmation orientée objet en Java. Paris:

Divay, M. (2006). La_programmation_objet_en_java. Paris: Dunod.

Jean Michel DOUDOUX(2002). Développons en Java. Notes Inédites

Laugié, H. (2000). Java et Eclipse Développez une application Java. ENI

Haro, C. (sd). Algorithmique Raisonner pour concevoir. Paris: ENI

Rohaut, S. (sd). Algorithmique Techniques fondamentales de

programmation (exemples en PHP et en JAVA). Paris: ENI

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

INTRODUCTION A LA P.O.O.: PRINCIPES ET CONCEPTS EN JAVA

Chaque langage de programmation appartient à une « famille » de

communément appelée « paradigme de programmation ». Il existe

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

qu‘on appelle interpréteur c’est-à-dire le source est compilé en pseudo

d'exécuter des programmes Java sur tous les environnements qui

La figure suivante illustre ce fonctionnement.

Afin de simplifier la tâche de programmation, le programmeur utilise des

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

Ce chapitre est consacré à la présentation du paradigme de

utilisant le paradigme orienté objet procède en deux temps :

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

de distribution des responsabilités on ne peut plus simple, chaque objet

décentralisée. Pour autant qu’elle respecte également des principes de

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

l’écriture de programmes, les rendant plus gérables, plus

A fortiori, cette découpe sera d’autant plus intuitive qu’elle s’inspire de

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

idéalement, sera aussi simple à créer qu’à maintenir, récupérer et faire

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

Pour mieux programmer dans un langage orienté objet, le programmeur

I.2. Principes et concepts de la P.O.O. en Java

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

dans les propriétés des classes.

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

Les comportements appelés « méthodes », sont les traitements, les

© MUHINDO NGAINGAI ALPHEE, Chef de Travaux

de type alpha numérique, l’année de naissance est du type entier et

associés et à en contrôler l'accès. Les classes constituent l'un des moyens