Cours Java - CT - Missway - 2023

C.T.
Josué MISSWAY KINDIA

Ir Concepteur
COURS DE LANGAGE DE
PROGRAMMATION III(JAVA)
A l’usage des étudiants de troisième année graduat en
Informatique et des passionnés de développement
Février 2023
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 langage de programmation Java est
destiné aux étudiants de troisième année graduat en
Informatique de Gestion. Son intérêt réside par le fait
qu’actuellement, la plupart des applications
informatiques sont centrées vers une approche dite
orientée-objet.
D’où l’impérieuse nécessité pour les étudiants

d’apprendre ce langage d’autant plus qu’il tourne sur
plusieurs systèmes d’exploitation, ce qui 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.
Java est un langage qui a fait toutes ses preuves

dans le temps, il est et demeure un langage orienté
objet.
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 programmer
objet avec Java, et va aussi aborder les aspects de
programmation graphique. Il sied toutefois 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 six chapitres, de valeur non négligeable, à savoir :
 Le chapitre premier fait une présentation du

langage, en spécifiant quelques généralités
possibles ;
P age |2
 Le deuxième pour sa part, explique les concepts

généralement utilisés en programmation avec leur
adéquation en Java ;
 Le troisième chapitre aborde la structure du langage
java ;
 Le quatrième chapitre quant à lui aborde les notions
de l’orienté-objet avec des exemples précis,
 Le cinquième chapitre gravitera autour de
l’interface graphique en Java à travers l’éditeur
Netbeans.
 Le sixième et dernier chapitre tachera de connecter
Java avec une base de données externe.
I. OBJECTIF DU COURS :
a) Objectif général
Apprendre aux étudiants la programmation orientée-objet

à travers le langage Java.
b) Objectifs spécifiques
L’étudiant qui aura suivi ce cours avec une attention

particulièrement soutenue, sera capable de :
Acquérir des connaissances théoriques de base du

langage Java et par ricochet la programmation
orientée-objet ;
Maitriser un langage neutre sur le plan plate-forme.
Maitriser les outils nécessaires pour le
développement des applications Java notamment en
mode graphique et en mode console;
Connecter Java à une base de données externe.
II. METHODE EXPLOITEE :
Le cours sera dispensé en appliquant la méthode

interro-active pour une formation intégrale de
P age |3
l’étudiant, donc ce dernier sera lui-même au centre de

sa formation et il aura deux volets dont :
- La partie théorique : 45 heures ;

- La partie pratique : 15 heures.
III. STRATEGIES D’EVALUATION :
L’évaluation comprendra des travaux pratiques,

interrogation et examen écrits.
IV. BIBLIOGRAPHIE
a) Ouvrages
1. Boichat, JB., Apprendre Java et C++ en parallèle,
4ème édition, Eyrolles, Paris, 2008.
2. Claude, D., Exercice en Java 5.0, 2ème édition
Eyrolles, Paris, 2006.
3. DJUNGU, SJ, Outils et langages du Web n.0, Ed.
CRIA, Kinshasa, 2013.
4. MUKENGE, J., Le Langage Java et nous, 1ère édition,
CRIGED, Kinshasa, Octobre 2012.
b) Notes de cours
5. Gautier, P., Cours d’initiation à la programmation
orienté-objet avec le langage Java, Pôle
informatique, ENSM Saint-Etienne, 2013-2014.
6. KANGA, E., Cours des questions spéciales de
programmation avancée, L1 Info, ISCBDD, 2016-2017.
7. MISSWAY, J., Cours d’Informatique de Gestion, G3
SCF, ISC-BDD, 2015-2016.
8. MISSWAY,J., Cours de Technique de base de données,
G3 Info, ISC-BDD,2015-2016.
9. MISSWAY, J., cours de langage de programmation
III( Java), G3 info, ISC-BDD, 2016-2017.
10. MUKENGE, J., Cours de Java, G3 Info, ISC Kin,
2014-2015.
P age |4
c) Sites consultés
11. http://www.developpez.com/java
12. http://www.siteduzero.com/tutoriel-3-10601-
programmation-en-java.html
13. http://www.openclassroom.com/java
P age |5
CHAPITRE I : GENERALITES SUR LE JAVA

1.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. Comme C++, Java fait partie intégrante des
langages orientés objets. 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
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.
1.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.
P age |6
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 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.
1.3. Succès 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) ;
P age |7
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.
- 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.
1.4. La machine virtuelle de Java (JVM)

P age |8
La JVM n’est pas une machine physique mais plutôt

virtuelle. Elle sert à compiler le programme Java mais
pas l’exécuter.
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 fichier.class.
Comme nous allons le voir plus tard, la JVM opère

sur deux genres des types notamment primitifs et
référence.
1.5. Byte code
Un programmeur Java écrit son code source, sous

la forme de classes, dans des fichiers dont l’extension
P age |9
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 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.
1.6. Les techniques de base de programmation en Java
Il existe des outils capables de programmer en

Java (plate-forme) ou kit de développement Java appelé
JDK qui est facilement téléchargeable sur internet mais
il faudra y associer un éditeur de textes tels que le
Bloc-notes, mais pour sa compilation, il faut que vous
puissiez utiliser les commandes MS DOS. Soit vous pouvez
utiliser un SDK avec éditeur intégré et quels outils
Java soient installés sur votre machine pour que ladite
compilation se fasse correctement.
De plus, Java exploite les classes sans pourtant

le concevoir. Dans java, tout est classe et tout est
objet. Un objet dépend de la classe.
P a g e | 10
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
P a g e | 11
CHAPITRE II : CONCEPTS FONDAMENTAUX DE PROGRAMMATION

EN JAVA
Ce chapitre é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
P a g e | 12
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 ;.
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érateu Définition Priorit Associativ

r é ité
++/-- pré/post 1 Droite
incrémentation/dec
auto
+/- plus/moins unaire 2 Droite
(signe)
* Multiplication 4 Gauche
/ Division 4 Gauche
% Modulo 4 Gauche
+/- addition/soustract 5 Gauche
ion
P a g e | 13
Exemple
- X+=Y signifie X=X+Y ;

