C.T.

Josué MISSWAY KINDIA

[Link] ATANDELE

PROGRAMMATION DES APPLICATIONS DESKTOPS

(LE LANGAGE JAVA)
A l’usage des étudiants en Informatique et des passionnés
de développement d’applications

Novembre 2025
 P age |2

« La grandeur d’un chercheur se mesure par l’esprit de

créativité qu’il regorge et qui fait jaillir la lumière »
 P age |1

INTRODUCTION
Ce cours de programmation des applications Desktop
est destiné aux étudiants de deuxième licence en
informatique de gestion. Son intérêt réside par le fait
qu’actuellement, les applications Desktop accusent une forte
performance par rapport aux applications web et mobile.

Il est crucial pour les étudiants d’apprendre la

programmation desktop à travers le langage Java d’autant
plus qu’il tourne sur plusieurs systèmes d’exploitation.

En outre, Java est l’un des langages de programmation

les plus populaires et largement utilisés dans le monde.
D’où la nécessité pour les étudiants d’apprendre ce langage,
en effet, il va les aider à répondre présent face à la
compétition qu’engendre la mondialisation.

Les passionnés ou les initiés en programmation Java

y tireront également des bienfaits, dans la mesure où,
beaucoup de cas d’école accompagnent les différents
chapitres.

En effet, le but de ces notes de cours est de donner

un premier aperçu sur Java en ne présentant que tout ce qui
est nécessaire de connaître, pour bien développer les
applications Desktop java, aussi bien en mode console qu’en
mode graphique.

Il sied par ailleurs de signaler que Java comprend

bien d’autres aspects de développement (applets,
programmation réseau, multitâches).

Le développement de ce cours est structuré autour de

cinq chapitres, de valeur non négligeable, à savoir :

 Le premier chapitre introduit les applications Desktop

et présente le langage Java ;
 Le deuxième chapitre pour sa part, explique les bases
du Java ;
 P age |2

 Le troisième chapitre aborde la structure du langage

java ;
 Le quatrième chapitre gravitera autour de l’interface
graphique en Java à travers l’éditeur Netbeans.
 Le cinquième et dernier chapitre tachera de connecter
Java avec une base de données externe.

I. METHODE EXPLOITEE :

Le cours sera dispensé en appliquant la méthode

interro-active pour une formation intégrale de
l’étudiant, donc ce dernier sera lui-même au centre de sa
formation et il aura deux volets dont :

II. STRATEGIES D’EVALUATION :

L’évaluation comprendra des travaux pratiques,

interrogation et examen écrits.

III. BIBLIOGRAPHIE

a) Ouvrages

Boichat, JB., Apprendre Java et C++ en parallèle, 4ème

édition, Eyrolles, Paris, 2008.

Claude, D., Exercice en Java 5.0, 2ème édition Eyrolles,

Paris, 2006.

DJUNGU, SJ, Outils et langages du Web n.0, Ed. CRIA,

Kinshasa, 2013.

MUKENGE, J., Le Langage Java et nous, 1ère édition,

CRIGED, Kinshasa, Octobre 2012.

b) Notes de cours

Gautier, P., Cours d’initiation à la programmation

orienté-objet avec le langage Java, Pôle informatique,
ENSM Saint-Etienne, 2013-2014.
 P age |3

KANGA, E., Cours des questions spéciales de

programmation avancée, L1 Info, ISCBDD, 2016-2017.

MISSWAY, J., Cours d’Informatique de Gestion, G3 SCF,

ISC-BDD, 2015-2016.

MISSWAY, J., Cours de Technique de base de données, G3

Info, ISC-BDD, 2015-2016.

MISSWAY, J., cours de langage de programmation

III(Java), G3 info, ISC-BDD, 2016-2017.

MUKENGE, J., Cours de Java, G3 Info, ISC Kin, 2014-2015.

c) Sites consultés

1. [Link]
2. [Link]
[Link]
3. [Link]
 P age |4

CHAPITRE I : NOTIONS GENERALES DE LA PROGRAMMATION

DESKTOP ET DU LANGAGE JAVA
I. La programmation desktop
Une application desktop ou application de bureau est
un logiciel conçu pour être exécuté sur un ordinateur sans
avoir besoin d’accéder à internet ou à un réseau privé.
Le développement d’applications desktop se distingue
par sa capacité à offrir des performances optimales et une
intégration poussée avec les ressources matérielles de
l’ordinateur. Les applications desktop sont cruciales pour
de nombreuses entreprises et utilisateurs finaux, offrant
une stabilité et une performance souvent supérieures aux
applications web.
1.1. Définition
La programmation desktop est un domaine du
développement logiciel où l'objectif est de concevoir des
applications qui s'exécutent localement sur un ordinateur,
sans dépendre nécessairement d'une connexion Internet. Ces
applications peuvent inclure des outils de productivité, des
jeux ou des logiciels métiers. Java, en tant que langage de
programmation polyvalent, joue un rôle clé dans ce domaine.

Son objectif est de créer des applications pouvant

s’exécuter localement sur des systèmes d’exploitation tels
que Windows, MacOs ou linux.

Pour pouvoir développer une application de ce genre,

il est important de bien choisir un langage de programmation
qui nous met à l’aise. Pour notre cas, on va utiliser le
langage Java. Avec sa syntaxe claire, sa portabilité et sa
vaste bibliothèque standard, Java fait partie des langages
de programmation les plus utilisés dans de nombreux
domaines.

1.2. Outils et technologies

Il existe de nombreux langages de programmation
et des principaux Frameworks pour faire de la
programmation desktop, les plus souvent utilisés sont :
 P age |5

- JavaFX &Swing (Java) : interface riche pour application

java ;
- .NET (Windows forms, WPF, etc.) : développement rapide
et interface moderne pour Windows ;
- Electron (JavaScript, HTML, CSS) : application web
packagées en Desktop (VS CODE) ;
- Etc.
Evidemment, il existe de nombreux Environnement de
Développement intégré, comme Visual Studio, PyCharm,
Xcode, Vs code, IntelliJ IDEA, NetBeans, etc.

1.3. Avantages et inconvénients de la programmation

desktop
La programmation desktop reste un domaine clé du
développement logiciel, bien qu'elle soit parfois éclipsée
par les applications web et mobiles. Elle présente des
avantages et des inconvénients liés à son mode d’exécution,
ses besoins matériels et son interopérabilité.

a) Avantages
 Performance et rapidité : les applications desktop
fonctionnent localement, ce qui élimine la dépendance
à une connexion Internet. Elles offrent des performances
supérieures pour des tâches gourmandes en ressources
(ex. : montage vidéo, jeux, logiciels de conception).
 Accès aux ressources matérielles : Les applications
desktop peuvent exploiter pleinement les capacités
matérielles de l’ordinateur, telles que le processeur,
la mémoire, la carte graphique ou les périphériques.
 Sécurité et confidentialité : Contrairement aux
applications web, les données des applications desktop
restent généralement locales, ce qui limite les risques
d'exposition en ligne. Elles sont moins exposées aux
attaques réseau.
 Personnalisation et spécialisation : Les logiciels
desktop sont souvent conçus pour des besoins
 P age |6

spécifiques, comme les logiciels de gestion

d'entreprise (ERP, CRM) ou les outils métiers
spécialisés. Les interfaces peuvent être conçues pour
répondre à des cas d’utilisation précis.
 Disponibilité hors ligne : Les applications desktop ne
nécessitent pas d’accès Internet pour fonctionner,
offrant une disponibilité totale.
 Stabilité à long terme : Une fois installée, une
application desktop ne dépend pas d’un serveur distant
pour fonctionner, réduisant ainsi les problèmes liés à
la maintenance côté serveur.

b) Inconvénients
 Dépendance au système d'exploitation : Les applications
desktop doivent être compatibles avec des plateformes
spécifiques (Windows, macOS, Linux), ce qui peut
nécessiter des efforts supplémentaires pour la
portabilité.
 Installation et maintenance : Les utilisateurs doivent
télécharger, installer et parfois mettre à jour
manuellement les applications.
 La gestion des versions et des dépendances peut être
complexe.
 Coût de développement : Développer des applications
natives pour plusieurs systèmes d’exploitation peut
être coûteux et nécessiter des ressources
supplémentaires.
 Moins de flexibilité pour l'accès à distance :
Contrairement aux applications web, les applications
desktop ne sont pas accessibles depuis n’importe quel
appareil ou lieu sans installation préalable.
 Poids sur le matériel : Les applications desktop peuvent
consommer beaucoup d'espace disque et de ressources
système, ce qui peut poser problème sur des machines
moins puissantes.
 Mises à jour et support utilisateur : Les utilisateurs
doivent mettre à jour les logiciels manuellement ou via
 P age |7

des mécanismes intégrés, ce qui peut être un obstacle

pour certains. Les développeurs doivent gérer les bogues
et problèmes sur différents environnements utilisateur.

1.4. Comparaison avec d’autres types de programmation

Le tableau ci-dessous présente quelques aspects
différentiant la programmation desktop des autres types
de programmation :
Aspect Application Application Application
desktop web mobile
performance Excellente Dépend de la Dépend des
connexion ressources de
internet l’appareil
Accessibilité Limitée au Partout via Accessible via
périphérique un téléchargement
sur lequel est navigateur
installée
l’application
Cout de Elevé Moindre Moyen (mise à
maintenance jour via store)
Compatibilité Limitée par Compatible à Dépendances des
l’OS tout système plateformes
à travers le
navigateur
Sécurité Plus sécurisé, Risque lié au Variable selon
local Cloud le stockage.

2. Généralités sur le Java

2.1. Présentation

Inspiré des langages C et C++. Java est un langage

de programmation très récent dont les premières versions
remontent vers l’année 95, langage développé par Sun
Microsystems. Java est un langage à typage fort, il assure
la gestion de la mémoire, il est simple, un langage multi
taches.

Outre son orientation objet, le langage Java a

l’avantage d’être modulaire (on peut écrire des portions de
code génériques, c.-à-d. utilisables par plusieurs
applications), rigoureux (la plupart des erreurs se
 P age |8

produisent à la compilation et non à l’exécution) et portable

(un même programme compilé peut s’exécuter sur différents
environnements).

L’objectif principal de Java est d’augmenter la

productivité des programmeurs tout en leurs facilitant la
conception et l’édition des codes sources.

Le Java est idéal pour la programmation desktop grâce à ses

bibliothèques graphiques puissantes et sa simplicité
d’utilisation. Voici quelques raisons de l’adopter :

- Cross-Platform : Les applications Java fonctionnent sur

différents systèmes d’exploitation (Windows, MacOs,
Linux).
- Frameworks robustes : Java propose des bibliothèques
telles que Swing, AWT, et JavaFX pour créer des
interfaces graphiques.
- Communauté active : Les développeurs Java bénéficient
d’une documentation abondante et d’un support
communautaire.
2.2. Bref historique du langage Java

Le langage Java trouve ses origines dans les années

1990. A cette époque, quelques ingénieurs (innovateurs) de
SUN Microsystems commencent à parler d'un projet
d'environnement indépendant du hardware pouvant facilement
permettre la programmation d'appareil aussi variés que les
téléviseurs, les magnétoscopes etc ... James Grosling (SUN
Microsystems) développent un premier langage, Oak,
permettant de programmer dans cet environnement. En 1992,
tout est prêt pour envahir le marché avec cette nouvelle
technologie mais la tentative se solde par un échec.

Bill Joy (co-fondateur de SUN Microsystems) sauve

malgré tout le projet. Devant la montée en puissance de
l'Internet, il lui semble intéressant d’insister sur
l’élaboration d’un langage indépendant des plates-formes et
des environnements (les principaux problèmes rencontrés sur
 P age |9

l’Internet étant liés à l'hétérogénéité des machines et des

logiciels utilisés). Dès lors tout s'accélère. Oak est
renommé (en 1995) Java et soumis à la communauté Internet
grandissante. Une machine virtuelle, un compilateur ainsi
que de nombreuses spécifications sont données gratuitement
et Java entame une conquête fulgurante.

2.3. Caractéristiques du langage Java

Java possède un certain nombre de caractéristiques

qui ont largement contribué à son énorme succès :
C'est un langage orienté objet dérivé du C, mais plus
simple à utiliser ;
Il est doté, en standard, de bibliothèques de classes
très riches comprenant la gestion des interfaces
graphiques (fenêtres, boites de dialogue, contrôles,
menus, graphisme), la programmation multithreads
(multitâches), la gestion des exceptions, les accès aux
fichiers et au réseau … L’utilisation de ces
bibliothèques facilitent grandement la tâche du
programmeur lors de la construction d’applications
complexes ;
Il est doté, en standard, d’un mécanisme de gestions
des erreurs (les exceptions) très utile et très
performant ;
Java est fortement typé ;
Il est multi plates-formes : les programmes tournent
sans modification sur tous les environnements où Java
existe (Windows, Unix et Mac) ;

Sun a défini trois plateformes d'exécution (ou

éditions) Java pour des cibles distinctes selon les besoins
des applications à développer, nous pouvons citer :
- Java 2 Standard Edition (J2SE / Java 2 SE) :
environnement d'exécution et ensemble complet d'API
(Interfaces de programmation) pour des applications de
type desktop. Cette plate-forme sert de base en tout ou
partie aux autres plateformes.
 P a g e | 10

- Java 2 Enterprise Edition (J2EE / Java 2 EE) :

environnement d'exécution reposant intégralement sur
Java SE pour le développement d'applications web et
d'entreprises.
- Java 2 Micro Edition (J2ME / Java 2 ME) :
environnement d'exécution et API pour le développement
d'applications sur appareils mobiles et embarqués dont
les capacités ne permettent pas la mise en œuvre de Java
SE.
En Java 2 Standard Edition (J2SE), l'on développe deux genres
de programmes :
 Les applications, qui sont des logiciels classiques
s'exécutant directement sur une plate-forme
spécifique, soit à travers une machine virtuelle
java, soit directement en code exécutable par le
système d'exploitation (code natif).
 Les applets, qui sont des programmes java insérés
dans un document HTML s'exécutant à travers la
machine virtuelle java (JVM) du navigateur lisant le
document HTML (des pages web).
Notons que, dans le cadre de ce cours, nous nous
intéressons uniquement aux applications dites classiques de
la plate-forme J2SE.

2.4. La machine virtuelle de Java (JVM)

La JVM n’est pas une machine physique mais plutôt

virtuelle. Elle sert à compiler le programme Java mais pas
l’exécuter.
 P a g e | 11

Java
Virtual
Machine
Pentium
Windows

Java
Virtual
Machine
Pentium
Code source
Compilateur Java
Code Java Linux

Indépendant Indépendant Java

Virtual
Machine
PowerPC
MAC OS

Java
Virtual
Machine
Alpha
UNIX

Le code que java exécute après compilation s’appelle

Code byte et ce code byte peut être utilisé dans n’importe
quel système d’exploitation.

La JVM est une machine à pile, elle supporte les

objets. Exécute le [Link].

Comme nous allons le voir plus tard, la JVM opère

sur deux genres des types notamment primitifs et référence.

2.5. Byte code

Un programmeur Java écrit son code source, sous la

forme de classes, dans des fichiers dont l’extension est
.java. Ce code source est alors compilé par le compilateur
java en un langage appelé byte code et enregistre le résultat
dans un fichier dont l’extension est .class. Le byte code
ainsi obtenu n’est pas directement utilisable. Il doit être
interprété par la machine virtuelle de Java qui transforme
 P a g e | 12

alors le code compilé en code machine compréhensible par le

système d’exploitation. C’est la raison pour laquelle Java
est un langage portable : le byte code reste le même quel
que soit l’environnement d’exécution.

Le byte code n’est rien d’autre que le code généré

par Java après compilation. Il est le langage machine de la
JVM, il n'est autre qu'un code intermédiaire entre votre
code Java et le code machine.

Ce code particulier se trouve dans les fichiers

précompilés de vos programmes ; en Java, un fichier source
a l'extension .java et un fichier précompilé a l'extension
.class ; c'est dans ce dernier que vous pourrez voir du byte
code.

2.6. Types de compilation

Les premières implémentations du langage utilisaient

une machine virtuelle interprétée pour obtenir la
portabilité. Ces implémentations produisaient des programmes
qui s’exécutaient plus lentement que ceux écrits en langage
compilé (C, C++, etc.) si bien que le langage souffrit d’une
réputation de faibles performances.

Des implémentations plus récentes de la machine

virtuelle Java (JVM) produisent des programmes beaucoup plus
rapides qu’auparavant, en utilisant différentes techniques :

- La première technique est de compiler directement en

code natif comme un compilateur traditionnel,
supprimant complètement la phase de bytecode. Des
compilateurs Java tels que GNU Compiler for Java (GCJ)
compilent ainsi directement le Java en code objet natif
pour la machine cible. On obtient ainsi de bonnes
performances, mais aux dépens de la portabilité : le
code final produit par ces compilateurs ne peut de ce
fait être exécuté que sur une seule architecture ;
- Une autre technique appelée compilation « juste-à-
temps », ou « à la volée » (just in time, JIT), traduit
le byte code en code natif durant la phase de lancement
du programme ;
 P a g e | 13

- Certaines machines virtuelles plus sophistiquées

utilisent une recompilation dynamique durant laquelle
la machine virtuelle analyse le comportement du
programme et en recompile sélectivement certaines
parties. La recompilation dynamique permet d’obtenir de
meilleurs résultats que la compilation statique car les
compilateurs dynamiques peuvent optimiser en fonction
de leur connaissance de l’environnement cible et des
classes qui sont utilisées.

La compilation JIT et la recompilation dynamique

permettent à Java de tirer profit de la rapidité du code
natif sans perdre la portabilité.

Nota : Il ne faut pas confondre Java du JavaScript. Le

premier a été développé par Microsystems et le
second par Netscape.

Java script ne s’exécute que sur un environnement

web, il sert à rendre des sites web très attrayant et très
dynamique, java lui s’exécute sur plusieurs plates-formes.

2.7. Java et la programmation orientée objet

Java est un pur langage orienté objet, ce qui

signifie que le niveau le plus externe de la structure des
données est l’objet. Il n’y a pas de constante, de variable
ni de fonction indépendante en Java. On accède à toute chose
via les classes et les objets. Ce qui constitue un des
aspects les plus agréables de Java par rapport à d’autres
langages.

1. Classe

Un objet est une variable (presque) comme les autres.

Il faut notamment qu’il soit déclaré avec son type. Le type
d’un objet est un type complexe (par opposition aux types
primitifs entier, caractère, …) qu’on appelle une classe.

Une classe regroupe un ensemble de données (qui

peuvent être des variables primitives ou des objets) et un
 P a g e | 14

ensemble de méthodes de traitement de ces données et/ou de

données extérieures à la classe. On parle d’encapsulation
pour désigner le regroupement de données dans une classe.

La syntaxe de déclaration d'une classe

modificateurs nom_de_classe [extends classe_mere]

[implements interface] { ... }

ClassModifiers class ClassName [extends SuperClass]

[implemenents Interfaces]

// insérer ici les champs et les méthodes

2. Les objets (instanciation)

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.

Cercle mon_rond;
mon_rond = new Cercle();

2.1. Création d’un objet

Il est nécessaire de définir la déclaration d'une

variable ayant le type de l'objet désiré. La déclaration est
de la forme nom_de_classe nom_de_variable

Exemple :

MaClasse m;

String chaine;
 P a g e | 15

L'opérateur new se charge de créer une instance de

la classe et de l'associer à la variable

Exemple :

m = new MaClasse();

L'opérateur new est un opérateur de haute priorité

qui permet d'instancier des objets et d'appeler une méthode
particulière de cet objet : le constructeur

2.2. Durée de vie d’un objet

Les objets ne sont pas des éléments statiques et leur

durée de vie ne correspond pas forcément à la durée
d'exécution du programme.

La durée de vie d'un objet passe par trois étapes :

la déclaration de l'objet et l'instanciation grace à

l'opérateur new

Exemple :

nom_de_classe nom_d_objet = new nom_de_classe( ... );

l'utilisation de l'objet en appelant ces méthodes

la suppression de l'objet : elle est automatique en java
grâce à la machine virtuelle. La restitution de la
mémoire inutilisée est prise en charge par le
récupérateur de mémoire (garbage collector).

2.3. Les modificateurs d’accès

Ils se placent avant ou après le type de l'objet mais

la convention veut qu'ils soient placés avant. Ils
s'appliquent aux classes et/ou aux méthodes et/ou aux
attributs.

Ils ne peuvent pas être utilisés pour qualifier des

variables locales : seules les variables d'instances et de
classes peuvent en profiter.
 P a g e | 16