- X-=Y signifie X=X-Y ;
- X*=Y signifie X=X*Y ;
- 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 ;
P a g e | 14
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 :
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
P a g e | 15
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
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;
System.out.println("x+y*z="+calcul);
calcul=x*y%z+t;
System.out.println("x*y%z+t="+calcul);
}
Le résultat après exécution donne :

x+y*z=45
x*y%z+t=4
P a g e | 16
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

< 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 {

int A=5, B=7,C=4;
boolean I;
I=A>B;
System.out.println("A>B="+I);
I=(A>B)|(B==C);
System.out.println("(A>B)|(B==C="+I);
}
}
Le résultat après exécution donnera :
A>B=false
(A>B)|(B==C=false
P a g e | 17
Opérateurs d’affectation

= Affectation 15 Droite
+= ajout et affectation 15 Droite
-= soustraction et 15 Droite
affectation
*= multiplication et 15 Droite
affectation
/= division et 15 Droite
affectation
&= 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.
Opérat Description Exemple avec x=7

eur
~ OU bit-à- Retourne 1 si l'un des 9 ^ 12
bit deux bits de même poids (1001 ^
P a g e | 18
est à 1 (mais pas les 1100) //

deux 5 (0101)
& ET bit-à- Retourne 1 si les deux
bit bits de même poids sont à9 & 12
1 (1001 &
1100)
// 8
(1000)
| OU bit-à- Retourne 1 si l'un ou 9 | 12
bit l'autre des deux bits de (1001 |
même poids est à 1 (ou 1100) //
les deux) 13 (1101)
Les opérateurs suivants effectuent des rotations sur

les bits, c'est-à-dire qu'il décale chacun des bits
d'un nombre de bits vers la gauche ou vers la droite.
Opérateur Description Exemple avec x=7
<< Rotation à Décale les bits vers la 6 << 1 (110
gauche gauche (multiplie par 2 << 1) //
à chaque décalage). des 12 (1100)
zéros sont insérés à
droite
>> Rotation à Décale les bits vers la 6 >> 1
droite avec droite (divise par 2 à (0110 >> 1)
conservatio chaque décalage). Les //3 (0011)
n du signe "0" qui sortent à droite >>>
sont perdus, tandis que
le bit non-nul de poids
plus fort est recopié à
gauche
>>> Rotation à Décale les bits vers la 6 >>> 1
droite avec droite (divise par 2 à (0110 >>>
remplissage chaque décalage). Les 1) // 3
de zéros "0" qui sortent à droite (0011
sont perdus, tandis que
des "0" sont insérés à
gauche
P a g e | 19
2.4. 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";
System.out.println(Pren+Nom);
Le résultat après exécution donnera Caleb Mindele
2.5. 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.
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 ;
P a g e | 20
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.5.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.
Données numériques
Type Taill Description (valeurs
e extrêmes)
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.
P a g e | 21
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 :
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.5.2. Les types références

P a g e | 22
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.
Une classe étant un morceau de code complet et

cohérent qui définit un ensemble d’objets unifiés
logiquement ainsi que leur comportement.
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
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 ;
P a g e | 23
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.6. 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.7. 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.
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.
P a g e | 24
2.7.1. Instruction d’entrée
Elles permettent de faire entrer des données à

partir du clavier.
En voici quelques-unes :
Scanner sc= new Scanner(System.in) :

Cette instruction permet d’instancier un objet de
la classe Scanner. L’instruction String
str=sc.nextline permet de récupérer la chaine
saisie.
Exemple : Lecture d'un texte d'une fenêtre console
package exempleLecture;
import java.util.Scanner;
public class Lecture {
String ligne_lue;
System.out.println("Entrer une string");
Scanner clavier=new Scanner (System.in);
ligne_lue=clavier.nextLine();
System.out.println(ligne_lue);
}
}
bufferedReader clavier=new BufferedReader(new
InputredReader(system.in)) ; 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
package exempleLecture;
import java.io.*;
P a g e | 25
public class Lecture {

String ligne_lue = null;
System.out.println("Entrer une string");
try
{
InputStreamReader lecteur = new

InputStreamReader(System.in);
BufferedReader entree = new BufferedReader(lecteur);
ligne_lue = entree.readLine();
}
catch (IOException err)
{
System.exit(0);
}
System.out.println(ligne_lue);
}
}
2.7.2. Instruction de sortie
Elle permet l’affichage de données à l’écran. Il s’agit

de :
System.out.print(arg) : permet d’imprimer

l’argument qui doit être spécifié par le
programmeur.
Exemple1
System.out.print(˝Je suis malade˝) ;
Le système va afficher le message Je suis malade.
Exemple2
P a g e | 26
Int a =5;
Int b=5 ;
System.out.println(a+b);
Le système affichera 10.
EXERCICES D’APPLICATION
P a g e | 27
CHAPITRE III : STRUCTURE DU LANGAGE 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) System.out.println ("ascendant") ;

else System.out.println ("non ascendant") ;
Plusieurs tests successifs :