Ils assurent le contrôle des conditions d'héritage,

d'accès aux éléments et de modification de données par les
autres objets.

Il existe 3 modificateurs qui peuvent être utilisés

pour définir les attributs de visibilité des entités
(classes, méthodes ou attributs) : public, private et
protected. Leur utilisation permet de définir des niveaux de
protection différents (présenté dans un ordre croissant de
niveau de protection offert):

Public
Protected
Private
2.4. Propriétés ou attributs

Les données d'une classe sont contenues dans des

variables nommées propriétés ou attributs. Ce sont des
variables qui peuvent être des variables d'instances, des
variables de classes ou des constantes.

3. Méthodes

Les méthodes sont des fonctions qui implémentent les

traitements de la classe.

Les méthodes d’un objet caractérisent son

comportement, c’est-à-dire l’ensemble des actions (appelées
opérations) que l’objet est à même de réaliser. Ces
opérations permettent de faire réagir l’objet aux
sollicitations extérieures (ou d’agir sur les autres
objets). De plus, les opérations sont étroitement liées aux
attributs, car leurs actions peuvent dépendre des valeurs
des attributs, ou bien les modifier.

La syntaxe de la déclaration d'une méthode est :

modificateurs type_retourné nom_méthode ( arg1, ... ) {...

}
 P a g e | 17

// définition des variables locales et du bloc

d'instructions

Le type retourné peut être élémentaire ou

correspondre à un objet. Si la méthode ne retourne rien,
alors on utilise void.

CLASSE STRING

Les strings sont très utile pour afficher du texte,

c'est pourquoi si un objet doit être affichée, on fait
appelle à la fonction toString () qui existe dans toutes les
classes.
Cette méthode renvoie alors une String. Un autre
élément important est que Java nous fournit beaucoup de
méthode dans la classe String. Il est donc possible de faire
beaucoup de manipulation sur les strings. C'est en
particulier utile pour du traitement de texte.
En voici quelques méthodes :

a) toLowerCase (): permet de transformer toute saisie

clavier de type caractère en minuscule ;
exemple :
String chaine1,chaine2;
chaine1="PAPA";
chaine2=[Link]();
[Link](chaine2);

A l’exécution, ce programme affiche papa en minuscule.

b) toUpperCase () : transforme de minuscule en majuscule ;
exemple :
public class EXEMPLE_CLASS_STRING {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic her
String chaine1,chaine2;
chaine1="papa";
chaine2=[Link]();
 P a g e | 18

[Link](chaine2);
}
Ce programme affiche à l’exécution PAPA.
c) Concat () : permet de concaténer deux chaines de
caractère.
Exemple :
public class EXEMPLE_CLASS_STRING {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic her
String chaine1,chaine2,chaine3;
chaine1="ISC";
chaine2=" BANDUNDU";
chaine3=[Link](chaine2);
[Link](chaine3);
}

}
A l’exécution, ce programme affiche ISC BANDUNDU
d) Equals () : permet de voir si deux chaines de caractères
sont identiques.
class EXEMPLE_CLASS_STRING {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic her
String chaine1,chaine2,chaine3;
chaine1="KISANGANI";
chaine2="KINGASANI";
if ([Link](chaine2))
[Link]("les deux chaines
identiques");
else
[Link]("les deux chaines ne sont pas
identiques");
}
 P a g e | 19

}
A l’exécution le programme affiche le second message car,
les deux chaines ne sont pas identiques.
e) Length () : permet de donner la longueur d’une chaine de
caractère.

package exemple_class_string;
public class EXEMPLE_CLASS_STRING {
public static void main(String[] args) {
// TODO code application logic her
String chaine;
chaine="KISANGANI";
int longueur;
longueur=[Link]();
[Link](longueur);
}
}
A l’exécution, ce programme affiche 9 comme nombre de
caractères composant la chaine KISANGANI.

3.1. Les package

Un grand nombre de classes, fournies par Java SE,

implémentent des données et traitements génériques
utilisables par un grand nombre d’applications. Ces classes
forment l’API du langage Java.

Toutes ces classes sont organisées en packages (ou

bibliothèques) dédiés à un thème précis.

Parmi les packages les plus utilisés, on peut citer

les suivants :
 P a g e | 20

Package Description
[Link] Classes graphiques et de gestion
d’interfaces
[Link] Gestion des entrées/sorties
[Link] Classes de base (importé par défaut)
[Link] Classes utilitaires
[Link] Autres classes graphiques
[Link] Accès aux données de base de données et
traitement
[Link] Classe permettant des calculs en
précision entière et en virgule flottante
[Link] Support de localisation pour la gestion
des textes, des dates, des nombres et des
messages
[Link] Classes qui permettent le développement
en réseau

Pour accéder à une classe d’un package donné, il faut

préalablement importer cette classe ou son package. Par
exemple, la classe Date appartenant au package [Link] qui
implémente un ensemble de méthodes de traitement sur une
date peut être importée de deux manières :

une seule classe du package est importée :

import [Link];
toutes les classes du package sont importées (même les
classes non utilisées) :
import [Link].*;

Le programme suivant utilise cette classe pour afficher la

date actuelle :