P a g e | 28
if(condition1)
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
public class Test {

public static void main(String[] variables) {
Scanner clavier = new Scanner(System.in);
int num1, num2, num3, max;
// Fournir les données d'entrée
System.out.print("Saisir le numéro 1 ");
num1 = clavier.nextInt();
// 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 {
P a g e | 29
// si num1 < num2 et num2 > num3

max = num3;
}
}
// Afficher le résultat
System.out.println("le maximum est = " + max);
// fermer les ressources
clavier.close();
}
}
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 java.util.Scanner ;
public class triangle {
public static void main ( String args [ ]) {
Scanner. Clavier = new Scanner (System.in) ;
Int A, B, C, Sauve ;
System.out.println (‘’ Saisir la valeur de A’’) ;
A = clavier.nextInt() ;
System.out.println (‘’ Saisir la valeur de B’’) ;
B = clavier.nextInt() ;
System.out.println (‘’ Saisir la valeur de C’’) ;
C= clavier.nextInt() ;
// mise en ordre croissant
If (A>=B) { Sauve = A ; A=B ; B=Sauve ;}
If (A>=C) { Sauve = A ; A=C ; C=Sauve ;}

P a g e | 30
If (B>=C) { Sauve = B ; B=C ; C=Sauve ;}
// fin mise en ordre croissant
If ((C*C ) == (A*A) + (B*B)) System.out.println

(‘’triangle rectangle’’) ;
Else
If ((A==B) && (B==C)) System.out.println

(‘’triangle équilatéral’’) ;
else
if( (A==B) && (B<C) || (B>C))

System.out.println(‘’triangle isocèle’’ );
else System.out.println (‘’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 :
P a g e | 31
case valeur4 :
//bloc de code 3&4 ;
break
default : //bloc de code par
défaut ;
}
Exemple 1
int x = 10;
switch (x+1)
{ case 11 : System.out.println(">> case 11");
case 12 : System.out.println(">> case 12");
default : System.out.println(">> 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.
public class Test {

int jour;

System.out.print("Saisir le numéro de jour : ");
jour = clavier.nextInt();
P a g e | 32
switch (jour) {
case 1:
System.out.println("Lundi");
break;
case 2:
System.out.println("Mardi");
break;
case 3:
System.out.println("Mercredi");
break;
case 4:
System.out.println("Jeudi");
break;
case 5:
System.out.println("Vendredi");
break;
case 6:
System.out.println("Samedi");
break;
case 7:
System.out.println("Dimanche");
break;
default:
System.out.println("Entrée invalide!
Veuillez saisir le numéro de jour entre 1 et 7.");
}

clavier.close();
}
}
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".
P a g e | 33
public class Test {

int num;

System.out.print("Saisir un nombre : ");
num = clavier.nextInt();
switch (num % 2) {
/* Si n%2 == 0 */
case 0:
System.out.println("Pair");
break;
/* Sinon n%2 == 1 */
case 1:
System.out.println("Impair");
break;
}

clavier.close();
}
}
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 java.util.Scanner;
public class Test {

int num;

P a g e | 34

num = clavier.nextInt();
switch (num > 0 ? 1 : 0) {

// Num est positif
case 1:
System.out.println(num + " est positif.");
break;
// Num soit négatif soit nul

case 0:
switch (num < 0 ? 1 : 0) {
case 1:
System.out.println(num + " est négatif.");
break;
case 0:
System.out.println(num + " est nul.");
break;
}
break;
}

clavier.close();
}
}
Exemple 5 : Écrivez un programme pour créer une
calculatrice qui exécute des opérations arithmétiques
de base (additionn, soustration, multiplication et
diviseion) en utilisant "switch-case"
public class Test {

P a g e | 35
double num1, num2, resultat = 0;

char op;

System.out.print("Saisir nombre 1 : ");
num1 = clavier.nextDouble();
System.out.print("Saisir l'opérateur: ");

op = clavier.next().charAt(0);
System.out.print("Saisir nombre 2 : ");

num2 = clavier.nextDouble();
switch (op) {
case '+':
resultat = num1 + num2;
break;
case '-':
resultat = num1 - num2;
break;
case '*':
resultat = num1 * num2;
break;
case '/':
resultat = num1 / num2;
break;
default:
System.out.println("Opérateur invalide");
}
System.out.println(num1 + " " + op + " " + num2

+ " = " + resultat);

clavier.close();
}
P a g e | 36
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 :
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.
P a g e | 37
Exemple1
public class Boucle

{ public static void main(String[] args)
{ int i, n, som ;
som = 0 ;
for (i=0 ; i<4 ; i++)
{ System.out.println ("donnez un entier ") ;
n = Clavier.lireInt() ;
som += n ;
}
System.out.println ("Somme : " + som) ;
}
}
Exemple 2
for (int x=0;x<10;x++){
System.out.println("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++)
{
System.out.println ("I="+i+" j="+j);
}
A l’exécution, nous aurons :
I=1 j=1
I=2 j=2
I=3 j=3
I=4 j=4
I=5 j=5
P a g e | 38
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 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

{ int i, n, som ;
som = 0 ;
i = 0 ;
Scanner clavier=new Scanner(System.in) ;
while (i<4)
n = Clavier.nextInt() ;
som += n ;
i++ ;
}
}
}
P a g e | 39
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

{ int i, n, som ;
som = 0 ;
i = 0 ;
Scanner clavier=new Scanner(System.in) ;
do
n = Clavier.nextInt() ;
som += n ;
i++ ;
}
while (i<4) ;
}
}
Exercices
P a g e | 40
1. Ecrire un programme pour afficher tous les nombres