import [Link];
public class DateMain {
public static void main(String[] args) {
Date today = new Date();
[Link](”Nous sommes le ” +
[Link]());
}
 P a g e | 21

CHAPITRE II. LES BASES DE LA PROGRAMMATION EN JAVA

Cette partie évoque les termes et concepts de base
de programmation, tout en spécifiant leurs exemples d’usages
en Java.

2.1. Identificateur

L’identificateur est le nom choisi pour appeler un

élément (une variable ou une méthode). Java accepte tout
identificateur correct. Pour cela, il est important
d’utiliser un terme simple du langage modifié pour répondre
aux exigences suivantes :

Un identificateur doit commencer par une lettre ;

Il peut contenir tous les caractères alphanumériques
(lettres ou chiffres), des caractères de soulignement
(_) ou des symboles monétaire Unicode (£ ou $), mais
pas d’autres caractères spéciaux ;
Il doit être constitué d’un seul mot (sans espace ni
tiret).

L’utilisation des majuscules dans un identificateur

dépend de son type car Java distingue les majuscules des
minuscules.

Un identificateur ne peut pas appartenir à la liste

des mots réservés du langage Java :

Abstract, assert (JDK 1.4), boolean, break, byte, case,

catch, char, class, const, continue, default, do, double,
else, extends, false, final, finally, float, for, goto,if,
implements, import, instanceof, int, interface, long,
native, new, null, package, private, protected, public,
return, short, static, super, switch, synchronized, this,
throw, throws, transient, true, try, void, volatile, while

2.2. Commentaire

Ils ne sont pas pris en compte par le compilateur

donc ils ne sont pas inclus dans le pseudo code. Ils ne se
terminent pas par un ;.
 P a g e | 22

Il existe trois types de commentaire en Java :

//……. (sur une ligne)

/*……*/ (sur plusieurs lignes
/**….. Commentaire de documentation unique

2.3. Opérateurs

Il existe cinq types d’opérateurs :

Opérateurs arithmétiques
Opérateurs logique
Opérateurs de comparaison
Opérateurs d’affectation
Opérateurs de niveaux de bits

Les tableaux suivants indiquent la priorité des

opérateurs (préséance) et l’ordre des opérateurs de même
priorité (associativité).

Opérateurs arithmétiques :

Opérateur Définition Priorit Associativi

é té
++/-- pré/post 1 Droite
incrémentation/dec
auto
+/- plus/moins unaire 2 Droite
(signe)
* Multiplication 4 Gauche
/ Division 4 Gauche
% Modulo 4 Gauche
+/- addition/soustracti 5 Gauche
on

Exemple
- X+=Y signifie X=X+Y ;
- X-=Y signifie X=X-Y ;
- X*=Y signifie X=X*Y ;
 P a g e | 23

- X/=Y signifie X=X/Y ;

- Y=X++ signifie Y=X+1 ; (post incrémentation)
- Y=++X signifie Y=X+1 ; (pré incrémentation)
- Y=X—signifie Y=X-1 ; (post décrémentation)
- Y=--X signifie Y=X-1 (pré décrémentation)
-
Exemples d’usage pour la post incrémentation

Exemple 1 :

int k = 5 , n ; n = 5 k = 6
n = k++ ;
Exemple 2 :
int k = 5, n ; n = -1 k = 6
n = k++ - k ;

Dans l'instruction k++ - k nous avons le calcul

suivant : la valeur de k (k=5) est utilisée comme premier
opérande de la soustraction, puis elle est incrémentée
(k=6), la nouvelle valeur de k est maintenant utilisée
comme second opérande de la soustraction ce qui revient
à calculer n = 5-6 et donne n = -1 et k = 6.

Exemple 3 :

int k = 5 , n ;
n = k - k++ ;
n = 0 k = 6
Dans l'instruction k - k++ nous avons le calcul
suivant : la valeur de k (k=5) est utilisée comme premier
opérande de la soustraction, le second opérande de la
soustraction est k++c'est la valeur actuelle de k qui est
utilisée (k=5) avant incrémentation de k, ce qui revient
à calculer n = 5-5 et donne n = 0 et k = 6.

Exemple pour l’opérateur de pré incrémentation

Exemple1 :
 P a g e | 24

int k = 5 , n ;
n = ++k ; n = 6 k = 6
Exemple 2 :
int k = 5 , n ;
n = ++k - k ; n = 0 k = 6

Dans l'instruction ++k - k nous avons le calcul

suivant : le premier opérande de la soustraction étant
++k c'est donc la valeur incrémentée de k (k=6) qui est
utilisée, cette même valeur sert de second opérande à la
soustraction ce qui revient à calculer n = 6-6 et donne
n =0 et k = 6.

Exemple 3 :

int k = 5 , n ;
n = k - ++k ; n = -1 k = 6
Dans l'instruction k - ++k nous avons le calcul suivant
: le premier opérande de la soustraction est k (k=5), le
second opérande de la soustraction est ++k, k est
immédiatement incrémenté (k=6) et c'est sa nouvelle
valeur incrémentée qui est utilisée, ce qui revient à
calculer n = 5-6 et donne n = -1 et k = 6.

Exemple de la post-décrémentation : k—

La valeur de k est d'abord utilisée telle quelle dans

l'instruction, puis elle est diminuée de un à la fin.
Exemple 1 :

int k = 5 , n ;
n = k-- ; n = 5 k = 4
pré-décrémentation : --k
La valeur de k est d'abord diminuée puis utilisée dans
l'instruction.
Exemple1 :
int k = 5, n ;
n = --k ; n = 4 k = 4
 P a g e | 25

Exemple
public static void main(String[] args) {
// TODO code application logic here
int x=5,y=3, z=3,t=4,calcul;
calcul=x*y*z;
[Link]("x+y*z="+calcul);
calcul=x*y%z+t;
[Link]("x*y%z+t="+calcul);
}

Le résultat après exécution donne :

x+y*z=45
x*y%z+t=4

Opérateurs logiques

Opérateur Définition Priorité Associativité

! Complément logique 2 Droite
(NOT)
& évaluation AND 9 Gauche
^ ou exclusif XOR 10 Gauche
| évaluation OR 11 Gauche
&& court-circuit AND 12 Gauche
| | court-circuit OR 13 Gauche

Opérateurs de comparaison

Opérateur Définition Priorité Associativité

< inférieur à 7 Gauche
> supérieur à 7 Gauche
<= inférieur ou égal à 7 Gauche
>= supérieur ou égal à 7 Gauche
== égal à 8 Gauche
!= différent de 8 Gauche

public class Main {

 P a g e | 26

public static void main(String[] args) {

int A=5, B=7,C=4;
boolean I;
I=A>B;
[Link]("A>B="+I);
I=(A>B)|(B==C);
[Link]("(A>B)|(B==C="+I);
}}
Le résultat après exécution donnera :

A>B=false
(A>B)|(B==C=false

Opérateurs d’affectation

Opérateur Définition Priorité Associativité

= Affectation 15 Droite
+= ajout et affectation 15 Droite
-= soustraction et 15 Droite
affectation
*= multiplication et 15 Droite
affectation
/= division et affectation 15 Droite
&= AND binaire et 15 Droite
affectation
|= OR binaire et 15 Droite
affectation
^= XOR binaire et 15 Droite
affectation
Opérateurs de données binaires (bit-à-bit)
Ce sont des opérateurs de bas niveau en Java dont
les opérandes sont exclusivement l'un des types entiers
ou caractère de Java (short, int, long, char, byte). Ce
type d'opérateur traite ses opérandes comme des données
binaires.
Ils permettent de manipuler directement les bits
du mot mémoire associé à la donnée.
 P a g e | 27

Opérat Description Exemple avec x=7

eur
~ OU bit-à-bit Retourne 1 si l'un des deux 9 ^ 12
bits de même poids est à 1 (1001 ^
(mais pas les deux 1100) // 5
(0101)
& ET bit-à-bit Retourne 1 si les deux bits
de même poids sont à 1 9 & 12
(1001 &
1100) //
8 (1000)
| OU bit-à-bit Retourne 1 si l'un ou 9 | 12
l'autre des deux bits de (1001 |
même poids est à 1 (ou les 1100) //
deux) 13 (1101)

Concaténation

Java admet l'opérateur + comme opérateur de

concaténation de chaines de caractères. L'opérateur + permet
de concaténer plusieurs chaines.
Exemple
String Pren= "Caleb " ;
String Nom= "Mindele";
[Link](Pren+Nom);
Le résultat après exécution donnera Caleb Mindele
2.4. Variable
Les variables constituent l’aspect le plus important
de la programmation. Avant de pouvoir utiliser une variable,
il est nécessaire de la déclarer, c’est-à-dire d’associer la
variable à un emplacement de la mémoire et de spécifier son
type.
Une variable possède un nom, un type et une valeur.
La déclaration d'une variable doit donc contenir deux choses
: un nom et le type de données qu'elle peut contenir. Une
variable est utilisable dans le bloc ou elle est définie.
 P a g e | 28

Java est un langage à typage fort, pour ainsi dire

qu’on ne peut pas déclarer une variable sans type.
Voici la syntaxe :
Typevariable nomVariable;
Exemple :
int X ;
NB : On peut également faire la déclaration et
l’initialisation d’une variable en une seule
instruction :
typeVariable nomVariable = uneValeur;

Exemple :

int A=10 ;

2.4.1. Types primitifs ou élémentaires

Les types primitifs ou élémentaires sont

indépendants de toute classe et utilisables partout.
Les types primitifs permettent de manipuler des
booléens, des entiers, des réels, des caractères. Ils sont
les seuls types du langage qui ne soient pas des classes.
Ils sont utilisés pour définir les champs de données de
toutes les classes.
La déclaration de variables est obligatoire avant
leur utilisation.
 P a g e | 29

Données numériques
Type Taill Description (valeurs extrêmes)
e
Byte 8 -128 à 127
bits
Short 16 -32768 à 32767 entier court
bits
Int 32 -2,14E9 à 2,14E9 entier signé
bits
Long 64 -9,22E18 à 9,22E18entier long
bits
Float 32 1,402E-45 à 3,402E38virgule
bits flottante simple précision
Double 64 4,94E-324 à 1,79E308 virgule
bits flottante double précision
Toute variable non initialisée prend
automatiquement la valeur 0.
Attention, en Java, un numérique ne peut servir
de résultat à un test comme le font les instructions if,
while ou for.

Booléens

Le type boolean, ils prennent les valeurs true et false.

Un booléen prend la valeur par défaut false.
Caractères

Les caractères peuvent être déclarés avec le type

char. Non initialisés, ils prennent la valeur 0
(caractère null).
Ils occupent 2 octets puisque codés en Unicode (à
la différence du C qui les code sur 8 bits en ASCII).
Unicode a permis entre autres d’associer dans une table
toutes les tables ASCII.
Caractères spéciaux
Ils sont utilisés pour indiquer des opérations
particulières comme un saut de ligne. En voici un tableau
non exhaustif :
 P a g e | 30

Caractère Séquence Unicode

Barre oblique inversée \\ \u005c

Retour arrière \b \u000d
Tabulation \t \u0009
Retour chariot \r \u0008
Saut de ligne \n \u000a
Saut de page \f \u000c
Guillemet \“ \u0022
Apostrophe \’ \u0027
Valeur hexadécimale \xHH
Valeur octale \OOO
Caractère Unicode \Uhhhh
2.4.2. Les types références

Si les types de données précédents acceptent un

nombre, un caractère, un état ou une chaine, les types de
données composites ou de référence sont constitués de
plusieurs éléments, utilisés pour nommer les classes et les
tableaux.

Exemple : NomDeClasse

Conversion de types
La conversion (également appelée transtypage) est
faite en Java seulement d’un type primitif en un autre type
primitif. Il se fait de la manière suivante :

typeVariableA variableA =(typeVariableA) valeurB

Voici le résumé de conversion :

Type initial Convertit en tpe

Byte short, chart, int, long, float,
double
Short int, long, float, double
Char int, long, float, double
Int long, double
Long float, double
Float Double
 P a g e | 31

Pour transtyper un type de données, il suffit de le

placer entre parenthèses, immédiatement avant la variable à
transtyper.

Exemple

float a=1.0 ;

int b=(int)a ;

Dans ce cas, la variable à transtyper est a avec

float comme le type de données initial, int le type de
destination et b la variable contenant la nouvelle valeur.
Cela suppose que la valeur de a tiendra dans int. La décimale
de a est perdue dans la conversion car Java arrondit les
décimales au nombre entier le plus proche.

Exemple

int i=3, y=2 ;

float z=x/y // réponse est 1.5

2.5. Les constantes

Ce sont des variables dont le contenu ne peut pas

être modifié, elles sont précédées du mot clef final :

final int x=10 ; x est déclarée comme constante

entière initialisée à 10.

x = 32 ; <------ provoquera une erreur de compilation

interdisant la modification de la valeur de x.

Une constante peut être déclarée et initialisée plus

loin une seule fois :final int x ; ….. x = 10;

2.6. Instructions

Une instruction n’est rien d’autre qu’une commande.

Une commande peut occuper plusieurs lignes de codes, mais le
compilateur lit l’intégralité de tous ces codes comme une
commande unique.
 P a g e | 32

Lorsque les instructions sont sur une seule ligne se

terminent par un point-virgule (;), les groupes
d’instructions (les instructions sur plusieurs lignes) se
terminent par une accolade fermante (}).
Nota : les instructions sur plusieurs lignes sont appelées
blocs de code.

a. Instruction d’entrée

Elles permettent de faire entrer des données à partir

du clavier.
En voici quelques-unes :

Scanner sc= new Scanner([Link]) :

Cette instruction permet d’instancier un objet de la
classe Scanner. L’instruction String str=[Link]
permet de récupérer la chaine saisie.

Exemple : Lecture d'un texte d'une fenêtre console

package exempleLecture;
import [Link];
public class Lecture {
public static void main(String[] args) {
String ligne_lue;
[Link]("Entrer une string");
Scanner clavier=new Scanner ([Link]);
ligne_lue=[Link]();
[Link](ligne_lue);
}
}
bufferedReader clavier=new BufferedReader(new
InputredReader([Link])) ; permet au programmeur de
créer un objet de la classe BufferedReader appélé
clavier.
Tout objet de la classse BufferedReader exécute une
méthode appelé readLine()qui permet de lire une ligne
entière de chaine de caractères.

Exemple : Lecture d'un texte d'une fenêtre console

 P a g e | 33

package exempleLecture;
import [Link].*;
public class Lecture {
public static void main(String[] args) {
String ligne_lue = null;
[Link]("Entrer une string");
try
{
InputStreamReader lecteur = new
InputStreamReader([Link]);
BufferedReader entree = new BufferedReader(lecteur);
ligne_lue = [Link]();
}
catch (IOException err)
{
[Link](0);
}
[Link](ligne_lue);
}
}

b. Instruction de sortie

Elle permet l’affichage de données à l’écran. Il s’agit de :

[Link](arg) : permet d’imprimer l’argument

qui doit être spécifié par le programmeur.

Exemple1

[Link](˝Je suis malade˝) ;

Le système va afficher le message Je suis malade.

Exemple2
Int a =5;
Int b=5 ;
[Link](a+b);
Le système affichera 10.
 P a g e | 34

CHAPITRE III : STRUCTURE DE CONTROLE EN JAVA

3.1. Structure de contrôle

a. Structure de contrôle de séquence conditionnelle

L’instruction if else

Elle permet d’effectuer un test afin de contrôler

la valeur d’une expression. En fonction du résultat du
test, il est possible d’exécuter une instruction (ou un
bloc) ou bien une autre :

Un test :

if(condition1)
instruction1 ;
else
instruction 2 ;

if(condition1) { bloc1 } else { bloc2} ;

Les instructions qui se trouvent entre les deux premières

accolades ne seront réellement exécutées que si et seulement
si la condition qui est entre les parenthèses du if est
vraie. Le deuxième bloc (la deuxième paire) sera exécuté au
contraire si la condition consignée par le if est fausse. Ce
bloc est facultatif. Pour indiquer la condition, nous avons
à notre disposition plusieurs opérateurs mathématiques de
comparaison vus précédemment.
Exemple

if (a < b) [Link] ("ascendant") ;

else [Link] ("non ascendant") ;

Plusieurs tests successifs :

if(condition1)
 P a g e | 35

instruction1 ;
else if(condition2)
instruction2 ;
else if(confition3).
instruction3 ;

Exemple:
Écrivez un programme pour trouver un maximum entre trois
nombres en utilisant une if-else ou if imbriquée
import [Link];

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);
int num1, num2, num3, max;
// Fournir les données d'entrée
[Link]("Saisir le numéro 1 ");
num1 = [Link]();
[Link]("Saisir le numéro 2 ");
num2 = [Link]();
[Link]("Saisir le numéro 3 ");
num3 = [Link]();
// Calculer la surface
if (num1 > num2) {
if (num1 > num3) {
// si num1 > num2 et num1 > num3
max = num1;
} else {
// si num1 > num2 mais num1 > num3 est fausse
max = num3;
}
} else {
if (num2 > num3) {
// Si num1 < num2 et num2 > num3
max = num2;
} else {
// si num1 < num2 et num2 > num3
max = num3;
}
}
// Afficher le résultat
 P a g e | 36

[Link]("le maximum est = " + max);

// fermer les ressources
[Link]();
}
}
Exemple:
Lire A, B et C lesquels sont des entiers positifs
représentant les longueurs des trois côtés d’un triangle.
Déterminer si ce triangle est rectangle, équilatéral,
isocèle ou quelconque.

import [Link] ;

public class triangle {

public static void main ( String args [ ]) {

Scanner. Clavier = new Scanner ([Link]) ;

Int A, B, C, Sauve ;

[Link] (‘’ Saisir la valeur de A’’) ;

A = [Link]() ;

[Link] (‘’ Saisir la valeur de B’’) ;

B = [Link]() ;

[Link] (‘’ Saisir la valeur de C’’) ;

C= [Link]() ;

// mise en ordre croissant

If (A>=B) { Sauve = A ; A=B ; B=Sauve ;}

If (A>=C) { Sauve = A ; A=C ; C=Sauve ;}

If (B>=C) { Sauve = B ; B=C ; C=Sauve ;}

// fin mise en ordre croissant

If ((C*C ) == (A*A) + (B*B)) [Link] (‘’triangle

rectangle’’) ;
 P a g e | 37

Else

If ((A==B) && (B==C)) [Link] (‘’triangle

équilatéral’’) ;

else

if( (A==B) && (B<C) || (B>C))

[Link](‘’triangle isocèle’’ );

else [Link] (‘’triangle

quelconque’’) ;

} }

Nota:
Un bloc peut remplacer une instruction si
plusieurs instructions sont à exécuter.

L’instruction switch

Elle permet d’exécuter une instruction ou un bloc

différent en fonction de la valeur prise par une
expression.

switch(expression) {
case valeur1 : //bloc de code 1 ;
break ;
case valeur2 : //bloc de code 2 ;
break ;
case valeur3 :
case valeur4 :
//bloc de code 3&4 ;
break
default : //bloc de code par
défaut ;
}

Exemple 1
 P a g e | 38

int x = 10;
switch (x+1)
{ case 11 : [Link](">> case 11");
case 12 : [Link](">> case 12");
default : [Link](">> default");
}

Après exécution, nous aurons :

>> case 11
>> case 12
>> default

Exemple 2 :
Écrivez un programme pour Saisir le numéro du jour dans
une semaine (1-7) et affichez le nom du jour à l'aide de
switch case.
import [Link];

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);

int jour;

// Fournir les données d'entrée

[Link]("Saisir le numéro de jour : ");
jour = [Link]();
switch (jour) {
case 1:
[Link]("Lundi");
break;
case 2:
[Link]("Mardi");
break;
case 3:
[Link]("Mercredi");
break;
case 4:
[Link]("Jeudi");
 P a g e | 39

break;
case 5:
[Link]("Vendredi");
break;
case 6:
[Link]("Samedi");
break;
case 7:
[Link]("Dimanche");
break;
default:
[Link]("Entrée invalide! Veuillez
saisir le numéro de jour entre 1 et 7.");
}

// fermer les ressources

[Link]();
}
}

Exemple 3:Écrivez un programme pour saisir un nombre de

l'utilisateur et vérifiez si ce nombre est pair ou impair
en utilisant "switch case".
import [Link];

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);

int num;

// Fournir les données d'entrée

[Link]("Saisir un nombre : ");
num = [Link]();

switch (num % 2) {
/* Si n%2 == 0 */
case 0:
[Link]("Pair");
break;

/* Sinon n%2 == 1 */
 P a g e | 40

case 1:
[Link]("Impair");
break;
}

// fermer les ressources

[Link]();
}
}
Exemple 4 : Écrivez un programme pour entrer un nombre et
vérifiez si ce nombre est positif, négatif ou nul en
utilisant "switch case".
mport [Link];

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);