naturels de 1 à n en utilisant la boucle for et
while
public class Test {
int i, n;

System.out.print("Saisir un nombre n : ");
n = clavier.nextInt();
System.out.println("les nombres naturels de 1 à

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

System.out.print(i + "\t");
}
clavier.close();
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
P a g e | 41
public class Test {

int i, n, somme = 0;

n = clavier.nextInt();
// calculer la somme
for (i = 2; i <= n; i += 2) {
somme += i;
}
System.out.println("la somme des nombres pairs

de 1 à " + n + " = " + somme);
clavier.close();}}
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){
P a g e | 42

a++;
if (a==5)
break;
else
// autre truc à faire
}
Ici la boucle s’arrête lorsque a est égal à 5.
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 ;
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.
P a g e | 43
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 [] ;
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 {
int Table []={4,8,6,10,7,1,9,5,3};
int somme=0;
int i=0;
System.out.println("la somme de quelques chiffres");

System.out.println("==============================");
while (i<=7){
System.out.println(""+Table[i]);
P a g e | 44
somme+=Table[i];
i++;
System.out.println(" ---");
System.out.println("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 :
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 {
Scanner sc=new Scanner(System.in);

P a g e | 45
final int ligne = 5;

final int colonne = 3;
double tableau[][]=new double[ligne][colonne];
double somme= 0;
for (int i = 0;i<ligne;i++){
System.out.println("Ligne numero " + (i + 1));
for (int j=0;j<colonne;j++){
System.out.println("Donnez la valeur " + (j + 1) + "");
tableau[i][j]= sc.nextDouble();
}}
for(int i=0;i<ligne;i++){
for(int j=0;j<colonne;j++) {
somme+=tableau[i][j];
}
}
System.out.println("La somme est " + somme);
}
}
}
Exemple : cette fois-ci nous allons voir comment

trouver la somme des éléments sur la diagonale.
public class SOMMEDIAGONALE {

// TODO code application logic here
Scanner sc=new Scanner(System.in);
final int ligne = 3;
final int colonne = 3;
double tableau[][]=new double[ligne][colonne];
P a g e | 46
double somme= 0;
for (int i = 0;i<ligne;i++){
System.out.println("Ligne numero " + (i +
1));
for (int j=0;j<colonne;j++){
System.out.println("Donnez la valeur "
+ (j + 1) + " ");
tableau[i][j] = sc.nextDouble();
} }
for (int i=0;i<ligne;i++){
for (int j=0;j<i;j++)
somme=somme+tableau[i][j];
}
System.out.println("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 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).
P a g e | 47
- 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
P a g e | 48
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.
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ée.La 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.
CHAPITRE IV : LA PROGRAMMATION ORIENTEE-OBJET

La programmation orientée objet existe depuis
l’arrivée des langages Simula I (1961-64) et Simula 67
(1967), conçus par les informaticiens norvégiens Ole-
Johan Dahl et Kristan Nygaard. Simula 67 contenait déjà
les objets, les classes, l’héritage, l’encapsulation,
etc.
Alan Kay, du PARC de Xerox, avait utilisé Simula

dans les années 1960. Il réalisa en 1976 Smalltalk qui
reste, aux yeux de certains programmeurs, le meilleur
langage de programmation par objets.
P a g e | 49
Cependant, elle n’est devenue vraiment un des

paradigmes de la programmation qu’au milieu des années
1980. L'idée de base de la programmation orientée objet
est de rassembler dans une même entité appelée objet les
données et les traitements qui s'y appliquent.
En programmation traditionnelle, les données et

opérations sont séparées, les structures de données sont
donc envoyées aux procédures et fonctions qui les
utilisent. La programmation orientée objet résout de
nombreux problèmes inhérents à cette conception en
mettant dans une même entité les attributs et les
opérations. Cela est plus proche du monde réel, dans
lequel tous les objets disposent d’attributs auxquels
sont associés des activités.
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.
4.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 desobjets) et
un ensemble de méthodes de traitement de ces données
et/ou de données extérieures à la classe. On parle
P a g e | 50
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
4.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.
Un objet est une instance 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.
Cercle mon_rond;
mon_rond = new Cercle();
4.2.1. Création d’un objet

P a g e | 51
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;
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
4.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).
P a g e | 52
4.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.
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.
4.3.1. Mots clés gérant la visibilité
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 :Une variable, méthode ou classe déclarée

public est visible par tous les autres objets. Dans
la philosophie orientée objet aucune donnée d'une
classe ne devraient être déclarée publique : il est
préférable d'écrire des méthodes pour la consulter
et la modifier
Protected : Si une classe, une méthode ou une
variable est déclarée, seules les méthodes présentes
dans le même package que cette classe ou ses sous
classes pourront y accéder. On ne peut pas qualifier
une classe avec protected.
Private : C'est le niveau de protection le plus
fort. Les composants ne sont visibles qu'à
l'intérieur de la classe : ils ne peuvent être
P a g e | 53
modifiés que par des méthodes définies dans la

classe prévues à cet effet. Les méthodes déclarée
private ne peuvent pas être en même temps déclarée
abstract car elles ne peuvent pas être redéfinies
dans les classes filles.
4.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.
4.5. 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.
4.5.1. Déclaration
La syntaxe de la déclaration d'une méthode est :
modificateurs type_retourné nom_méthode ( arg1, ... )

{... }
// définition des variables locales et du bloc

d'instructions
}
P a g e | 54
Le type retourné peut être élémentaire ou

correspondre à un objet. Si la méthode ne retourne rien,
alors on utilise void.
4.5.2. Passage de paramètres
Lorsqu'un objet est passé en paramètre, ce n'est

pas l'objet lui-même qui est passé mais une référence
sur l'objet. La référence est bien transmise par valeur
et ne peut pas être modifiée mais l'objet peut être
modifié via un message (appel d'une méthode).
Pour transmettre des arguments par référence à

une méthode, il faut les encapsuler dans un objet qui
prévoit les méthodes nécessaires pour les mises à jour.
Si un objet o transmet sa variable d'instance v

en paramètre à une méthode m, deux situations sont
possibles :
si v est une variable primitive alors elle est

passée par valeur : il est impossible de la modifier
dans m pour que v en retour contiennent cette
nouvelle valeur.
Si v est un objet alors m pourra modifier l'objet
en utilisant une méthode de l'objet passé en
paramètre.
4.5.3. Surcharge de méthodes
La surcharge d'une méthode permet de définir

plusieurs fois une même méthode avec des arguments
différents. Le compilateur choisit la méthode qui doit
être appelée en fonction du nombre et du type des
arguments. Ceci permet de simplifier l'interface des
classes vis à vis des autres classes.
P a g e | 55
Une méthode est surchargée lorsqu'elle exécute

des actions différentes selon le type et le nombre de
paramètres transmis.
4.5.4. Constructeur
Chaque classe doit définir une ou plusieurs

méthodes particulières appelées des constructeurs.
Un constructeur est une méthode particulière qui

est appelée automatiquement à la création d'un objet et
qui permet d'initialiser correctement cet 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é).
En java, les objets ne peuvent être créés que par

allocation dynamique. Le constructeur est appelé lors de
l'allocation de l'objet par new (et non lors de la
déclaration de la référence).
Un constructeur se reconnaît facilement en Java:
il porte le même nom que la classe

il n'a pas de type de retour (même pas void)
On peut évidemment définir plusieurs constructeurs pour

une même classe, s'ils ont une signature différente.
Modification de la classe compte : la méthode Init est
remplacée par deux constructeurs:
La syntaxe de la déclaration d'une méthode est :
modificateurs type_retourné nom_méthode ( arg1, ... )
{... }
// définition des variables locales et du bloc
d'instructions
P a g e | 56
}
4.5.5. 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=chaine1.toLowerCase();
System.out.println(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
*/
// TODO code application logic her
String chaine1,chaine2;
chaine1="papa";
chaine2=chaine1.toUpperCase();
}
Ce programme affiche à l’exécution PAPA.
P a g e | 57
c) Concat () : permet de concaténer deux chaines de

caractère.
Exemple :
/**
*/
String chaine1,chaine2,chaine3;
chaine1="ISC";
chaine2=" BANDUNDU";
chaine3=chaine1.concat(chaine2);
}
}
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 {
/**
*/
String chaine1,chaine2,chaine3;
chaine1="KISANGANI";
chaine2="KINGASANI";
if (chaine1.equals(chaine2))
System.out.println("les deux chaines
identiques");
else
System.out.println("les deux chaines ne sont
pas identiques");
}
P a g e | 58
}
A l’exécution le programme affiche le second message
car, les deux chaines ne sont pas identitiques.
e) Length () : permet de donner la longueur d’une chaine
de caractère.
package exemple_class_string;
/**
*
* @author JMK Missway
*/
/**
*/
String chaine;
chaine="KISANGANI";
int longueur;
longueur=chaine.length();
System.out.println(longueur);
}
P a g e | 59
}
A l’exécution, ce programme affiche 9 comme nombre de
caractères composant la chaine KISANGANI.
4.6. Les packages
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 :
Package Description
java.awt Classes graphiques et de gestion
d’interfaces
java.io Gestion des entrées/sorties
java.lang Classes de base (importé par défaut)
java.util Classes utilitaires
javax.swing Autres classes graphiques
Java.sql Accès aux données de base de données
et traitement
Java.math Classe permettant des calculs en
précision entière et en virgule
flottante
Java.text Support de localisation pour la
gestion des textes, des dates, des
nombres et des messages
Java.net 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
P a g e | 60
java.util 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 java.util.Date;
toutes les classes du package sont importées (même
les classes non utilisées) :
import java.util.*;
Le programme suivant utilise cette classe pour afficher

la date actuelle :
import java.util.Date;
public class DateMain {
Date today = new Date();
System.out.println(”Nous sommes le ” +
today.toString());
}
}
CHAPITRE V : 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 !
5.1. Création d’un projet
Nous allons aborder ce point, en y illustrant avec un

exemple à l’appui.
P a g e | 61
Pour créer un fichier, nous allons procéder comme suit :
Dans le menu Fichier, cliquer sur Nouveau projet
Dans Nouveau projet, choisissez Application java

P a g e | 62
Vous devriez contrôler l’emplacement de votre projet

P a g e | 63
5.1.1. Ajout d’une interface
Le projet initial se compose uniquement d’un

fichier Main.java. Il s’agit par défaut d’une
application console appelée Main.java
P a g e | 64
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 | 65
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 | 66
A ce niveau nous avons maintenant deux fichier

le Main.Java et mon_formulaire.Java
a. Suppression du fichier Main.java
Faites un clic droit sur Main.java, dans le menu

contextuel, cliquez sur Supprimer.
5.1.2. Compilation du projet
En cliquant sur , NetBeans vous demandera de

sélectionner la classe mon_formulaire
P a g e | 67
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 | 68
5.2. Les éléments de base d’une fenêtre

5.2.1. 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 | 69
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 | 70
Ceci étant, nous allons maintenant nommer notre

formulaire en lui donnant le nom CALCULATRICE et cela à
partir de la propriétés Title.
Après exécution, nous aurons :

P a g e | 71
5.2.2. 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 | 72
Après avoir saisie Quitter et une fois valider par la

touche Entrée, vous obtiendrez :
5.2.3. 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 | 73
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 | 74
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 :
P a g e | 75
A l’exécution, nous aurons
5.2.4. 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 à gauche.Label.RIGHT
justifie le texte à droite, Label.CENTER justifie
le texte au centre ;
P a g e | 76
setFont() : permet de fixer la police et la taille

d’un Label
getText() : retourne le texte contenu dans une
étiquette ;
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 | 77
Code source
int i,j,resultat;
String Chaine1, Chaine2, Chaine3;
// récuparation des deux données au format
String...
Chaine1 = jTextField2.getText();
Chaine2 = jTextField3.getText();
// converson en int
i = Integer.parseInt(Chaine1);
j = Integer.parseInt(Chaine2);
// addition
resultat = i + j;
// conversion en chaine
Integer rr = new Integer(resultat);
Chaine3 = rr.toString();
// on affiche le résultat
jTextField4.setText(Chaine3);
}
P a g e | 78
CHAPITRE VI: 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 java.sql.
6.1. Package java.sql
Ce package a deux principes classes :

Java.sql.DriverManager :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.
Java.sql.ResultSet :cette classe symbolise un
ensemble de résultats dans une base de données et
autorisel’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.
6.2. 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, Informix). Chaque produit a un pilote JDBC adapté
P a g e | 79
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).
6.3. Création de la base de données sous SQL Server
2008 r2
Pour créer la base de données avec Sql Server, il faut

suivre la démarche suivante :
Après son lancement, cette boite de dialogue

apparait :
P a g e | 80
Authentification
Cliquez ici pour se windows
connecter
cliquez sur « Se conn », après s’être connecté, la

fenêtre suivante, qui est l’interface de SQL Server
Management Studio s’affiche comme suit :
P a g e | 81
Faites un clic-droit sur base de données, ensuite