int num;

// Fournir les données d'entrée

[Link]("Saisir un nombre : ");
num = [Link]();

switch (num > 0 ? 1 : 0) {

// Num est positif
case 1:
[Link](num + " est positif.");
break;

// Num soit négatif soit nul

case 0:
switch (num < 0 ? 1 : 0) {
case 1:
[Link](num + " est négatif.");
break;
case 0:
[Link](num + " est nul.");
break;
}
break;
}
 P a g e | 41

// fermer les ressources

[Link]();
}
}
Exemple 5 : Écrivez un programme pour créer une
calculatrice qui exécute des opérations arithmétiques de
base (addition, soustraction, multiplication et division)
en utilisant "switch-case"

import [Link];

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);

double num1, num2, resultat = 0;

char op;

// Fournir les données d'entrée

[Link]("Saisir nombre 1 : ");
num1 = [Link]();

[Link]("Saisir l'opérateur: ");

op = [Link]().charAt(0);

[Link]("Saisir nombre 2 : ");

num2 = [Link]();

switch (op) {
case '+':
resultat = num1 + num2;
break;

case '-':
resultat = num1 - num2;
break;

case '*':
resultat = num1 * num2;
break;
 P a g e | 42

case '/':
resultat = num1 / num2;
break;

default:
[Link]("Opérateur invalide");
}

[Link](num1 + " " + op + " " + num2 +

" = " + resultat);

// fermer les ressources

[Link]();
}}
Si l’instruction break est omise après un bloc de
code, le test suivant (case) est exécuté sans sortir du
switch. Avec break, un seul bloc de code peut être
exécuté, suivit de la sortie du switch.

Remarque : switch ne peut s’employer en Java qu’avec des

entiers int ou des caractères char.

b. Structure de contrôle de séquences répétitives

Les instructions itératives permettent d’exécuter

plusieurs fois un bloc d’instructions, et ce, jusqu’à ce
qu’une condition donnée soit fausse. Les trois types
d’instructions itératives sont les suivantes :

Boucle for

La boucle for est la plus puissante. Elle est

utilisée lorsqu’on connait à l’avance le nombre de tour
à effectuer. Elle est beaucoup plus utilisée dans le cas
de matrice (tableau ou vecteur). Elle permet en une ligne
de configurer tout le fonctionnement de la boucle :

For (initialisation ; condition ; opération)

{ /*bloc*/ }

Cette boucle fonctionne ainsi :

 P a g e | 43

tout d’abord une initialisation est effectuée

ensuite la condition est testée
 si elle est vraie, le bloc est exécuté puis
l’opération effectuée ; ensuite on repart
sur la condition
 si elle est fausse, le bloc n’est pas
exécuté et l’on quitte la boucle.
Exemple1
public class Boucle
{ public static void main(String[] args)
{ int i, n, som ;
som = 0 ;
for (i=0 ; i<4 ; i++)
{ [Link] ("donnez un entier ") ;
n = [Link]() ;
som += n ;
}
[Link] ("Somme : " + som) ;
}
}
Exemple 2
for (int x=0;x<10;x++){
[Link]("Je suis malade");
}
A l’exécution, ce programme affichera autant de fois Je
suis malade sur l’écran
Exemple 3
for (int i=1, j=1;(i<=5); i++,j++)
{
[Link] ("I="+i+" j="+j);
}

A l’exécution, nous aurons :

I=1 j=1
I=2 j=2
I=3 j=3
 P a g e | 44

I=4 j=4
I=5 j=5

Boucle while (Tant que)

La boucle while exécute un bloc tant qu’une condition est
vraie :
while(condition) { … }

Avant chaque exécution du bloc, la condition est

à nouveau testée jusqu’à ce qu’elle soit fausse. Si elle
est fausse dès le départ, le bloc ne sera jamais exécuté.

En d’autres termes c’est une boucle pré-testée

puisque on ne connait pas à l’avance l’évaluation. C’est une
boucle générale car elle peut être utilisée ou son exécution
s’applique à tout le cas.

Exemple 1

public class Boucle

{ public static void main(String[] args)
{ int i, n, som ;
som = 0 ;
i = 0 ;
Scanner clavier=new Scanner([Link]) ;
while (i<4)
{ [Link] ("donnez un entier ") ;
n = [Link]() ;
som += n ;
i++ ;
}
[Link] ("Somme : " + som) ;
}
}
 P a g e | 45

Boucle do while

La boucle do while exécute un bloc tant qu’une

expression est vraie :

do { … }
while(expression)

Après chaque exécution du bloc, la condition est

à nouveau testée jusqu’à ce qu’elle soit fausse.
Si elle est fausse dès le départ, le bloc sera exécuté
une fois.

Exemple :

public class Boucle

{ public static void main(String[] args)
{ int i, n, som ;
som = 0 ;
i = 0 ;
Scanner clavier=new Scanner([Link]) ;
do
{ [Link] ("donnez un entier ") ;
n = [Link]() ;
som += n ;
i++ ;
}
while (i<4) ;
[Link] ("Somme : " + som) ;
}
}
Exercices