cliquer sur « Nouvelle base de données » ; une boite
de dialogue apparait vous permettant de saisir le
nom de la base de données et de spécifier son
emplacement si possible. Par exemple BDDGEST_ETUD
Enfin, cliquez sur ok
a. Création de la table
Pour créer la table, il suffit de :
Dérouler l’onglet base de données ;

Cliquer sur le signe + placé à côté de votre base
de données BDDGEST_ETUD ainsi créée ;
Faites un clic-droit sur table, la fenêtre suivante
apparait, vous permettant de structurer votre table
en y nommant les champs et le spécifiant la taille.
Enfin, donnez-en un nom, exemple T_Etudiant
b. Création de la Source de données ODBC pour SQL

Server
P a g e | 82
La démarche se veut être la suivante :
Aller dans panneau de configuration ;

Cliquer sur Outils d’administration ;
Cliquer sur source de données ODBC, la fenêtre
suivante apparait :
Cliquez sur ajouter

Une autre boite de dialogue apparait, vous
demandant de sélectionner le pilote pour lequel
vous souhaitez définir la source de données. Pour
le cas précis, sélectionner SQL server puis
cliquer sur Terminer.
Entrer le nom de la source de données, puis
sélectionner à l’aide du combobox, le serveur
auquel la base de données est attachée puis
cliquer sur suivant.
P a g e | 83
6.4. Se connecter et utiliser la source de donnés

a. Requête de sélection
L’objet connection créé va permettre d’interagir

avec la base. Pour réaliser des requêtes de sélection,
un objet de type Statement doit être généré.
Statement requete=con.createStatement() ;
Le résultat d’une requête est récupéré au moyen

d’un objet de type ResulSet. Cette interface permet
d’accéder aux données extraites grâce à la requête.
Resultset resultat=requete.executeQuery("select*
from T_Etudiant") ;
Après la requête, le curseur est positionné juste

avant la première ligne du résultat, la méthode next()
permet d’avancer d’enregistrement en enregistrements
séquentiellement.
resultat.next()
pour récupérer les données dans chaque colonne,

l’interface ResultSet propose plusieurs méthodes
adaptées aux types des données récupérées :
getstring(NumColonne), getInt(NumColonne),
getDate(NumColonne),….
P a g e | 84
6.5. Etude de cas : Gestion de vente de produits
Lors de la création d’un projet, il y a un fichier

Main.Java, c’est dans ce fichier que seront écrit ces
codes pour l’affichage du formulaire de demarrage.
PAGE_DEMAR PAGE_DEMAR = new PAGE_DEMAR();

PAGE_DEMAR.setVisible(true);
MOT_DE_P MALALA = new MOT_DE_P();
try {
for(int i = 0; i<=100; i++){
Thread.sleep(100);
PAGE_DEMAR.jProgressBar1.setValue(i);
if(i==100){
MALALA.setVisible(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.
P a g e | 85
Cliquez sur Code.
Après avoir cliqué sur Code, cliquer ensuite sur

la propriété Modificateurs de variable pour changer la
visibilité du jProgressBar1. Choisissez Public.
P a g e | 86
A l’exécution nous aurons,
FENETRE D’AUTHENTIFICATION
P a g e | 87
 BOUTON VALIDER
private void
VALIDERActionPerformed(java.awt.event.ActionEvent evt)
{
// TODO add your handling code here malala:
String Motpass= jPasswordField1.getText();
if(Motpass.contains("MALALA")){
MENU MENU = new MENU();
MENU.setVisible(true);
setVisible(false);
}
else{
JOptionPane.showMessageDialog(null,"Mot de
passe incorrect !");
jTextField1.setText("");
jPasswordField1.setText("");
}
}
 BOUTON QUITTER
private void
QUITTActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
System.exit(0);
}
P a g e | 88
FENETRE DE MENU GENERAL
 BOUTON ENREGISTREMENT
private void
ENREGActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here malala:
ENREGISTREMENT TAMFUMU = new ENREGISTREMENT();
TAMFUMU.setVisible(true);
setVisible(false);
}
P a g e | 89
FENETRE D’ENREGISTREMENT DES INFORMATIONS
 BOUTON ENREGISTRER
private void
ENREGISTRERActionPerformed(java.awt.event.ActionEvent
evt) {
try{
Statement req=con.createStatement();
int a;
a = req.executeUpdate("Insert into TPRODUIT Values
("+jTextField1.getText()+",'"+jTextField2.getText()
+"','"+jTextField3.getText()+"','"+jTextField4.getT
ext()+"','"+jTextField5.getText()+"')");
Afficher();
JOptionPane.showMessageDialog(null, "Enregistrement
effectué");
}
P a g e | 90
catch (Exception e){

JOptionPane.showMessageDialog(null, "Erreur
\n"+e.getMessage());
}}
 BOUTON RECHERCHER
private void
RECHERCHERActionPerformed(java.awt.event.ActionEvent
evt) {
try{
ResultSet rs=req.executeQuery("Select *
From TPRODUIT WHERE CODE_PROD="+
jTextField1.getText());
while(rs.next()){
jTextField2.setText(rs.getString(2));
}}catch(Exception e){
Code\n"+e.getMessage());}}
 BOUTON SUPPRIMER
private void
jButton3ActionPerformed(java.awt.event.ActionEvent evt)
{
try{
if(jTextField1.getText().length()!=0){
int a;
a=req.executeUpdate("Delete from
TPRODUIT WHERE CODE_PROD="+ jTextField1.getText());
Afficher();
JOptionPane.showMessageDialog(null,"Suppression
reussie");
P a g e | 91
}else{JOptionPane.showMessageDialog(null,"Remplir le
Code");}
}catch (Exception e){
JOptionPane.showMessageDialog(null,"Erreur
suppression\n"+e.getMessage());}
}
 BOUTON MODIFIER
private void
{
try{
int a;
a = req.executeUpdate("UPDATE TPRODUIT SET
LIBELLE_PROD='"+jTextField2.getText()+"',QUANTITE='"+jT
extField3.getText()+"',PU='"+jTextField4.getText()+"',P
T='"+jTextField5.getText()+"' Where
CODE_PROD="+jTextField1.getText());
Afficher();
JOptionPane.showMessageDialog(null, "Modification
reussie");
}catch (Exception e){
\n"+e.getMessage());
}}
P a g e | 92
 BOUTON ANNULER
private void
{
}
 BOUTON QUITTER
private void
jButton7ActionPerformed(java.awt.event.ActionEvent
evt) {
System.exit(0);
}
P a g e | 93
EXERCICES RESOLUS EN JAVA

1. Quels résultats fournit ce programme ?
public class OpIncr

{ int i, j, n ;
i = 0 ; n = i++ ;
System.out.println ("A : i = " + i + " n = " + n
) ;
i = 10 ; n = ++ i ;
System.out.println ("B : i = " + i + " n = " + n
) ;
i = 20 ; j = 5 ; n = i++ * ++ j ;
System.out.println ("C : i = " + i + " j = " + j +
" n = " + n ) ;
i = 15 ; n = i += 3 ;
System.out.println ("D : i = " + i + " n = " + n)
;
i = 3 ; j = 5 ; n = i *= --j ;
System.out.println ("E : i = " + i + " j = " + j +
" n = " + n) ;
}
}
Solution
A : i = 1 n = 0
B : i = 11 n = 11
C : i = 21 j = 6 n = 120
D : i = 18 n = 18
E : i = 12 j = 4 n = 12
2. Quels résultats fournit ce programme ?
public class OpCond
{ int n=10, p=5, q=10 ;
n = p = q = 5 ;
P a g e | 94
n += p += q ;
System.out.println ("A : n = " + n + " p = " +
p + " q = " + q) ;
q = n < p ? n++ : p++ ;
System.out.println ("B : n = " + n + " p = " +
p + " q = " + q) ;
q = n > p ? n++ : p++ ;
System.out.println ("C : n = " + n + " p = " +
p + " q = " + q) ;
}
}
Solution
A : n = 15 p = 10 q = 5
B : n = 15 p = 11 q = 10
C : n = 16 p = 11 q = 15
3. Quelles erreurs ont été commises dans chacun des
groupes d’instructions suivants. On suppose que les
variables concernées sont d’un type primitif
numérique et qu’elles ont été correctement déclarées
(un groupe ne comporte aucune erreur) :
// groupe 1
if (a < b) System.out.println ("ascendant")
// groupe 2
if (a < b) { System.out.println ("ascendant) ; max = b
}
// groupe 3
int n, p ;
.....
switch (n) { case 2 : System.out.println ("petit") ;
break ;
case p : System.out.println ("limite") ;
break ;
P a g e | 95
}
// groupe 4
int n ;
final int LIMITE = 20 ;
.....
switch (n) { case LIMITE-1 : System.out.println ("un peu
trop petit") ; break ;
case LIMITE : System.out.println ("OK")
; break ;
case LIMITE+1 : System.out.println ("un peu
trop grand") ; break ;
}
Solution
Groupe 1
Il manque un point-virgule à la fin du premier appel de
System.out.println :
if (a < b) System.out.println ("ascendant") ;
Groupe 2
Il manque un point-virgule à la fin de la deuxième
instruction du bloc :
if (a < b) { System.out.println ("ascendant) ; max = b
; }
4. Soit le programme suivant :
public class Exerc

{ int i, n, som ;
som = 0 ;
for (i=0 ; i<4 ; i++)
som += n ;
P a g e | 96
}
}
}
Écrire un programme réalisant la même chose en
employant à la place de l’instruction for :
1. une instruction while,
2. une instruction do... while
Solution
Avec une instruction while :
public class ExoII4b
{ int i, n, som ;
som = 0 ;
i = 0 ;
while (i<4)
som += n ;
i++ ;
Avec une instruction do... while :

P a g e | 97
public class ExoII4c
{ int i, n, som ;
som = 0 ;
i = 0 ;
do
som += n ;
i++ ;
while (i<4) ;
5. Quels résultats fournit le programme suivant ?
public class ExoII5

{ int n=0 ;
do
{ if (n%2==0) {System.out.println (n + " est
pair") ;
n += 3 ;
continue ;
}
P a g e | 98
if (n%3==0) {System.out.println (n + " est

multiple de 3") ;
n += 5 ;
}
if (n%5==0) {System.out.println (n + " est
multiple de 5") ;
break;
}
n += 1 ;
}
while (true) ;
}
}
Solution
0 est pair
3 est multiple de 3
9 est multiple de 3
15 est multiple de 3
20 est multiple de 5
P a g e | 99
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
classiques.
Cela dit, nous laissons place aux uns d’apprendre

et aux autres de perfectionner.
P a g e | 100
Table des matières

INTRODUCTION............................................................................................................................... 1
I. OBJECTIF DU COURS : ................................................................................................... 2
II. METHODE EXPLOITEE : ................................................................................................... 2
III. STRATEGIES D’EVALUATION : .................................................................................. 3
IV. BIBLIOGRAPHIE ................................................................................................................ 3
CHAPITRE I : PRESENTATION DU LANGAGE JAVA ............................................................... 5
1.2. Bref historique du langage Java ..................................................................... 5
1.3. Succès du langage Java ......................................................................................... 6
1.4. La machine virtuelle de Java (JVM) .............................................................. 7
1.5. Byte code ..................................................................................................................... 8
1.6. Les techniques de base de programmation en Java .................................. 9
CHAPITRE II : CONCEPTS FONDAMENTAUX DE PROGRAMMATION EN JAVA ................. 11
2.1. Identificateur ........................................................................................................ 11
2.2. Commentaire ............................................................................................................... 12
2.3. Opérateurs ................................................................................................................. 12
Opérateurs arithmétiques : .............................................................................................. 12
Exemple pour l’opérateur de pré incrémentation .................................................. 14
Opérateurs logiques ............................................................................................................. 16
Opérateurs de comparaison ................................................................................................ 16
Opérateurs d’affectation .................................................................................................. 17
Opérateurs binaires ............................................................................................................. 17
2.4. Concaténation .......................................................................................................... 19
2.5. Variable ..................................................................................................................... 19
Données numériques ............................................................................................................... 20
Booléens ..................................................................................................................................... 21
Caractères ................................................................................................................................. 21
Caractères spéciaux ............................................................................................................. 21
2.5.2. Les types références ....................................................................................... 21
Conversion de types ............................................................................................................. 22
2.6. Les constantes ........................................................................................................ 23
2.7. Instructions ............................................................................................................. 23
2.7.2. Instruction de sortie ..................................................................................... 25
CHAPITRE III : STRUCTURE DU LANGAGE JAVA ............................................................... 27
3.1. Structure de contrôle ......................................................................................... 27
P a g e | 101
a. Structure de contrôle de séquence conditionnelle .................................. 27

L’instruction if else ......................................................................................................... 27
L’instruction switch ........................................................................................................... 30
b. Structure de contrôle de séquences répétitives ...................................... 36
Boucle for ................................................................................................................................. 36
Boucle while (Tant que)..................................................................................................... 38
Boucle do while ...................................................................................................................... 39
3.2. Les tableaux ............................................................................................................. 42
3.2.2. Tableau à plusieurs dimensions ................................................................. 44
3.3. Gestion des exceptions ....................................................................................... 46
- Try, catch et finaly ................................................................................................... 47
CHAPITRE IV : LA PROGRAMMATION ORIENTEE-OBJET .................................................... 48
4.1. Classe .......................................................................................................................... 49
4.2. Les objets (instanciation) .............................................................................. 50
4.2.1. Création d’un objet ......................................................................................... 50
4.3. Les modificateurs d’accès ................................................................................ 52
4.3.1. Mots clés gérant la visibilité ................................................................. 52
4.4. Propriétés ou attributs..................................................................................... 53
4.5. Méthodes ..................................................................................................................... 53
4.5.2. Passage de paramètres ..................................................................................... 54
4.5.3. Surcharge de méthodes ..................................................................................... 54
4.5.4. Constructeur ......................................................................................................... 55
4.5.5. CLASSE STRING ...................................................................................................... 56
4.6. Les packages ............................................................................................................. 59
CHAPITRE V : INTERFACES GRAPHIQUES EN JAVA ........................................................... 60
5.1. Création d’un projet ........................................................................................... 60
5.1.1. Ajout d’une interface ..................................................................................... 63
a. Ajout d’un composant visuel ................................................................................ 64
b. Suppression du fichier Main.java ..................................................................... 66
5.2. Les éléments de base d’une fenêtre ............................................................ 68
5.2.1. Utilisations des objets de l’interface ................................................ 68
Communiquer avec l’utilisateur ..................................................................................... 74
5.2.4. Gestion des composants et des événements ........................................... 75
CHAPITRE VI: ACCES AUX BASES DE DONNEES ................................................................. 78
P a g e | 102
6.1. Package java.sql .................................................................................................... 78

6.2. Installation des pilotes (drivers) ............................................................ 78
a. Création de la table ............................................................................................... 81
b. Création de la Source de données ODBC pour SQL Server ....................... 81
6.4. Se connecter et utiliser la source de donnés....................................... 83
a. Requête de sélection ............................................................................................... 83
6.5. Etude de cas : Gestion de vente de produits....................................... 84
EXERCICES RESOLUS EN JAVA ................................................................................................ 93
CONCLUSION ................................................................................................................................. 99

Cours Java - CT - Missway - 2023

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

Cours Java - CT - Missway - 2023

Transféré par

Droits d'auteur :

Formats disponibles

C.T.

Josué MISSWAY KINDIA

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

D’où l’impérieuse nécessité pour les étudiants

Les passionnés ou les initiés en programmation

Java est un langage qui a fait toutes ses preuves

Le but de ces notes de cours est de donner un

Le développement de ce cours est structuré autour

 Le chapitre premier fait une présentation du

 Le deuxième pour sa part, explique les concepts

Apprendre aux étudiants la programmation orientée-objet

L’étudiant qui aura suivi ce cours avec une attention

Acquérir des connaissances théoriques de base du

II. METHODE EXPLOITEE :

Le cours sera dispensé en appliquant la méthode

l’étudiant, donc ce dernier sera lui-même au centre de

- La partie théorique : 45 heures ;

III. STRATEGIES D’EVALUATION :

L’évaluation comprendra des travaux pratiques,

CHAPITRE I : GENERALITES SUR LE JAVA

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

Outre son orientation objet, le langage Java a

L’objectif principal de Java est d’augmenter la

1.2. Bref historique du langage Java

Le langage Java trouve ses origines dans les

Bill Joy (co-fondateur de SUN Microsystems) sauve

1.3. Succès du langage Java

Java possède un certain nombre de

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

1.4. La machine virtuelle de Java (JVM)

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

Indépendant Indépendant Java

Le code que java exécute après compilation

La JVM est une machine à pile, elle supporte les

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

1.5. Byte code

Un programmeur Java écrit son code source, sous

est .java. Ce code source est alors compilé par le

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

Ce code particulier se trouve dans les fichiers

1.6. Les techniques de base de programmation en Java

Il existe des outils capables de programmer en

De plus, Java exploite les classes sans pourtant

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

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

CHAPITRE II : CONCEPTS FONDAMENTAUX DE PROGRAMMATION

L’identificateur est le nom choisi pour appeler

Un identificateur doit commencer par une lettre ;

L’utilisation des majuscules dans un

Un identificateur ne peut pas appartenir à la

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

Ils ne sont pas pris en compte par le compilateur

Il existe trois types de commentaire en Java :

//……. (sur une ligne)

Il existe cinq types d’opérateurs :

Opérateu Définition Priorit Associativ

- X+=Y signifie X=X+Y ;

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

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

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

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

nouvelle valeur incrémentée qui est utilisée, ce qui

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