1. Ecrire un programme pour afficher tous les nombres

naturels de 1 à n en utilisant la boucle for et while

import [Link];
 P a g e | 46

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);

int i, n;

// Fournir les données d'entrée

[Link]("Saisir un nombre n : ");
n = [Link]();

[Link]("les nombres naturels de 1 à "

+ n);

for (i = 1; i <= n; i++) {

[Link](i + "\t");
}

// fermer les ressources

[Link]();

2. Écrivez un programme pour saisir le nombre

d'utilisateurs et trouvez la somme de tous les nombres
pairs entre 1 et n en utilisant la boucle "for" et
"while

import [Link];

public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner([Link]);

int i, n, somme = 0;

// Fournir les données d'entrée

[Link]("Saisir un nombre : ");
 P a g e | 47

n = [Link]();

// calculer la somme
for (i = 2; i <= n; i += 2) {
somme += i;
}

[Link]("la somme des nombres pairs de

1 à " + n + " = " + somme);
// fermer les ressources

[Link]();}}

Nota : il existe aussi des instructions de contrôle des

boucles, nous en illustrons deux :

Instructions break et continue

L’instruction break est utilisée pour sortir

immédiatement d’un bloc d’instructions (sans traiter les
instructions restantes dans ce bloc). Dans le cas d’une
boucle on peut également utiliser l’instruction continue
avec la différence suivante :

Break : l’exécution se poursuit après la boucle (comme si la

condition d’arrêt devenait vraie) ;

Exemple

int a=0;
while(a<10){
[Link]("Je suis malade");
a++;
if (a==5)
break;
else
// autre truc à faire
}
Ici la boucle s’arrête lorsque a est égal à 5.
 P a g e | 48

Continue : l’exécution du bloc est arrêtée mais pas celle de

la boucle. Une nouvelle itération du bloc
commence si la condition d’arrêt est toujours
vraie.

for(int a=0 ;a<10 ;a++){

if (a==5)
continue ;
[Link]("Je suis malade");

Ceci ne vas pas imprimer Je suis malade si x a la valeur 5,

mais continue à l’imprimer pour 6,7 ,8 et 9.

3.2. Les tableaux

Un tableau est une structure de données contenant un

groupe de valeurs de même type. Par exemple, un tableau
accepte un groupe de valeur string, un groupe de valeur int
ou un groupe de valeur boolean. Tant que les valeurs sont
du même type, elles peuvent être placées dans le même
tableau.

Les tableaux sont caractérisés par une paire de

crochets droits qui peuvent être placés soit après
l’identificateur, soit après le type de données, et si
possible avec l’initialisation du nombre d’éléments qi les
constituent.

La déclaration d’un tableau ne lui alloue pas de

mémoire. Dans la plupart de langages, la taille du tableau
n’est spécifiée qu’au moment de son utilisation pour que la
mémoire lui soit allouée.

3.2.1. Tableau à une dimension

La déclaration d’un tableau à une dimension est faite de la

manière suivante :

Sans initialisation

Type nom_vecteur [] ;
 P a g e | 49

Avec initialisation :

Type nom_vecteur []=new type [taille] ;

Exemple : Ecrire un programme en Java qui affiche le contenu

d’un tableau et qui calcule et affiche à la fin
la somme.

Solution

Public class Tableau {

public static void main(String[] args) {

int Table []={4,8,6,10,7,1,9,5,3};

int somme=0;

int i=0;

[Link]("la somme de quelques chiffres");

[Link]("==============================");

while (i<=7){

[Link](""+Table[i]);

somme+=Table[i];

i++;

[Link](" ---");

[Link]("Total:"+(somme));

3.2.2. Tableau à plusieurs dimensions

La logique reste la même pour les tableaux à une

dimension, sauf qu’il faut simplement doubler les crochets
afin d’avoir une matrice de dimension nXm. Voici donc la
syntaxe :
 P a g e | 50

Type [] []nom_vecteur=new type[n] [m]

Exemples

Soit un tableau à deux dimensions de type double :

double [] [] Tableau=new double [2] [2] ;
On peut l’initialiser comme suit :
double [] [] Tableau ={{10.1, 11.8, },{9.4,23.2}} ;

Exemple

Ecrire un programme en Java qui crée un tableau à

plusieurs dimensions (5,3) et permet d’afficher le somme
de tous les éléments du tableau.

public class Main {

public static void main(String[] args) {

Scanner sc=new Scanner([Link]);

final int ligne = 5;
final int colonne = 3;
double tableau[][]=new double[ligne][colonne];
double somme= 0;
for (int i = 0;i<ligne;i++){
[Link]("Ligne numero " + (i + 1));
for (int j=0;j<colonne;j++){
[Link]("Donnez la valeur " + (j + 1) + "");
tableau[i][j]= [Link]();
}}
for(int i=0;i<ligne;i++){
for(int j=0;j<colonne;j++) {
somme+=tableau[i][j];
}
}
[Link]("La somme est " + somme);
}
}}
 P a g e | 51

Exemple : cette fois-ci nous allons voir comment trouver

la somme des éléments sur la diagonale.

public class SOMMEDIAGONALE {

public static void main(String[] args) {
// TODO code application logic here
Scanner sc=new Scanner([Link]);
final int ligne = 3;
final int colonne = 3;
double tableau[][]=new double[ligne][colonne];
double somme= 0;
for (int i = 0;i<ligne;i++){
[Link]("Ligne numero " + (i + 1));
for (int j=0;j<colonne;j++){
[Link]("Donnez la valeur " +
(j + 1) + " ");
tableau[i][j] = [Link]();
} }
for (int i=0;i<ligne;i++){
for (int j=0;j<i;j++)
somme=somme+tableau[i][j];
}
[Link]("La somme " + somme);
} }
3.3. Gestion des exceptions

Certains langages de programmation, dont le langage

Java, proposent un mécanisme de prise en compte des erreurs,
fondé sur la notion d’exception. Une exception est un objet
qui peut être émis par une méthode si un événement d’ordre
“exceptionnel” (les erreurs rentrent dans cette catégorie)
se produit. La méthode en question ne renvoie alors pas de
valeur de retour, mais émet une exception expliquant la cause
de cette émission. La propagation d’une émission se déroule
selon les étapes suivantes :

Les exceptions représentent le mécanisme de gestion

des erreurs intégré au langage java. Il se compose d'objets
 P a g e | 52

représentant les erreurs et d'un ensemble de trois mots clés

qui permettent de détecter et de traiter ces erreurs ( try,
catch et finally).

- Try, catch et finaly

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.

Exemple:

try {
operation_risquée1;
opération_risquée2;
}
catch (Exception e) {
traitements
}
finally {
traitement_pour_terminer_proprement;
}
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
 P a g e | 53

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.

Si l'exception générée est une instance de la classe

déclarée dans la clause catch ou d'une classe dérivée, alors
on exécute le bloc associé. Si l'exception n'est pas traitée
par un bloc catch, elle sera transmise au bloc de niveau
supérieur. Si l'on ne se trouve pas dans un autre bloc try,
on quitte la méthode en cours, qui régénère à son tour une
exception dans la méthode appelante.

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é[Link] clause
finally définit un bloc qui sera toujours exécuté, qu'une
exception soit levée ou non. Ce bloc est facultatif. Il est
aussi exécuté si dans le bloc try il y a une instruction
break ou continue.

Exemple :

try {

int division = 10 / 0; // Erreur : division par zéro

} catch (ArithmeticException e) {

[Link]("Erreur : Division par zéro !");

} finally {

[Link]("Fin du programme.");
 P a g e | 54

CHAPITRE IV : INTERFACES GRAPHIQUES EN JAVA

Pour créer les interfaces graphiques, nous allons
utiliser l’Environnement de Développement Intégré (EDI)
NetBeans.

NetBeans est l'IDE créé par Sun Microsystems, il

contient donc toutes les fonctionnalités d'un bon IDE :

Un debugger,
Un outil de modélisation UML,
Tout le nécessaire pour faire des applications J2EE,
Il est gratuit !

1. Création d’un projet

Nous allons aborder ce point, en y illustrant avec un exemple

à l’appui.

Pour créer un fichier, nous allons procéder comme suit :

Dans le menu Fichier, cliquer sur Nouveau projet

 P a g e | 55

Dans Nouveau projet, choisissez Application java

Vous devriez contrôler l’emplacement de votre projet

 P a g e | 56

2. Ajout d’une interface

Le projet initial se compose uniquement d’un

fichier [Link]. Il s’agit par défaut d’une
application console appelée [Link]
 P a g e | 57

Ajout d’un composant visuel

Dans le sous menu Fichier, choisissez nouveau fichier

Pour les applications graphiques, nous allons

utiliser le fichier Swing GUI Forms. Car ce dernier
regorge tous les outils graphiques.
 P a g e | 58

Il y a beaucoup de types de graphiques, mais nous

allons travailler avec le composant JDialog Form. Choisissez
ensuite un nom adapté par exemple Mon_formulaire.
 P a g e | 59

A ce niveau nous avons maintenant deux fichier le

[Link] et mon_formulaire.Java

3. Suppression du fichier [Link]

Faites un clic droit sur [Link], dans le menu

contextuel, cliquez sur Supprimer.

4. Compilation du projet

En cliquant sur , NetBeans vous demandera de sélectionner

la classe mon_formulaire
 P a g e | 60

En validant mon_formulaire, nous aurons une telle

fenêtre, qui constitue notre formulaire :

Ce formulaire est vide, il sera question d’y

ajouter des éléments tels que bouton, commandes, etc.
 P a g e | 61

5. Les éléments de base d’une fenêtre

a. Utilisations des objets de l’interface

Une fenêtre graphique peut se manipuler sous forme

graphique (utilisez l’onglet Design) ou sous forme
textuelle (onglet Source). La construction d’une interface
se fait en mode Design.

Tous les objets graphiques nécessaires à une

interface sont regroupés dans l’onglet Palette.
 P a g e | 62

Lorsqu’on objet graphique est sélectionné à la

souris, l’onglet Properties permet de manipuler ses
propriétés (couleur, position, forme,….).
 P a g e | 63

Ceci étant, nous allons maintenant nommer notre

formulaire en lui donnant le nom CALCULATRICE et cela à
partir de la propriété Title.

Après exécution, nous aurons :

 P a g e | 64

b. Ajout d’un bouton

Dans la liste des composants sélectionnez ToggleButton et

dessinez ensuite un bouton sur la fenêtre.

Nous obtiendrons une fenêtre semblable à celle-ci :

Pour changer le texte sur ce bouton généré,

Sélectionnez le bouton à la souris, et examiner le
panneau Properties. Modifiez ensuite le champ Text.
 P a g e | 65

Après avoir saisie Quitter et une fois valider par la

touche Entrée, vous obtiendrez :

c. Attachez une action à un bouton

Faire un clic droit sur le bouton pour faire

apparaître le menu contextuel. Et choisir ensuite :
Events/Mouse/mouseClicked. Cela signifie que nous
désirons attacher un événement lorsque l’évènement click
se produira sur le bouton.
 P a g e | 66

Automatiquement, NetBeans vous propose de remplir le

code qui sera associé à l’événement Click sur le bouton. Le
nom de la procédure est clair de ce point de vue.

Pour notre bouton, puis qu’il a un nom quitter,

nous allons mettre le code suivant :
 P a g e | 67

Ce code permettra de terminer l’application sur

l’événement Click.

Communiquer avec l’utilisateur

a. Lire les données saisies et afficher

Utilisez les JLabel et les JTextFiled pour

construire une fenêtre similaire à la fenêtre ci-
dessous.

Et pour conclure ajoutez un JTextArea et un autre

bouton que nous allons appeler ToggleButton2 Le texte
sur le bouton est bien Valder. Maintenant ajoutez le
code Java suivant :

A l’exécution, nous aurons

 P a g e | 68

6. Gestion des composants et des événements

Pour créer et gérer un bouton de commande, nous aurons :

Button () ; permet de créer un bouton de commande

vide. Button(Strig) crée un bouton avec une chaine de
caractère comme étiquette ou caption ;
Set visible() : permet de déterminer de la visibilité
ou non ;
Add() : permet d’ajouter un bouton dans le
formulaire ;
SetBounds() : définit la taille d’un bouton de
commande.

Pour créer et gérer les étiquettes :

Label() :permet de créer une étiquette vide.

Label(String) crée une étiquette avec une chaine de
caractères justifiée à [Link] justifie le
texte à droite, [Link] justifie le texte au
centre ;
setFont() : permet de fixer la police et la taille
d’un Label
getText() : retourne le texte contenu dans une
étiquette ;
 P a g e | 69

setText() : permet de changer le texte de

l’étiquette ;
getAlignment() :retourne le chiffre qui représente la
justification de l’étiquette. 0 pour la gauche, 1 pour
le centre et 2 pour la droite.
Concernant les évènements, nous citerons par exemple :

 WindowsListener : permet de gérer les événements de la

fenêtre ;
 Window Adapter : permet de créer un gestionnaire
d’événements ;
 EventListener : permet d’écourter n’importe quelle
interface ;
 Action Listener : permet de déclencher les événements
à partir de la souris et les touches clavier ;
 Item Listener : permet la gestion de cases à cocher ;
 getContent Pane () : permet de rétirer le container de
la fénètre.
Exercice

L’exemple ci-dessous consistait à écrire une

application demandant le nom de l’utilisateur et affiche
dans une zone de texte Bonjour suivi du nom saisie par
l’utilisateur. A présent, en votre qualité de programmeur,
on vous demande d’écrire un programme Java qui calcule la
somme de deux nombres.

Ces deux nombres doivent être saisis dans deux zones

de textes par l’utilisateur. Les boutons à prévoir sont
calculer et quitter.

Résolution

Interface à réaliser
 P a g e | 70

Code source

int i,j,resultat;
String Chaine1, Chaine2, Chaine3;
// récuparation des deux données au format String...
Chaine1 = [Link]();
Chaine2 = [Link]();
// converson en int
i = [Link](Chaine1);
j = [Link](Chaine2);
// addition
resultat = i + j;
// conversion en chaine
Integer rr = new Integer(resultat);
Chaine3 = [Link]();
// on affiche le résultat
[Link](Chaine3);
}
 P a g e | 71

CHAPITRE V: ACCES AUX BASES DE DONNEES

A partir de la version 1.1 du JDK, l’API JBDC
(Application Programming Interface Java DataBase
Connectivity) fait partie intégrante de la plate-forme Java.
JDBC est un ensemble de classes et d’interfaces permettant
des de réaliser des connexions vers des bases de données
et d’effectuer des requêtes avec le langage de requêtes
structuré SQL(Structured Query Langage). En plus de tout ce
que fait ODBC(Open DataBase Connectivity), JDBC permet aussi
l’accès à des sources de données sous forme de
fichiers(exemple:fichier XML). L’API JDBC est représentée
par le package [Link].

5.1. Package [Link]

Ce package a deux principales classes :

[Link] : Elle prend en charge le
chargement des pilotes et permet de créer des nouvelles
connexions à des bases de données. Elle tient à jour,
la liste principale des pilotes JDBC recensés du
système.
[Link] : cette classe symbolise un ensemble
de résultats dans une base de données et autorise
l’accès aux résultats d’une requête rangée par rangée.
Pendant le traitement de la requête, un resultSet
conserve un pointeur vers la rangée manipulée.
L’application se déplace séquentiellement dans
l’ensemble des résultats.

5.2. Création de la base de données sous MySQL

Pour la création de la base de données, nous avons

besoin d’un serveur et d’un navigateur mais aussi d’une
connexion web. Mais en ce qui concerne les tests, nous aurons
à effectuer sur un serveur local et le Wamp Server est un
système bien indiqué.
Le Wamp Serveur contient principalement :
 Un serveur local appelé Apache ;
 Un interpréteur PHP ;
 P a g e | 72

 Un SGBD appelé MySQL utilisant l’outil phpMyAdmin.

Le phpMyAdmin est une interface conviviale qui

permet de gérer très facilement une base de données, sans
nécessiter une connaissance avancée des requêtes SQL. Le
fait que l’interface soit développée en PHP la rend
parfaitement adaptée à l’utilisation conjointe d’une base
MySQL et d’un moteur de scripts PHP. Elle peut donc
fonctionner directement sur le serveur Web et être
accessible par le biais d’un simple navigateur, ce qui
explique sa présence sur la plupart des sites dynamiques
distants (actuellement, phpMyAdmin est le gestionnaire de
bases de données préconisé par la majorité des hébergeurs
proposant des serveurs qui prennent en charge MySQL/PHP). On
peut ainsi créer avec la même facilité des bases de données
et des tables en local comme sur le serveur distant.
Cependant, pour créer une base de données, il suffit juste
de lancer WampServer. Après le lancement, allez du côté
droite de la barre des tâches, cliquez sur l’icône de
WampServer.

Et cliquez sur phpMyAdmin. La page suivante apparait.

Insérer le nom de la
base de donnéés

Ensuite, cliquez sur créer

pour valider la création.
 P a g e | 73

Une fenêtre apparait, vous demandant de mettre le nom de

la table.
a. Création des tables

Après l’exécution la fenêtre suivante apparaitra pour le

remplissage des colonnes ou champs de la base de données.

5.3. Installation des pilotes (drivers)

Il existe un driver spécifique pour chaque SGBD (Système de

Gestion de base de Données : Access, SqlServer, Oracle,
 P a g e | 74

Informix, MySql). Chaque produit a un pilote JDBC adapté

dont certains sont souvent commercialisés par les éditeurs.
Il existe quatre types de driver :

Les pilotes accédant aux bases des données grâce à une

technologie des ponts. Par exemple, le pont ODBC. (Java
soft : toute base accessible par ODBC)
Les pilotes API natif : le code java qu’il renferme
appelle les méthodes C/C++ natives livrées par les
éditeurs de Base de Données et chargées d’interagir avec
ces dernières. (IBM, DB2)
Pilotes qui fournissent au client une API réseau
générique qui, traduite au niveau du serveur, permet
d’accéder aux bases de données. (DataRamp :toute base
accessible avec ODBC ; SCO : Informix)
Pilotes qui interagissent directement avec le
gestionnaire de la base de données via des sockets Java.
(Borland : interbase 4.0 ; Connect software : Sybase,
MS SQL SERVER).

5.3.1. Installation du pilote JDBC MYSQL Driver :

JDBC (Java Data Base Connectivity) est l’interface

JAVA d’accès aux bases de données SQL. Les opérations de
bases y sont définies comme sélectionner la base de données,
exécuter une requête et parcourir le Resultset.

Pour communiquer avec la base de données MYSQL, le

driver est à importer soit manuellement soit incorporer dans
la librairie. Ici avec la version 8 de Netbeans. Dans le cas
où il n’est pas incorporé, il faut le faire manuellement.
Le chargement du pilote MSQL se fait de la manière
suivante :
Un clic droit sur Librairies, choisir « Add Library »
ou « Ajouter la librairie ».
 P a g e | 75

Après ajout ou chargement, le pilote nous importe

toutes les classes, dont :

5.3.2. Importer la BDD dans Java :

Lancer Wampserver jusqu’à ce que son icone devienne

verte.
Après dans java, aller dans « Services » et faites
un clic droit sur Database puis cliquez sur « Nouvelle
connexion » ou « New connection ».
 P a g e | 76

Une boite de dialogue s’ouvre et permet de

selectionner « MYSQL (connector/ J driver) » puis « suivant »
ou « next ».

N.B : dans l’onglet Database, il est selectionné

par defaut MYSQL. On doit l’effacer et spécifier le nom de
sa base de données. Pour notre cas, nous avons choisi
« gestion_du_personnel ». Cliquer sur « tester la connexion »
puis « suivant » et enfin « Terminer ».
 P a g e | 77

Après avoir cliqué sur « terminer », nous aurons à

créer les différentes tables.

5.4. Etude de cas : Gestion de vente de produits

Lors de la création d’un projet, il y a un fichier

[Link], c’est dans ce fichier que seront écrit ces codes
pour l’affichage du formulaire de demarrage.

PAGE_DEMAR PAGE_DEMAR = new PAGE_DEMAR();

 P a g e | 78

PAGE_DEMAR.setVisible(true);
MOT_DE_P MALALA = new MOT_DE_P();

try {
for(int i = 0; i<=100; i++){
[Link](100);
PAGE_DEMAR.[Link](i);
if(i==100){
[Link](true);
PAGE_DEMAR.setVisible(false);
}
}
}
catch (Exception e){
}

N.B : Dans le formlaire de demmarage, placez l’Objet

jProgressBar sur le formulaire, ensuite, faites un
clic droit sur le jProgressBar1, puis cliquer sur
Propriétés et la fenêtre de propriété s’affiche.

Cliquez sur Code.

 P a g e | 79

Après avoir cliqué sur Code, cliquer ensuite sur la

propriété Modificateurs de variable pour changer la
visibilité du jProgressBar1. Choisissez Public.

A l’exécution nous aurons,

 P a g e | 80

FENETRE D’AUTHENTIFICATION

 BOUTON VALIDER
private void
VALIDERActionPerformed([Link] evt) {
// TODO add your handling code here malala:
String Motpass= [Link]();
if([Link]("MALALA")){
MENU MENU = new MENU();
[Link](true);
setVisible(false);
}
else{
[Link](null,"Mot de
passe incorrect !");
[Link]("");
[Link](""); }}
 P a g e | 81

 BOUTON QUITTER
private void
QUITTActionPerformed([Link] evt) {
// TODO add your handling code here:
[Link](0);
}

FENETRE DE SAISIE DES INFORMATIONS

a. Code pour l’importation des packages

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
 P a g e | 82

b. Déclaration de variables servant à la connexion

Connection con;
ResultSet rs;
Statement st;
int CODE_PROD,QUANTITE,PU,PT;
String LIBELLE_PROD;
DefaultTableModel dt;
c. Codes
 Code pour la connexion à la base de données
try{
[Link]("[Link]");
con=[Link]("jdbc:mysql://localhost/bd
gestprod","root","");
st=[Link]();
dt=new DefaultTableModel();
[Link]("CODE_PROD");
[Link]("LIBELLE_PROD");
[Link]("QUANTITE");
[Link]("PU");
[Link]("PT");
[Link](dt);
[Link](null, "Connexion établie");
}catch(Exception e){
[Link](null, "Erreur
\n"+[Link]());}
 Méthodes pour l’affichage de données de la table
try{
[Link](0);
 P a g e | 83

rs=[Link]("Select * From TPRODUIT");

while([Link]()){
CODE_PROD=[Link]("CODE_PROD");
LIBELLE_PROD=[Link]("LIBELLE_PROD");
QUANTITE=[Link]("QUANTITE");
PU=[Link]("PU");
PT=[Link]("PT");
Object[]TPRODUIT ={CODE_PROD,LIBELLE_PROD,QUANTITE,PU,PT};
[Link](TPRODUIT);}
}catch(Exception e){
[Link](null, "Erreur de connexion à
la base\n"+[Link]());}
 BOUTON ENREGISTRER
private void
ENREGISTRERActionPerformed([Link] evt)
{
// TODO add your handling code here:
try{
Statement req=[Link]();
int a;
a = [Link]("Insert into TPRODUIT Values
('"+[Link]()+"','"+[Link]()+"
','"+[Link]()+"','"+[Link]()+
"','"+[Link]()+"')");
Afficher();
[Link](null, "Enregistrement
effectué");
[Link]("");
[Link]("");
[Link]("");
[Link]("");
[Link]("");
}
catch (Exception e){
[Link](null, "Erreur
\n"+[Link]());}}
 P a g e | 84

 BOUTON RECHERCHER
private void
RECHERCHERActionPerformed([Link] evt)
{
// TODO add your handling code here:
try{
Statement req=[Link]();
ResultSet rs=[Link]("Select *
From TPRODUIT WHERE CODE_PROD="+ [Link]());
while([Link]()){
[Link]([Link](2));
[Link]([Link](3));
[Link]([Link](4));
[Link]([Link](5));
}}catch(Exception e){
[Link](null, "Erreur
Code\n"+[Link]());}}

 BOUTON SUPPRIMER
private void
jButton3ActionPerformed([Link] evt) {
// TODO add your handling code here:
try{
if([Link]().length()!=0){
Statement req=[Link]();
int a;
a=[Link]("Delete from
TPRODUIT WHERE CODE_PROD="+ [Link]());
Afficher();
[Link](null,"Suppression réussie");
[Link]("");
[Link]("");
[Link]("");
[Link]("");
[Link]("");

}else{[Link](null,"Remplir le
Code");}
}catch (Exception e){
[Link](null,"Erreur
suppression\n"+[Link]());}}
 P a g e | 85

 BOUTON MODIFIER
private void
jButton4ActionPerformed([Link] evt) {
// TODO add your handling code here:
try{
Statement req=[Link]();
int a;
a = [Link]("UPDATE TPRODUIT SET
LIBELLE_PROD='"+[Link]()+"',QUANTITE='"+jText
[Link]()+"',PU='"+[Link]()+"',PT='"+j
[Link]()+"' Where
CODE_PROD="+[Link]());
Afficher();
[Link](null, "Modification
reussie");
[Link]("");
[Link]("");
[Link]("");
[Link]("");
[Link]("");
}catch (Exception e){
[Link](null, "Erreur
\n"+[Link]());
}}

 BOUTON ANNULER
private void
jButton6ActionPerformed([Link] evt) {
// TODO add your handling code here:
[Link]("");
[Link]("");
[Link]("");
[Link]("");
[Link]("");
}
 P a g e | 86

CONCLUSION
La programmation de nos jours devient un domaine
incontournable de l’informatique, car au-delà de matériels
qui deviennent de plus en plus sophistiqués, avec des très
grandes capacités en termes des performances, il faut
également des logiciels qui puissent être à la hauteur de
ceux-ci.

C’est pourquoi à travers ce cours, il nous a été

donné de faire comprendre aux étudiants, futurs
programmeurs, le bien-fondé du langage java afin de s’y
approprier, d’autant plus qu’au-delà de son caractère
orienté-objet, il tourne sur plusieurs plateformes.

La pratique de la programmation est un exercice par

moment rébarbatif, dans la mesure où, le programmeur est
chaque fois confronté aux multiples bugs. Raison pour
laquelle nous avions à travers ce support, abordé plusieurs
exercices permettant aux apprenants de faire usage des
méthodes les plus faciles de débogage des erreurs qui
surgissent dans le développement des applications.

Certes, Java implémente plusieurs types

d’applications, mais à travers ce cours, notre souci majeur
était de donner aux étudiants tous les rudiments nécessaires
de développement des applications desktop.

Cela dit, nous laissons place aux uns d’apprendre et

aux autres de perfectionner.
 P a g e | 87

Table des matières

INTRODUCTION............................................................................................................................... 1
I. METHODE EXPLOITEE : ................................................................................................... 2
II. STRATEGIES D’EVALUATION : ...................................................................................... 2
III. BIBLIOGRAPHIE ............................................................................................................ 2
CHAPITRE I : INTRODUCTION A LA PROGRAMMATION DESKTOP AVEC JAVA ................. 4
I. La programmation desktop ................................................................................................ 4
1.1. Définition ........................................................................................................................... 4
1.2. Outils et technologies ................................................................................................. 4
1.3. Avantages et inconvénients de la programmation desktop ........................... 5
b) Inconvénients ........................................................................................................................ 6
1.4. Comparaison avec d’autres types de programmation ........................................ 7
2.2. Bref historique du langage Java ..................................................................... 8
2.3. Caractéristiques du langage Java ................................................................... 9
2.4. La machine virtuelle de Java (JVM) ............................................................ 10
2.5. Byte code ................................................................................................................... 11
2.6. Types de compilation ........................................................................................... 12
1. Classe .............................................................................................................................. 13
2. Les objets (instanciation) .................................................................................. 14
2.1. Création d’un objet ............................................................................................. 14
2.3. Les modificateurs d’accès ................................................................................ 15
2.4. Propriétés ou attributs..................................................................................... 16
3. Méthodes ......................................................................................................................... 16
CLASSE STRING .......................................................................................................................... 17
3.1. Les package ............................................................................................................... 19
CHAPITRE II. LES BASES DE LA PROGRAMMATION EN JAVA ....................................... 21
2.1. Identificateur ........................................................................................................ 21
2.2. Commentaire ............................................................................................................... 21
2.3. Opérateurs ................................................................................................................. 22
Opérateurs arithmétiques : .............................................................................................. 22
Exemple pour l’opérateur de pré incrémentation .................................................. 23
Opérateurs logiques ............................................................................................................. 25
Opérateurs de comparaison ................................................................................................ 25
Opérateurs d’affectation .................................................................................................. 26
Opérateurs de données binaires (bit-à-bit) ........................................................... 26
 P a g e | 88

Concaténation .......................................................................................................................... 27
2.4. Variable ..................................................................................................................... 27
Données numériques ............................................................................................................... 29
Booléens ..................................................................................................................................... 29
Caractères ................................................................................................................................. 29
Caractères spéciaux ............................................................................................................. 29
2.4.2. Les types références ....................................................................................... 30
Conversion de types ............................................................................................................. 30
2.5. Les constantes ........................................................................................................ 31
2.6. Instructions ............................................................................................................. 31
b. Instruction de sortie ............................................................................................. 33
CHAPITRE III : STRUCTURE DU LANGAGE JAVA ............................................................... 34
3.1. Structure de contrôle ......................................................................................... 34
a. Structure de contrôle de séquence conditionnelle .................................. 34
L’instruction if else ......................................................................................................... 34
L’instruction switch ........................................................................................................... 37
b. Structure de contrôle de séquences répétitives ...................................... 42
Boucle for ................................................................................................................................. 42
Boucle while (Tant que)..................................................................................................... 44
Boucle do while ...................................................................................................................... 45
3.2. Les tableaux ............................................................................................................. 48
3.2.2. Tableau à plusieurs dimensions ................................................................. 49
3.3. Gestion des exceptions ....................................................................................... 51
- Try, catch et finaly ................................................................................................... 52
CHAPITRE IV : INTERFACES GRAPHIQUES EN JAVA ......................................................... 54
a. Création d’un projet ............................................................................................... 54
i. Ajout d’une interface ............................................................................................. 56
a. Suppression du fichier [Link] ..................................................................... 59
b. Les éléments de base d’une fenêtre ................................................................ 61
i. Utilisations des objets de l’interface ........................................................ 61
Communiquer avec l’utilisateur ..................................................................................... 67
iv. Gestion des composants et des événements ................................................... 68
CHAPITRE V: ACCES AUX BASES DE DONNEES .................................................................... 71
5.1. Package [Link] .................................................................................................... 71
 P a g e | 89

5.3. Installation des pilotes (drivers) ............................................................ 73

5.4. Etude de cas : Gestion de vente de produits....................................... 77
CONCLUSION ................................................................................................................................. 86