Prepar Javadebutant - 113415 - 114146 - 114638

INDIGO
Computing Learning Center

Kinshasa 2021
INTRODUCTION GÉNÉRALE
Java est un langage objet permettant le développement d’applications

complètes s’appuyant sur les structures de données classiques (tableaux, fichiers) et
utilisant abondamment l’allocation dynamique de mémoire pour créer des objets en
mémoire. La notion de structure, ensemble de données décrivant une entité (un objet
en Java) est remplacée par la notion de classe au sens de la programmation objet. Le
langage Java permet également la définition d’interfaces graphiques (GUI : Graphical
User Interface) facilitant le développement d’applications interactives et permettant à
l’utilisateur de "piloter" son programme dans un ordre non imposé par le logiciel.
Le langage est aussi très connu pour son interactivité sur le Web facilitant
l’insertion dans des pages Web, au milieu d’images et de textes, de programmes
interactifs appelés "applets1". Pour des problèmes de sécurité, ces applets sont
contrôlées et souvent limitées dans leur interaction avec le système d’exploitation de
l’ordinateur sur lequel elles se déroulent : limitation des accès aux fichiers locaux ou
aux appels système de la machine.
Un programme Java est portable au sens où il peut s’exécuter sur des

ordinateurs fonctionnant avec différents systèmes d’exploitation. Les programmes
écrits en Pascal ou en langage C sont aussi portables par compilation du code source
sur la machine où le programme doit s’exécuter. Java est portable d’une plate-forme
(matériel et système d’exploitation) à une autre sans recompilation. Le compilateur
produit un langage intermédiaire appelé "bytecode" qui est interprété sur les
différentes machines. Il suffit donc de communiquer le bytecode et de disposer d’un
interpréteur de bytecode pour obtenir l’exécution d’un programme Java. Les
navigateurs du Web ont intégré un interpréteur de bytecode qui leur permet d’exécuter
des programmes (applets) Java.
Cette portabilité est possible grâce à une normalisation indépendante de la

plateforme : les entiers, par exemple, ont toujours la même longueur (en nombre
d’octets) en Java quel que soit l’ordinateur, ce qui n’est pas le cas des langages C ou
C++ (le type int peut occuper 2 ou 4 octets suivant les machines). Cette portabilité est
1
Applet (nf) est l’acronyme de Application light weight.
1|Java pour Débutant
Yambi Kumuré |2
souvent résumée de manière un peu commerciale par write once, run anywhere
(écrivez une seule fois, exécutez n’importe où). Les programmes en Java ont
l’extension .java, et le bytecode généré a l’extension .class
En d’autres termes, Java est un langage interprété, ce qui signifie qu’un

programme compilé n’est pas directement exécutable par le système d’exploitation
mais il doit être interprété par un autre programme, qu’on appelle interpréteur.
Prenons l’exemple d’un langage de programmation comme C, avec le

lange, si on a le code source écrit en langage C que l’on va compilé à l’aide d’un
compilateur qui va traduire le code source en code binaire et le microprocesseur qui va
interpréter le code binaire.
Le problème ici est que lorsque vous compilez, vous obtenez un code
source qui est spécifique à des équipements particuliers. C’est-à-dire si compilez sous
Windows, le code binaire ne peut être interprété que sous Windows même pour Unix,
même pour MacOs, etc. Et pour utiliser le même code, il lui faut apporter des
modifications pour chaque système d’exploitation.
Mais avec Java, après la compilation du code source, au lieu d’obtenir le

code binaire, on obtient le Byte Code qui est indépendant du système d’exploitation.
Pour exécuter ce Byte Code, vous devez disposer d’une machine virtuelle dépendant
d’un système d’exploitation, c'est-à-dire si j’ai Windows, je dois avoir une machine
virtuelle spécifique pour Windows, mêmement pour Unix, MacOs, etc., mais le Byte
Code reste unique. La machine virtuelle se charge de traduire le Byte Code en code
binaire. Et ce code binaire est interprété par le microprocesseur.
La figure 1.1 illustre ce fonctionnement.

Compilateur
Code Byte Code
Javac
source
-
-
Interpréteur
Machine
Virtuelle Java
Code Binaire
10101010101 Système
01010101010 d’Exploitation
10101010101
01010100011
En d’autres termes, 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 javac en un langage appelé bytecode et
enregistre le résultat dans un fichier dont l’extension est .class. Le bytecode
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 bytecode reste le même quel que soit l’environnement
d’exécution.
En 2009, Sun Microsystems est racheté par Oracle Corporation qui fournit
dorénavant les outils de développement Java SE (Standard Edition) contenus dans le
Java Development Kit (JDK). Au moment où nous écrivons ces notes de cours, la
dernière version stable est le JDK 8u20
Compilation
La compilation s’effectue par la commande javac suivie d’un ou plusieurs

noms de fichiers contenant le code source de classes Java. Par exemple, javac
MyProg.java compile la classe My-Prog dont le code source est situé dans le
fichier MyProg.java. La compilation nécessite souvent la précision de certains

Yambi Kumuré |4
paramètres pour s’effectuer correctement, notamment lorsque le code source fait

référence à certaines classes situées dans d’autres répertoires que celui du code
compilé. Il faut alors ajouter l’option -classpath suivie des répertoires (séparés par
un ; sous Windows et : sous Unix) des classes référencées. Par exemple :
javac -classpath /prog/exos1:/cours MyProg.java compilera le

fichier MyProg.java si celui-ci fait référence à d’autres classes situées dans les
répertoires /prog/exos1 et /cours. Le résultat de cette compilation est un fichier
nommé My-Prog.class contenant le bytecode correspondant au code source
compilé. Ce fichier est créé par défaut dans le répertoire où la compilation s’est
produite. Il est cependant fortement souhaitable de ne pas mélanger les fichiers
contenant le code source et ceux contenant le bytecode. Un répertoire de destination
où sera créé le fichier MyProg.class peut être précisé par l’option -d, par exemple
: javac -d /prog/exos1 -classpath /cours MyProg.java
Interprétation
Le bytecode obtenu par compilation ne peut être exécuté qu’à l’aide de

l’interpréteur. L’exécution s’effectue par la commande java suivie du nom de la classe
à exécuter (sans l’extension .class). Comme lors de la compilation, il se peut que des
classes d’autres répertoires soient nécessaires. Il faut alors utiliser l’option -
classpath comme dans l’exemple qui suit : java -classpath
/prog/exos1:/cours MyProg.
Environnement d’exécution
Pour saisir notre code source, nous avons besoin d’un éditeur de texte.
Généralement pour coder, on peut utiliser un Environnement de Développement
Intégré (EDI). En plus d’un éditeur de texte, un EDI comporte un compilateur et un
Débogueur qui est un programme d’aide à l’élimination des Bogues (qui en
programmation, est un défaut de conception ou de réalisation se manifestant par des
anomalies de fonctionnement) ou simplement des erreurs.
Dans le cadre de ce cours, nous allons utiliser Eclipse (www.eclipse.org) et

NetBeans (www.oracle.com). Ce deux EDI nous permettront d’avoir la coloration des
textes, l’auto-complétion et une grande variété d’outils et des fonctionnalités.
Et nous aurons aussi besoin d’une Machine Virtuelle (Java Vitual Machine, JVM) qui
devra nous permettre d’interpréter les Byte Code. En lieu et place d’installer
simplement la JVM qui va nous permettre d’exécuter nos programmes Java, nous
allons Installer le JDK (Java Development Kit) qui contient en plus de JVM,
l’ensemble des librairies standards de java (java.lang, java.util, java.awt, ...), le
compilateur (javac), un interpréteur d’applets (appletviewer), un interpréteur (java), un
générateur de documentation (javadoc), JRE (Java RunTime Environnement) qui est
un environnement d’exécution d’applications Java. Le JDK est téléchargeable à ce jour
gratuitement sur le site d’Oracle (www.oracle.com).
Installation des outils
a) JDK
Nous procédons à l’installation premièrement du JDK8 en double-cliquant

sur le fichier exécutable « jdk-8u92-windows-x64.exe » pour l’environnement
Windows que nous avions téléchargé :
Dans cette boîte de dialogue, je clique sur Next :

Yambi Kumuré |6
Je clique également sur Next :
A la fin d’installation, le programme me demande de proposer le dossier (chemin

d’accès) dans lequel sera installé le jre. En cliquant sur « suivant » dans la fenêtre
suivante, je laisse le dossier tel que proposé par le setup, mais si vous remarquez qu’en
laissant le chemin d’accès tel quel l’installation n’aboutit pas, reprenez l’installation et
à ce niveau, chemin d’accès au JRE en cliquant sur « Modifier ».
Et à la fin d’installation de Java, je clique sur « Close » et java est installé dans ma
machine.

Yambi Kumuré |8
Après installation de JDK, nous allons installer maintenant notre IDE Eclipse.
b) Eclipse
L’installation de Eclipse ne se fait pas de la même façon que le jdk, étant

donné que c’est un fichier archive qui est téléchargé. Ainsi, je commence par extraire
le fichier archive.
Je fais un clic-droit sur le fichier Eclipse téléchargé :
L’extraction du fichier commence

Après extraction du fichier, je copie tout le dossier eclipse (dans lequel est contenu
l’exécutable) dans le dossier Programmes ou Programmes Files se trouvant dans le
disque principal. Je le copie dans le même dossier où se trouve le dossier de java :
Après la copie, j’ouvre le dossier eclipse et je copie le raccourci du fichier exécutable

au bureau :

Yambi K u m u r é | 10
Pour le premier lancement d’Eclipse, il m’est demandé d’indiquer l’espace

du travail (le dossier dans lequel Eclipse enregistrera tous les projets que nous créons
et utiliserons). Ainsi, je crée un dossier au bureau et dans la fenêtre de lancement
d’Eclipse j’indique le chemin de ce dossier.
Premier programme Java
Pour commencer nous allons utiliser notre premier programme nommé
HelloWord. Sur ce, je lance Eclipse et je ferme la page Welcome.
Ensuite je clic sur File, New et Java Project pour ouvrir un nouveau projet Java :
11 | J a v a p o u r D é b u t a n t
Dans la boite de dialogue je saisis le nom du Projet : (PremierProgramme)

et je clic sur Finish :
Dans l’explorateur des projets à gauche de l’écran, je fais un clic droit sur
mon projet, dans le menu contextuel, je pointe New puis class :
Dans la boite de dialogue qui apparait, je saisis la nom de la classe
HelloWord puis je coche la case public static void main(String[] args) et je clic sur
Finish :
Je vois apparaitre un éditeur de texte au milieu de ma fenêtre avec un code

pré-écrit. Je saisis simplement le code :
System.out.println("Bonjour le Monde");
Résumé :
Dans ce programme, nous avons cinq éléments importants :
 public class HelloWord : c’est la déclaration de la classe. Java étant un

langage orienté objet, la programmation se fait par la déclaration des classes et
des objets.
 public static void main(String[] args) : c’est la méthode
principale qui exécute tout programme Java. On y insert toutes instructions
exécutables à l’intérieur de ses accolades.
 System.out.println("Bonjour le Monde"); : c’est l’instruction
qui sera exécutée et qui affiche le message "Bonjour le Monde" à l’écran.
Il faut noter que chaque instruction java se termine toujours par un point-virgule
( ;)
 // et /** . . .* . . .**// : c’est sont des commentaires en une
ligne (//) et en plusieurs lignes (/*…*/) qui expliquent les instruction du
programme.
 {. . . {. . .} } : les accolades ouvrent et ferment une bloque
d’instructions.
Affichage du texte à l’écran
 Le texte à afficher à l’écran est toujours entre les guillemets ("") autrement
appelé double-cote
Exemple 1 :
("Bonjour le Monde")
A la sortie nous aurons :
Bonjour le mode
 Lorsque le texte à afficher contient également les guillemets qui doivent être
affiché à la sortie, ceux – ci sont précédés par l’antislash (\) qui est un caractère
d’échappement.
Exemple 2 :
("Bonjour les amis de \"Kumuré\"") ;
Bonjour les amis de "Kumuré"
 Lorsque le texte à afficher contient plusieurs lignes, on utilise \n qui permet de
renvoyer à la ligne suivante tout texte qui vient après :
Exemple 3 :
("Bienvenu au cours de Java \nPrésenté par \nKumuré") ;

Bienvenu au cours de Java

Présenté par
Kumuré
 il existe une différence entre println et print :

 println permet de renvoyer le curseur à la ligne après affichage du texte
 print ne renvoie pas le curseur à la ligne
Exemple 4 :
System.out.print("Bienvenu au cours de Java") ;

System.out.println("Présenté par) ;
System.out.println("Kumuré") ;
Nous aurons à la sortie :
Bienvenu au cours de JavaPrésenté par

Kumuré
Les Variables
Une variable est une entité symbolique ou une zone mémoire dont la valeur
est susceptible d’être modifiée en cours d’exécution du programme.
Types de variables
Il existe plusieurs types de variables en java. A ce niveau, nous allons nous

attarder plus sur les types primitifs, les chaînes de caractères.
1) Types primitifs
Types primitifs sont représentés dans le tableau suivant :
Type Classe Valeurs Portée Défaut

boolean Boolean true ou false N/A false
byte Byte entier signé {-128..128} 0
char Character caractère {/u0000../uFFFF} /u0000
short Short entier signé {-32768..32767} 0
int Integer entier signé {-2147483648..2147483647} 0
long Long entier signé {-231..231 − 1} 0
float Float réel signé {-3, 402823438..3, 402823438} 0.0
{-1,40239846−45..1,40239846−45}
double Double réel signé {-1,797693134308..1,797693134308} 0.0
{-4,94065645−324..4,94065645−324}
2) Les chaînes de caractères
Les chaînes de caractères ne sont pas considérées en Java comme un type

primitif ou comme un tableau. On utilise une classe particulière, nommée String,
fournie dans le package java.lang.
Déclaration d’une variable
Pour déclarer une on suit la syntaxe suivante :
Type_variable nom_variable = initialisation ;
Exemple 5 :
int age = 19 ;
double poids = 56.8 ;
String nom = "Kumuré" ;
Dans cet exemple, nous avons 3 variables que nous avons créé dont la
première porte le nom age qui est du type Integer et dont la valeur est 19, la
deuxième porte le nom de poids, est du type Double et dont la valeur affectée est
56.8 et la troisième porte le nom de nom, est du type String et a comme valeur
affectée Kumuré.
Il faut noter que :
 La valeur à affecter dans une variable de type String doit être toujours entre
guillemet ("")
 Java étant un langage de programmation fortement typé, aucune variable ne
peut être utilisée sans être déclaré.
 Une variable peut bien être déclarée sans être initialisée. Dans ce cas, avant
d’être utilisé, une valeur doit lui être affectée. C’est pourquoi il est impérieux de
donner toujours une valeur initiale de la variable à chaque initialisation.
 Le nom d’une variable peut commencer par les signes (_) ou ($) ou les deux.
Exemple 6 :
String $nom ;
int _age ;
String $_prenom ;
double _$poids ;
 Le nom d’une variable peut contenir un chiffre mais ne peut commencer par un
chiffre
Exemple 7 :
String nom1 ;
String nom23prenom ;
Les constantes
Une constante est une zone mémoire ou une variable dont la valeur ne
change pas au cours de l’exécution du programme.
Pour déclarer une constante on utilise le mot final comme suit :
final type NOM_CONSTANTE = Valeur ;
Généralement, le nom de la constate est toujours en majuscule pour faire la

différence avec les variables.
Exemple 8 :
final double PI = 3.14 ;
Affichage de variable
Pour afficher le contenu d’une variable, on écrit seulement le nom de la

variable à l’intérieur de l’instruction d’affichage.
Exemple 9 :
System.out.println(age) ;
System.out.println(poids) ;
System.out.print(PI) ;
A l’exécution nous aurons :
19
56.8
3.14
On peut également afficher un texte et le contenu d’une variable. Sur ce,

bien que nous n’avons pas encore parlé des opérateurs, nous allons utiliser l’opérateur
de concaténation (+).
Exemple 10 :
System.out.println("votre âge est " + age) ;

System.out.println("votre poids est " + poids) ;
Les opérations sur les variables
a) opérateur d’affectation
Pour affecter une valeur à une variable, on utilise le signe égale (=). On
parle aussi d’assignation. On peut aussi affecter un signe (positif ou négatif) à une
variable.
Exemple 11 :
int a=5;
Nous dirons que nous avons affecté ou assigné la valeur 5 dans la variable
a. Nous pouvons aussi assigner une expression dans une variable comme dans
l’exemple 14.
Exemple 12 :
int a=5;
System.out.println( -a );
Le résultat donnera -5
b) opérations arithmétiques
Les opérateurs arithmétiques utilisés en Java sont
Plus (+) pour l’addition

Moins (-) pour la soustraction
Star (*) pour la multiplication
Slash (/) pour la division
Pourcentage (%) pour le modulo ou reste de la division entière
Exemple 13 :
Après exécution, nous aurons comme résultat 15
Exemple 14 :
Dans cet exemple, après exécution, nous aurons comme résultat 0 au lieu de
0.5. Il y a 2 explications valables à cette situation :
La variable c est du type Integer et ne peut contenir que les valeurs du

type entier. Rassurez – vous-même si nous essayons de changer le type de
c en double, le résultat à l’exécution sera cette fois 0.0 au lieu de 0.5.
Les variables a et b sont des entiers et lorsqu’on divise un entier par un
entier, on obtient toujours un entier. Raison pour laquelle quand nous
divisons 5 par 10 nous avons 0 au lieu de 0.5.
L’idée peut vous arriver de changer simplement a et b aussi en double
Exemple 15 :
Le résultat sera correct mais chemin parcouru sera très long et parfois
même difficile surtout si les variables proviennent d’une autre classe. La solution
serait simplement d’utiliser le transtypage.
c) opérations de transtypage
Le transtypage est une opération qui consiste à convertir une variable de

type donné à un autre type.
Exemple 16 :
Dans ce cas, le résultat se après exécution sera 0.5
Exemple 17 :
Ici, nous le résultat 2 après exécution

d) opérations de concaténation
La concaténation est une opération qui consiste à additionner une variable

du type String avec une ou plusieurs variables de n’importe quel type. La
concaténation est représentée par la signe plus (+). On peut aussi utiliser la virgule
(,) pour concaténer 2 ou plusieurs variables de même type lors de la déclaration.
Exemple 18 :
Dans cet exemple, le résultat après exécution sera : KumuréEddy
Exemple 19 :
Nous aurons après exécution :
Exemple 20 :
Nous aurons après exécution :
Exemple 21 :
Dans ce cas ici, nous n’aurons plus 10 mais plutôt 55. Ici, en utilisant (+)
comme opérateur de concaténation, le programme comprend que vous lui demandez
de faire rien que la concaténation de a et a. ce qui fait qu’il prend la valeur de premier
il met à côté de la valeur de deuxième a. Ainsi la solution serait de mettre l’opération
a+a dans la parenthèse (a+a) :
Exemple 22 :
Et le résultat sera
Exemple 23 :
Dans cet exemple, le résultat sera :
e) Opérations d’incrémentation et de décrémentation
Avant de parler de l’incrémentation, voyons quelques raccourcis sur les

calculs.
Soit la variable int a = 5;, lorsque nous voulons ajouter une valeur
dans la variable a qui contient déjà une valeur, nous pourrons normalement faire a =
a + 10; et nous aurons comme résultat 15. Nous pouvons aussi faire a = a *
5; et nous aurons 25 à la sortie.
La meilleure façon de faire c’est comme cet exemple :
Exemple 24 :
Dans ce cas nous aurons à la sortie :
En ce qui concerne l’incrémentation, c’est une opération qui consiste à

ajouter une valeur constante à une variable. Et la décrémentation est une opération qui
consiste à soustraire une valeur constante à une variable
Exemple 25 :
Ici la valeur de a à la sortie sera 6. C’est l’incrémentation
Exemple 26 :
Dans cet exemple, nous aurons la valeur de a à la sortie qui sera 4 et c’est la
décrémentation
Exemple 27 :
Après exécution dans cet exemple, nous aurons sur les deux lignes 6 car
sur la première ligne on demande de commencer par incrémenter la variable a ensuite
l’afficher. C’est la près-incrémentation. Sur la deuxième ligne, on demande d’afficher
d’abord la variable ensuite l’incrémenter. C’est la post-incrémentation.
Exemple 28 :
Dans cet exemple après exécution, nous aurons sur la première ligne le
résultat 5 car, on demande d’afficher d’abord la valeur de la variable a ensuite
l’incrémenter. Et sur la deuxième ligne le résultat sera 7 car, on demande de
commencer par incrémenter la variable a ensuite l’afficher or, après la première ligne,
a =6 et lorsqu’on incrémente, nous avons a=7.
Exercice I
1) Ecrire un programme Java qui déclare 2 variables a et b de type entier et affiche

leur somme, leur différence, leur produit, leur quotient et leur modulo sachant
que la valeur assignée dans a doit être inférieure à celle de b
2) Soit les variables suivantes :
Affecter la valeur de la variable a dans la variable b et la valeur de la

variable b dans la variable a. Afficher ensuite les 2 variables de telle sorte que
l’on ait a=8, b=5
3) Soit l’exercice 1),

a) Trouver la différence de a et b dans la variable c et afficher la valeur de c de
sorte qu’elle soit positive.
b) Trouver le quotient de a et b dans la variable c de type réel et afficher la
valeur de c de sorte qu’elle soit réelle aussi.
4) Qu’est sera le résultat à l’exécution de ce programme :

a)
b)
La lecture de données
La gestion des exceptions
Il existe de fois l’exécution d’une instruction ou d’un bloc d’instruction ne

se passe pas comme prévue parce que les conditions d’exécution ne sont pas remplies.
Dans ce cas, Java arrête brusquement l’exécution du programme et affiche sur une
invite de commande, un message d’erreurs.
Ainsi, le programmeur doit savoir anticiper ces erreurs en les gérants

d’avance. C’est-à-dire montrer au programme quoi faire en cas d’erreurs.
La gestion de ces exceptions se fait avec la classe Try avec ses méthodes
catch et finaly. Cette dernière méthode n’est pas obligatoire. La syntaxe est la
suivante :
try {
instructions succeptibles de générer l’exception
} catch (type_execption variable) {
instructions qui doivent gérer des possibles exceptions
}finally{
instructions s’exécutant toujours avec ou sans exceptions
}
Les exemples de gestion d’exception sont donnés dans le point suivant qui
parle de la lecture de données.
Lecture de données à partir du clavier
Jusqu’ici nos programme sont statiques c’est-à-dire nous écrivons des

lignes d’instructions qui s’exécutent tout seul sans l’intervention de l’utilisateur. Il
s’agit de rentre nos programmes dynamiques c’est-à-dire demander des valeurs à
l’utilisateur qui vont être utilisés dans le programme. Pour ce faire, il existe plusieurs
méthodes en Java, mais ici, nous allons en apprendre trois classes à savoir la classe
Scanner, la classe BufferedReader et la classe JOptionPane.
Bien que nous ne parlons pas de la programmation objet dans cette partie
mais nous voulons expliquons en quelques mots ce que c’est une classe. Dans le terme
très simple, une classe est une sorte de moule à partir duquel on crée plusieurs objets.
En d’autres termes, une classe est une usine de création d’objets de même nature.
Ceci étant, en java la programmation se fait en créant des classes à partir

desquelles on va créer les objets. A part les classes que allons créer, Java possède dans
sa librairie des milliers des classes possédant des milliers d’objets que le programmeur
emprunte dans ces programmes en guise de raccourci.
1) La classe Scanner
Comme nous l’avons évoqué ci-haut, la classe Scanner est une classe
réservée de Java se trouvant dans le répertoire java util. Ainsi pour utiliser Scanner, il
faut d’abord importer cette méta – classe avant de l’utiliser. Cette importation se fait
au début du programme par l’instruction :
import java.util.Scanner;
Pour créer un objet de la classe Scanner on utilise l’instruction suivante :
Scanner nom_objet =new Scanner(System.in);
L’objet ainsi créé va utiliser plusieurs méthodes telles que :
nom_objet.nextInt() : pour recueillir les entiers

nom_objet.nextLine() : pour recueillir du texte
nom_objet.nextDouble() : pour recueillir des réels
nom_objet.nextLong() : pour recueillir des entiers longs
nom_objet.hasNextLine() : pour tester si la valeur saisie est un texte
nom_objet.hasNextInt() : pour tester si la valeur saisie est un entier.
Exemple 29 :
Ce programme donne le résultat suivant :
Remarque 1 : lorsqu’on utilise la méthode nextLine précédée de nextInt ou de

nextDouble, nextLine a l’habitude de lire la fin de la valeur recueillie
dans nextInt ou nextDouble après validation avec la touche entrée
comme dans cet exemple.
Exemple 30 :
Nous remarquons que nextLine affecte automatique dans la variable nom le

vide qui vient après 25 qui est lu par nextInt. La solution serait alors d’anticiper cette
lecture par un nextLine supplémentaire.
Exemple 31 :
Remarque 2 : il peut se faire que l’utilisateur introduit une valeur différente

d’un entier dans la variable age. Comment réagira le programme ?
Le programme interrompt et affiche un message d’erreur générée

d’exception à cause de type de données. Nous devons alors prévoir d’avance les
exceptions de lecture de données et de conversion de données. Nous allons appeler la
classe try que nous avons vu précédemment :
Exemple 32 :
2) La classe BufferedReader
La classe Bufferedeader ouvre un flux d’entrée System.in de la classe

InputStream qui permet de lire à partir du clavier les donnée de type texte. Puisque
cette classe ne li que du texte, une conversion de données s’impose pour lire les autres
données du type primitif comme les entiers ou les réels. La classe BufferedReader
appartient au répertoire java io d’où son importation s’impose à travers l’instruction
suivante :
Import java.io.BufferedReader
Comme vu précédemment, après importation, il faut créer l’objet de qui

implémente la classe BufferedReader :
BufferedReader nom_objet =new BufferedReader(new

InputStreamReader(System.in));
L’objet créé utilise readLine() comme méthode de lecture et close() comme

méthode de fermeture d’objet :
Nom_objet.readLine();
Nom_objet.close();
Exemple 33 :
En regardant ce programme, nous voyons le mot InputStreamReader

souligné en rouge. Ce qui signifie que notre programme n’est pas correct. La première
solution serait d’importer également la classe InputStreamReader qui est du même
répertoire que BufferedReader. Cette importation se fait par l’instruction :
Import java.io.BufferedReader
Exemple 34 :
Après cette importation, nous crayons encore d’autres erreurs. Nous voyons
notre objet flux et ses deux méthodes sont à leurs tours soulignés. La solution ici est
celle de la gestion d’erreurs. Etant donné que le programme doit lire les éléments qui
doivent provenir de l’extérieur, cette lecture peut ou ne pas réussir. C’est pourquoi
nous allons faire appel à la classe try :
Exemple 35
Vous allez remarquer que dans le même répertoire io, nous avons importé
trois classes avec trois lignes d’instructions différentes, or nous pouvions bien le faire
en une seule ligne en utilisant l’Astérix (*) qui signifie tout (all en anglais) :
import java.io.*;
3) La classe JOptionPane
Il est question ici de lire les données saisies au clavier à travers une boîte de
dialogue autrement appelé fenêtre. Pour lire les données la classe JOptionPane utilise
la méthode showInputDialog et elle doit être importée dans le répertoire javax swing
avec l’instruction suivante :
import javax.swing.JOptionPane ;
Tout comme bufferedReader, la classe JOptionPane aussi ne li que du

texte c’est-à-dire des chaînes de caractères, d’où une conversion doit être faite pour les
autres types primitifs et nous allons voir comment faire cette conversion au point
suivant.
Exemple 36 :
import javax.swing.JOptionPane;
public class BoiteDialog {
public static void main(String[] args) {
String nom = "";
nom = JOptionPane.showInputDialog("entrer votre nom :");
}
La conversion de données
La conversion de données est une opération qui consiste à passer d’un type
de données à un autre. Cette conversion se fait d’une chaîne de caractère (String) à un
type primitif et d’un type primitif à une String.
a) De String à un type primitif
Pour passer d’un string à un type primitif, on utilise la syntaxe suivante :
Classe_type.parseType(String) ;
Ainsi selon les classes types, cette syntaxe se matérialise de la manière

élucidée dans ce tableau :
Classes Méthodes de conversion

Byte Byte.parseByte(variable)
Boolean Boolean.parseBoolean(variable)
Float Float.parseFloat(variable)
Short Short.parseShort(variable)
Long Long.parseLong(variable)
Integer Integer.parseInt(variable)
Double Double.parseDouble(variable)
Exemple 37 :
Ce programme donne le résultat :
b) De type primitif à String
Pour passer d’un type primitif à une String, on utilise la syntaxe suivante :
String.valueOf(variable à convertir);
Exemple 38 :
Il faut noter que toute conversion de données est susceptible de générer une
exception. C’est pourquoi il est conseillé de mettre les instructions de conversion dans
la classe try et catch afin de gérer les exceptions dû à l’échec de la conversion de
données.
Exemple 39
L’exemple 40 suivant, résume la lecture de données avec la

BufferedReader, la gestion d’exceptions et la conversion de données. Nous
remarquons, Java étant un langage déclaratif, nous pouvons, sur la même ligne
d’instructions, effectuer la déclaration d’une variable, la lecture de données, la

conversion de données et l’affectation de ces données dans les variables.
Exemple 40 :
Et le résultat de ce programme est :

Structures de contrôle
Une structure de contrôle d’exécuter un bloc d’instructions lorsque une

condition est remplie. Jusqu’ici nos programmes s’exécutaient instructions après sans
passer par une vérification quelconque. Dans cette partie, nous allons soumettre
certaines nos instructions à des vérifications conditionnelles.
Sur ce, il existe deux sortes de structures de contrôle dont les structures
conditionnelles et les structures itératives
Chacune de ces conditions utilise des opérateurs logiques ou les opérateurs

de comparaison. Ainsi, avant de parler de ces structures, parlons d’abord des
opérateurs logiques.
Dans ce tableau, nous présentons les opérateurs chacun son signe et sa

signification.
Soit les variable a, b et c :
Opérateurs Signes Exemples Significations

Inférieur < a<b a est inférieur à b
Supérieur > a>b a supérieur à b
Egal == a == b a est égal à b
Inférieur ou égal <= a <= b a est inférieur ou égal à b
Supérieur ou égal >= a >= b a est supérieur ou égal à b
Différent != a != b a est différent de b
ET && a < b && b <c a est inférieur à b ET b est inférieur
àc
OU || a == b || b == c a est égal à b OU b est égal à c
NON ! !(a<b) Non a ne doit pas être inférieur à b
NB : Pour comparer deux variables String, on peut utiliser la méthode equals()

ayant comme argument l’élément en comparaison (voir l’exemple 40b). cette
méthode equals() est sensible à la casse. Mais lorsqu’on désire effectuer une
comparaison en ignorant la casse, on utilise equalsIgnoreCase().
Structure conditionnelles
La structure if
La syntaxe de la structure if est :
if(condition){
instructions ;
}
Lorsqu’il n’y a qu’une seule instruction, on peut enlever les accolades et la

syntaxe devient :
if(condition)instructions ;
La condition est une expression ou une opération qui renvoi une valeur du
type booléenne c’est-à-dire vrai ou faux (true ou false en anglais). Les
instructions à l’intérieur de la condition if ou à droite de la condition ne sont exécutées
que si la valeur de l’expression (condition) est true.
Exemple 41 :
Le résultat de ce programme est :
Dans cet exemple, lorsque la variable age prend une valeur supérieure ou
égale à 18, le programme ne fait absolument rien. C’est-à-dire nous n’avons pas dit au
programme ce qu’il va faire si la condition est évaluée à faux (false).
La structure if . . . else
Cette structure permet d’exécuter un premier bloc d’instructions si la

condition est vraie. Dans le cas contraire, le programme affiche un deuxième bloc
d’instructions. Sa syntaxe est la suivante :
if(condition){
instructions1
}else{
instructions2
}
Ceci se traduit en français par : si la condition est vraie, exécute

instructions1 sinon exécute instructions2.
Exemple 42 :
Ce programme le résultat :
Exemple 43 :
import java.util.Scanner;
public class Condition_If_Else_b {
Scanner entre = new Scanner(System.in);
final String NOM = "Kumuré" ;

String nomSaisie ;
System.out.println("Entrer votre nom svp !");

nomSaisie = entre.nextLine();
if(nomSaisie.equals(NOM)){
System.out.println("Bienvenue" + nomSaisie);
}else{
System.out.println("Desolé, pas autorisé");
}
}
}
Structure if . . . else if . . . else
Cette structure permet de tester une condition1 si elle est vraie, on exécute
le bloc d’instructions1. Si elle est fausse, on teste encore une autre condition2 qui si
elle est vraie, on exécute le bloc d’instructions2 et si elle est fausse, on exécute le bloc
d’instructions3. Sa syntaxe est la suivante :
If(condition1){
Instructions1
}else if(condition2){
Instructions2
}else{
Instructions3
}
Exemple 44 :
Dans un programme, on peut avoir plusieurs blocs else if mais s’en abuser
peut nuire à votre programme.
Structure imbriquée
C’est-à-dire une condition dans une condition. Cette structure permet de

tester une condition1 si elle est vraie, on pose encore une autre condition2 avant
d’exécuter le bloc d’instructions1. Sa syntaxe est :
If(condition1){
If(condition2){
Instructions1
}else{
Instructions2
}
}
Exemple 45 :
Le résultat produit par ce programme sera :

Exemple 46 : en utilisant les opérateurs ET et OU, nous pouvons obtenir ceci pour cet
exemple 45 :
Et le résultat donnera :
La structure switch
Avant de voir cette structure, voyons d’abord cet exemple qui revient sur la
structure if et else if.
Exemple 47 : un programme qui lit une valeur entière compris entre 1 et 7 saisie par
l’utilisateur, et le programme affiche le jour de la semaine correspondant à
ce entier.
La structure switch permet de vérifier une variable entière afin d’exécuter

un bloc d’instructions correspondant à la valeur de la variable vérifiée.
Syntaxe :
switch(expression entière){
case valeur1 :
instructions ;
break ;
case valeur2 :
instructions2 ;
break
...
default :
instructions
}
Chaque instruction est précédée par un case qui donne la valeur à
comparer avec l’expression entière afin d’en exécuter les instructions correspondantes.
Le break permet de sortir du bloc switch lorsque la valeur entière saisie correspond à
celle de la valeur case. Lorsqu’aucune valeur de l’expression entière ne correspond à
la valeur exprimée en case, c’est le bloc d’instructions sous default qui s’exécute.
Exemple 48 : nous allons reprendre le même problème qu’à l’exemple 47 :
Structure Répétitive
Une structure répétitive est une structure qui permet d’exécuter un bloc
d’instructions autant de fois tant qu’une condition donnée demeure vraie. Cette
structure est appelée une boucle.
La boucle for
La boucle for (pour en français) permet d’exécuter un bloc d’instructions à

un nombre de fois bien connu d’avance. C’est-à-dire le nombre de fois qu’une
instruction est exécutée est connu avant l’exécution du programme.
Syntaxe :
for(initialisation ; condition ; incrémentation){

instructions
}
Exemple 49 : dans cet exemple, nous allons afficher une table de multiplication par 2
allant de 1 à 10. Dans nos connaissances actuelles, nous ferons ceci :
Exemple 50 : comme le nombre de fois que nous devons afficher cette instruction est
connu, nous pouvons afficher toutes ces 10 lignes d’instructions en 2
lignes avec la boucle for comme suit :
Les 2 exemples 49 et 50 donnent le même résultat que voici :
Remarque :
 La portée de la variable i est limitée qu’à la boucle for. Lorsque nous désirons
utiliser i à l’extérieur de for, nous aurons une erreur car i est une variable privée
de for.
 Lorsque je fais : for(int i = 0 ; i >=0 ; i++) : cette boucle est
dite infinie car l’exécution de cette boucle ne finit pas technique.
La boucle do while
La boucle do while (faire tant que) permet d’exécuter un bloc

d’instruction tant que la condition donnée est vraie. Le nombre de fois que le bloc
d’instructions s’exécute n’est pas connu d’avance. Avec cette boucle, l’instruction
s’exécute une fois avant de passer à la condition. C’est-à-dire, que la condition soit
fausse ou vraie, l’instruction s’exécute d’abord au moins une fois.
Syntaxe :
do{
instructions ;
}while(condition) ;
Exemple 51 : écrire un programme qui demande à l’utilisateur son âge tant que celui –
ci est inférieur ou égal à zéro et affiche cet âge dans le cas contraire.
La boucle while
La boucle while (tant que) joue le même rôle que la précédente mais la
différence intervient du faite qu’ici la condition est posée avant d’exécuter
l’instruction. Dans cette boucle, l’instruction est exécutée que lorsque la condition est
vérifiée.
Syntaxe :
while(condition){
instructions
}
Exemple 52 : On fait la même chose qu’à l’exemple 51 :
Et on a à l’exécution la réaction suivante :
Conditions dans une boucle
Lorsque nous avons utilisé la boucle do while ou while simplement et

quand les instructions se répètent, l’utilisateur ne comprend pas pourquoi cette
répétition. Ainsi nous devons savoir lui dire ce qui fait que les instructions se répètent.
Exemple 53 : en se basant à l’exemple 52 précédent, nous pouvons dire à l’utilisateur

d’entrer l’âge qui soit supérieur ou égal à 18.
A l’exécution nous aurons :

Exercice II
1) Ecrire un programme qui calcule la somme des entiers pairs inférieur à 100
additionnée avec la somme des entiers impairs inférieur 100 et affiche le
résultat à l'écran.
2) Ecrire un programme java qui permet à l’utilisateur de trouver un nombre

compris entre 1 et 10 généré de manière aléatoire par l’ordinateur. L’utilisateur
saisi autant de fois un nombre compris entre 1 et 100 jusqu’à trouver le nombre
généré par la machine.
Les Tableaux
Un tableau est une variable pouvant contenir plusieurs données de même

type. En d’autres termes, un tableau est une zone mémoire dans laquelle il est possible
d’enregistrer un nombre infini de données ayant le même type.
Tableau à une dimension
Un tableau à une dimension est un tableau ayant une seule ligne et plusieurs
colonnes.
Déclaration d’un tableau
La première possibilité pour déclarer un tableau c’est donner le type du

tableau, suivi du nom du tableau qui se termine par les crochets.
La deuxième possibilité c’est donner le type du tableau suivi des crochets et

du nom du tableau.
Syntaxe :
type nom_tab [] ;
Ou
type [] nom_tab ;
Cette déclaration est faite généralement lorsqu’on connait d’avance les

éléments qui seront stockés dans le tableau. Ainsi nous aurons une initialisation
suivante :
type nom_tab [] = {a, b, c} ;
D’où a, b, c sont des valeurs du tableau. Ce tableau est représenté

graphiquement comme :
a b c
Exemple 54 : Ecrire un programme qui déclare un tableau contenant les 7 jours de la
semaine
String jour [] = {"Lundi", "Mardi", "Mercredi", "Jeudi",

"Vendredi", "Samedi", "Dimanche"};
Mais lorsqu’on ne connait pas les éléments que doit contenir le tableau, ce
dernier est déclaré par la syntaxe suivante :
type nom_tab [] = new type[n];

ou
type [] nom_tab = new type[n];
D’où n est le nombre d’éléments que doit contenir le tableau.
Chaque élément du tableau a un indice qui indique sa position dans le

tableau. Prenons l’exemple du tableau tab_1 suivant :
a b c
Dans ce tableau, la valeur de n est 3. L’élément tab_1[i] représente

l’élément se situant à la position i du tableau tab_1. Et i est entier allant de 0 à n-1.
Ainsi dans ce tableau :
 a se situe à la position 0 c’est-à-dire tab_1[0]

 b se situe à la position 1 c’est-à-dire tab_1[1]
 c se situe à la position 2 c’est-à-dire tab_1[2]
Exemple 55 : Ecrire un programme qui déclare un tableau contenant 7 éléments dont

les valeurs correspondent aux jours de la semaine.
Ainsi pour afficher un élément du tableau, il faut préciser sa position.

Comme par exemple pour afficher Mercredi, nous allons faire :
System.out.println(jour[2]);
Pour afficher tous les éléments du tableau, je ne peux pas mettre seulement
jour, car jour ne contient aucune valeur sinon une simple référence. Un tableau
n’étant pas une variable de type primitif, il fait un stockage par référence. Tandis que
les variables primitifs font un stockage par valeur.
Ce qui fait que lorsque je déclare un tableau, une zone mémoire est déclaré
avec une référence qui point vers un tableau avec les index indiquant la position de
chacun de ses éléments.
Pour afficher tous les éléments de notre tableau jour, nous pouvons
utiliser l’itération avec la boucle for comme à l’exemple suivant :
Exemple 56 :
for(int i = 0; i < 7 ; i++){

System.out.println(jour[i]);
}
Dans cet exemple, 7 est la taille de notre tableau. Mais si nous ne

connaissons pas la taille du tableau, on utilise la propriété length qui retourne la
taille d’un tableau et nous aurons le même résultat comme à l’exemple suivant :
Exemple 57 :
for(int i = 0; i < jour.length ; i++){
System.out.println(jour[i]);
Toujours en utilisant la boucle for, nous pouvons faire l’itération sur

l’ensemble de valeurs du tableau en déclarant une variable de for qui contiendra
toutes les valeurs du tableau comme l’exemple suivant :
Exemple 58 :
for(String valeur : jour){

System.out.println(valeur);
}
Affecter un tableau dans un autre
L’affectation d’un tableau dans un autre se fait de la même manière que

pour les types primitifs sauf qu’avec le tableau, étant donné qu’il effectue un stockage
par référence, ce ne sont pas les valeurs qui sont copiées mais plutôt la référence du
tableau. Ce qui fera que les deux tableaux auront les mêmes références qui pointent sur
le même tableau.
Exemple 59 :
A l’exécution, day va afficher tous les contenus de jour.
Copier les valeurs d’un tableau à un autre
Il s’agit ici de copier les éléments d’un tableau indice après indice.
L’avantage de cette copie est que, même si une ou plusieurs valeurs du premier tableau
sont modifiées après la copie, celles qui sont déjà copiées dans le deuxième tableau ne
seront pas modifiées. Tandis que lorsqu’on affecte un tableau dans un autre, la
modification des éléments du premier tableau implique automatiquement le deuxième.
Exemple 60 :
N.B. : Que ça soit pour l’affectation ou pour la copie des valeurs d’un tableau dans un
autre, il faut que le deuxième tableau qui reçoit les valeurs aie une taille
supérieure ou égale au premier tableau.
Il est de fois où nous pouvons déclarer un tableau qui n’a pas de référence
c’est-à-dire qui ne pointe sur rien. Cela se fait grâce à la propriété null utilisée
comme suit :
int nombre [] = null ;
Comparaison de tableaux
Il est question ici de vérifier si un tableau a les mêmes valeurs que l’autre.
Cette vérification se fait sur tous les éléments notamment la référence, la taille des
tableaux et les valeurs que porte chaque indice des tableaux. Ainsi, si nous avons deux
tableaux suivants :
int tab1 [] = { 32, 25, 54, 41 };
int tab2 [] = { 32, 25, 54, 41 };
Lorsque nous tentons de comparer les deux tableaux par : if(tab1 ==

tab2) nous remarquerons que le résultat sera faux, pour la simple raison que la
comparaison qui est faite ici concerne les références de ce deux tableaux et celles – ci
sont belle est bien différente. Mais par contre si nous faisons une affectation de tab1
dans tab2 avant la comparaison par : tab1 = tab2 nous aurons le résultat vrai
parce que les références sont désormais les mêmes. Voyons cela dans l’exemple 60
suivant :
Exemple 61 :
Pour comparer les deux tableaux élément par élément, nous pourrons le
faire comme dans l’exemple 62 suivant :
Exemple 62 :
Dans cet exemple, nous commençons par vérifier avec la propriété null, si
les deux tableaux ont – ils des références. Ensuite avec la propriété length, nous
comparons les tailles de nos deux tableaux. Ainsi, si l’une de ces expressions est vraie
alors les tableaux sont différents. Sinon, nous créons une variable (i) d’itération qui
nous permettra d’accéder dans chaque élément de ces tableaux.
L’itération se fait en comparant chaque valeur de chaque indice de tableau

correspondant tant que la valeur de la variable (i) est inférieur à la taille de l’un des
tableaux et que l’élément à l’indice [i] du premier tableau tab1[i] est égal à
l’élément à l’indice correspondant dans le deuxième tableau tab2[i].
Dès que l’itération fini, nous vérifions si la variable (i) est supérieure ou égale à la
taille de l’un des tableaux. Dans ce cas, les tableaux sont égaux. Sinon les tableaux
sont différents.
Le tableau bidimensionnel
Un tableau bidimensionnel ou tableau à deux dimensions est un tableau

ayant plusieurs lignes et plusieurs colonnes. Ce tableau est déclaré de la même manière
que le premier sauf qu’on ajoute deux crochets qui marquent les deux dimensions du
tableau et dans les crochets on précise le nombre de lignes et des colonnes.
Syntaxe :
type [][] nom_tab = new type [n][m] ;

ou
type nom_tab [][] = {{a,b,c},{x,y,z}} ;
D’où n est l’entier représentant le nombre de lignes du tableau et m le

nombre de colonnes. Dans le deuxième cas, c’est un tableau initialisé dont a, b, c
sont les éléments de la première ligne du tableau et x, y, z les éléments de la
deuxième ligne. Graphiquement, nous aurons un tableau tab2Dim tel que :
a b c
x y z
Dans cette représentation, nous n=2 et m=3. Et l’élément a se situe sur

la première ligne et première colonne, son indice est donc tab2Dim[0][0] et b
se situe sur la première ligne et deuxième colonne, son indice est
tab2Dim[0][1]. L’élément c se situe sur la première ligne et troisième
colonne, son indice est tab2Dim[0][2].
L’élément x se situe sur la deuxième ligne et première colonne, son indice

est tab2Dim[1][0]. L’élément z se situe sur la deuxième ligne et troisième
colonne, son indice est tab2Dim[1][2].
Exemple 63 : Un programme qui déclare un tableau qui contient 5 cotes

d’interrogations présentées par 2 étudiants dans le même cours
Pour afficher un élément du tableau, on fait comme dans l’affectation c’est-
à-dire en précisant son indice. Par exemple pour afficher 18, nous faisons :
System.out.println(cotes[0][4]);
Pour afficher tous les éléments du tableau, nous allons utiliser la boucle
for comme précédemment. Mais cette fois nous allons faire deux itérations dont la
première concerne toutes les lignes du tableau et la seconde concerne toutes les
colonnes.
Exemple 64 :
Le tableau dynamique
Un tableau dynamique est un tableau dont la taille varie au cours de

l’exécution du programme. Il s’agit d’une liste d’élément homogène dans une zone
mémoire dont la taille n’est pas définie au préalable par le programmeur. Ce tableau
est matérialisé par la classe ArrayList du répertoire java util. Il est accessible
par des opérations spécialisées appelées communément fonction et en java on parle
des méthodes (Rassurons que nous allons parler des méthodes dans le chapitre
suivant).
Syntaxe :
ArrayListe<ClasseTypeObjet> nomTableau = new ArrayListe<ClasseTypeObjet>();
La classe type d’objet dont il est question dans cette syntaxe est une classe
qui instancie l’objet de type primitif. En d’autres termes, c’est un type de données
évolué ou un enveloppeur de type primitif comme nous l’avons vu dans le chapitre sur
les variables.
Avant chaque utilisation de ArrayList, il faut toujours l’importer dans le

répertoire java util par la syntaxe java.util.ArrayList.
Dans le tableau suivant, nous présentons les classes enveloppeurs et leur

types primitifs :
Enveloppeurs Types primitifs

Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boulean
Exemple 65 : Un tableau dynamique de type String :
import java.util.ArrayList;
public class TableauDynamique {
ArrayList<String> noms = new ArrayList<String>();
}
}
Exemple 66 : Un tableau dynamique de type Integer :
ArrayList<Integer> age = new ArrayList<Integer>();
}
}
Affectation et accession dans un tableau dynamique
Comme nous l’avons dit tant tôt, on affecte ou on accède à un tableau

dynamique par une méthode spécifique. Dans le tableau suivant nous présentons la
liste non exhaustive de méthodes utilisées dans un tableau dynamique.
Méthodes Signification Syntaxe

Size() Retourne la taille actuelle du tableau nomTab.size()
add() Ajoute un élément au premier indice disponible nomTab.add()
set() Remplace l’élément à l’indice n par m nomTab.set(n, m)
get() Retourne l’élément à l’indice n nomTab.get(n)
clear() Supprime tous les éléments du tableau nomTab.clear()
isEmpty() Vérifie si le tableau est vide nomTab.isEmpty()
remove() Supprime l’élément à l’indice n nomTab.remove()
contains() Vérifie si l’élément k existe dans le tableau nomTab.contains(k)
indexOf() Retourne l’indice du premier élément k trouvé nomTab.indexOf(k)
Les méthodes isEmpty() et contains() retourne un booléen (true ou

false) tandis que la méthode indexOf(), retourne un entier si l’élément est trouvé.
Au cas contraire, elle retourne -1.
Exemple 67 : Un programme qui affecte 5 noms dans un tableau dynamique. Le

programme remplace l’élément à l’indice 3 par « meta », supprime
l’élément à l’indice 1 et affiche l’élément à l’indice 2.
ArrayList<String> noms = new ArrayList<String>();
noms.add("Tshika");
noms.add("Mvula");
noms.add("Kibo");
noms.add("Poba");
noms.add("Mpila");
noms.add("Nzita");
noms.set(3, "meta");
System.out.println(noms.get(2));
}
}
Exemple 68 : un programme qui affiche tous les éléments du tableau noms
for(int i = 0; i < noms.size(); i++){

System.out.println(noms.get(i));
}
Ou
for(String nom: noms){

System.out.println(nom);
}
Exercices III
1) Ecrire programme qui génère une valeur aléatoire et affiche un message selon la
valeur générée. La valeur générée doit être un booléen et avant d’afficher le
message, le programme doit faire une pause.
2) Ecrire un programme de Jeux Quiz Pays-Capital. Dans ce jeu, le système

demande à l’utilisateur la capitale d’un pays qu’il choisit de manière aléatoire
dans un tableau à deux dimensions dans lequel on a enregistré les pays et les
capitales. Le programme affiche à la fin le score de l’utilisateur par apport aux
nombre de question.
Les Méthodes
Notions
Une méthode est un ensemble d’opérations regroupé en un sous-programme

exécuté dans le but de retourner ou non un résultat précis.
Dans la programmation orientée objet, une méthode est une fonction ou une
procédure qui regroupe un ensemble d’instructions spécifiant le comportement d’un
objet ou d’une classe. Certaines notions de cette deuxième définition nous sont encore
inconnues, nous nous limitions à la première définition.
Ainsi il existe des méthodes prédéfinies et des méthodes définies par le

programmeur. Nous allons plus attarder sur les méthodes créées par nous-même.
Pour créer une méthode on parle de définir une méthode et cette définition
comprend le nom de la méthode, le paramètre (facultatif selon le cas) et le corps de la
méthode. Et pour utiliser la méthode définie, il faut l’appeler par son nom. Un
programme peut avoir plusieurs méthodes et une méthode peut appeler une autre
méthode.
Dans un programme java, les seules instructions exécutables sont celles

comprises à l’intérieur de la méthode principale main. Cette méthode est la seule
méthode exécutable qui est appelé automatiquement lors du lancement du programme
(application). Et c’est la méthode main qui se charge d’appeler toute autre méthode
afin d’en exécuter ses instructions.
Définition d’une méthode
Une méthode peut être défini n’importe où dans une classe ou sur un autre
fichier du package. Elle possède un type de données selon qu’elle retourne ou non une
valeur. Lorsqu’elle retourne une valeur, elle porte un type de données primitif mais
lorsqu’elle ne retourne pas de valeur, elle prend le type void.
Syntaxe de définition :
a) Méthode qui ne retourne pas une valeur
static void nomMethode(Parametres){

instructions;
}
b) Méthode qui retourne une valeur
static TypeDonneRetour nomMethode(Parametres){

instructions;
return valeur ;
}
Syntaxe d’appellation :
Qu’elle retourne ou pas une valeur, toutes les méthodes sont appelées de la
même manière. On y ajoute des arguments dans la parenthèse si elle comporte de
paramètre :
a) Une méthode ayant de paramètres
nomMethode(arguments);
b) Une méthode n’ayant pas de paramètres
nomMethode();
Exemple 69 : un programme qui définit une méthode nommée AfficherMessage, qui

affiche le message « Bonjour les amis » et qui est appelé par la méthode
main.
public class Methode1 {

AfficherMessage();
}
static void AfficherMessage(){
System.out.println("Bonjour les amis");
}
}
Exemple 70 : un programme qui définit une méthode nommée CalculAge qui a deux
variables (anais et anac) en paramètre. Cette méthode retourne l’âge en le
calculant par anac – anais.
public class Methode1 {

System.out.println(CalculAge(2018,1925));
}
static int CalculAge(int anac, int anais){

int age;
age = anac-anais;
return age;
}
}
NB :
 Lorsqu’une méthode doit retourner une valeur, la dernière instruction doit être
return. Après cette instruction, aucune autre instruction n’est exécutable.
 Lorsqu’une variable est créée à l’intérieur d’une méthode, elle n’est accessible
qu’à cette méthode-là. On dit alors que la portée de cette variable est locale.
C’est-à-dire qu’elle ne peut pas être utilisée en dehors de la méthode dans
laquelle elle est déclarée.
La récursivité de méthode
On parle de la récursivité lorsqu’une méthode s’appelle elle-même. Comme

nous avons vu qu’une méthode peut appeler une autre méthode, il possible qu’une
méthode fait appel elle-même. Voyons avec les exemples 71 et 72 suivants.
Exemple 71 : Un programme qui calcule dans une méthode et retourne le factoriel

d’un nombre nbr.
public class MethodeFacto {

System.out.print(factoriel(5));
}
static int factoriel(int nbr){
if(nbr < 0){
System.out.print("le nombre doit un entier positif");
return -1;
}else{
int res = 1;
for(int i = 1; i <= nbr; i++){
res = res*i;
}
return res;
}
}
}
Exemple 72 : En utilisant la récursivité, le programme à l’exemple 71 précédant se

présentera comme suit :
public class MethodeFacto2 {

System.out.print(factoriel(5));
}
static int factoriel(int nbr){
if(nbr == 0 || nbr == 1){
return 1;
}else{
return nbr * factoriel(nbr-1);
}
}
}
CorreCtion d’exerCiCes
Exercice I
1) Le programme est le suivant :
2) Le programme :
Le résultat sera
3)
a) Le programme :
Le résultat est
b) Le programme :
Ce programme donne comme résultat :
4)
a) Le résultat sera :
b) Le résultat sera :
Exercices II
1)
package exercice;
public class SommePair {
int sommePair = 0, sommeImpair = 0 ;
for(int i = 1; i<=100;i++){
if(i%2==0){
sommePair = sommePair+i;
}else{
sommeImpair = sommeImpair+i;
}
}
int somme = sommePair + sommeImpair;
System.out.println("la somme des entiers pairs
inférieur à 100 est : "+sommePair);
System.out.println("la somme des entiers impairs
inférieur à 100 est : "+sommeImpair);
System.out.println("la somme des pairs et impairs
inférieur à 100 est : "+somme);
}
}
2)
Exercices III
1)
import java.util.Random;
public class JeuxAllea {
System.out.println("Connaissez-vous Kumuré ?");

Random aleat = new Random();
boolean valeur = aleat.nextBoolean();
System.out.print("Hum . . . ");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(valeur){
System.out.println("Oui je connais Kumuré !");
}else{
System.out.println("Non, je ne connais pas
Kumuré ");
}
}
}
2)
import java.util.*;
public class JeuxCapital {
final int NB_QST = 10 ;

int score = 0, index;
String pays, capital, reponse;
ArrayList<Integer> PaysDejaPris = new ArrayList<Integer>();
String donne [][] = {
{"Congo RD" , "Kinshasa" },
{"Angola" , "Luanda" },
{"Algérie" , "Alger" },
{"Maroc" , "Casablanca" },
{"Egypte" , "Caire" },
{"Sénégal" , "Dakar" },
{"Belgique" , "Bruxelles" },
{"France" , "Paris" },
{"Italie" , "Rome" },
{"Chine" , "Pékin" },
{"Japon" , "Tokyo" },
{"Allemagne" , "Berlin" },
{"Gabon" , "Libreville" },
{"Suisse" , "Zurich" },
{"Espagne" , "Madrid" },
};
Scanner clavier = new Scanner(System.in);
for( int i = 0; i < NB_QST ; i++){

//on choisi le pays de manière aléatoire avec Random
do {
Random element = new Random();
index = element.nextInt(donne.length);
}while(PaysDejaPris.contains(index));
//ajouter pays choisi dans le tableau pays déjà choisis
PaysDejaPris.add(index);
//affecte pays choisie et sa capitale dans les variable
pays = donne[index][0];
capital = donne[index][1];
//pose la question et recevoir la réponse d’utilisateur
System.out.println("Quelle est la capitale de "

+ pays +"?");
reponse=clavier.nextLine();
/*vérifier si la capitale saisie corrrespond à celui du

pays choisie*/
if(reponse.equalsIgnoreCase(capital)){
System.out.println("Bonne réponse");
score++;
}else{
System.out.println("Faux, la capital
de"+ pays +"est :" +capital);
}
}
//on affiche le score et on ferme l'objet clavier.
System.out.println("Votre score est de

"+score+"/"+NB_QST);
clavier.close();
}
}
Cet exercice, nous pouvons le faire autrement en utilisant une méthode qui
va contenir les données, notamment le tableau qui contient les pays et leurs capitales.
Ainsi, nous pouvons procéder de la manière suivante :
import java.util.*;
public class JeuxCapital {
final int NB_QST = 10 ;

int score = 0, index;
String pays, capital, reponse;
ArrayList<Integer> PaysDejaPris = new ArrayList<Integer>();
String [][] donne = BaseDonnees();
Scanner clavier = new Scanner(System.in);
for( int i = 0; i < NB_QST ; i++){

do {
Random element = new Random();
index = element.nextInt(donne.length);
}while(PaysDejaPris.contains(index));
PaysDejaPris.add(index);
pays = donne[index][0];
capital = donne[index][1];
System.out.println(i+1+") Quelle est la

capitale de " + pays
+"?");
reponse=clavier.nextLine();
if(reponse.equalsIgnoreCase(capital)){
System.out.println("Bonne réponse");
score++;
}else{
System.out.println("Faux, la capital
de"+pays+"est:" +capital);
}
}
System.out.println("Teminer, votre score est
de " + score + "/"+NB_QST);
clavier.close();
}
static String [][] BaseDonnees(){
String PaysCapitales [][] = {
{"Congo RD" , "Kinshasa" },
{"Angola" , "Luanda" },
{"Algérie" , "Alger" },
{"Maroc" , "Casablanca" },
{"Egypte" , "Caire" },
{"Sénégal" , "Dakar" },
{"Belgique" , "Bruxelles" },
{"France" , "Paris" },
{"Italie" , "Rome" },
{"Chine" , "Pékin" },
{"Japon" , "Tokyo" },
{"Allemagne" , "Berlin" },
{"Gabon" , "Libreville" },
{"Suisse" , "Zurich" },
{"Espagne" , "Madrid" },
};
return PaysCapitales;
}
}
Table de matière
INTRODUCTION GÉNÉRALE ........................................................................... 1

Compilation ............................................................................................................ 3
Interprétation .......................................................................................................... 4
Environnement d’exécution ................................................................................... 4
Installation des outils.............................................................................................. 5
Premier programme Java...................................................................................... 11
Affichage du texte à l’écran ................................................................................. 15
Les Variables ........................................................................................................ 16
Types de variables ................................................................................................ 16
Déclaration d’une variable ................................................................................... 16
Les constantes ...................................................................................................... 17
Affichage de variable ........................................................................................... 18
Les opérations sur les variables............................................................................ 18
Exercice I.............................................................................................................. 25
La lecture de données ........................................................................................... 26
La gestion des exceptions..................................................................................... 26
Lecture de données à partir du clavier ................................................................. 26
1) Laclasse Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ….27
2) La classe BufferedReader ................................................................................ 30
3) La classe JOptionPane ..................................................................................... 32
La conversion de données .................................................................................... 33
a) De String à un type primitif ............................................................................. 33
b) De type primitif à String .................................................................................. 34
Structures de contrôle ........................................................................................... 37
Structure conditionnelles ...................................................................................... 38
La structure if ....................................................................................................... 38
La structure if . . . else .......................................................................................... 39
Structure if . . . else if . . . else .............................................................................. 40
Structure imbriquée .............................................................................................. 41
La structure switch ............................................................................................... 43
Structure Répétitive .............................................................................................. 45
La boucle for ........................................................................................................ 46
La boucle do while ............................................................................................... 47
La boucle while .................................................................................................... 48
Conditions dans une boucle ................................................................................. 49
Exercice II ............................................................................................................ 51
Les Tableaux ........................................................................................................ 52
Tableau à une dimension ...................................................................................... 52
Déclaration d’un tableau ...................................................................................... 52
Affecter un tableau dans un autre......................................................................... 55
Copier les valeurs d’un tableau à un autre ........................................................... 55
Comparaison de tableaux ..................................................................................... 56
Le tableau bidimensionnel ................................................................................... 58
Le tableau dynamique .......................................................................................... 59
Affectation et accession dans un tableau dynamique ........................................... 61
Exercices III ......................................................................................................... 63
Les Méthodes ....................................................................................................... 64
Notions ................................................................................................................. 64
Définition d’une méthode .................................................................................... 64
La récursivité de méthode .................................................................................... 66
Correction d’exercices ......................................................................................... 68
Exercice I.............................................................................................................. 68
Exercices II ........................................................................................................... 70
Exercices III ......................................................................................................... 72
Table de matière ................................................................................................... 76

Prepar Javadebutant - 113415 - 114146 - 114638

Transféré par

Droits d'auteur :

Formats disponibles

Prepar Javadebutant - 113415 - 114146 - 114638

Transféré par

Informations du document

Description originale:

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

Prepar Javadebutant - 113415 - 114146 - 114638

Transféré par

Droits d'auteur :

Formats disponibles

INDIGO

Computing Learning Center

Java est un langage objet permettant le développement d’applications

Un programme Java est portable au sens où il peut s’exécuter sur des

Cette portabilité est possible grâce à une normalisation indépendante de la

En d’autres termes, Java est un langage interprété, ce qui signifie qu’un

Prenons l’exemple d’un langage de programmation comme C, avec le

Mais avec Java, après la compilation du code source, au lieu d’obtenir le

La figure 1.1 illustre ce fonctionnement.

En d’autres termes, Un programmeur Java écrit son code source, sous la

La compilation s’effectue par la commande javac suivie d’un ou plusieurs

3|Java pour Débutant

paramètres pour s’effectuer correctement, notamment lorsque le code source fait

javac -classpath /prog/exos1:/cours MyProg.java compilera le

Le bytecode obtenu par compilation ne peut être exécuté qu’à l’aide de

Dans le cadre de ce cours, nous allons utiliser Eclipse (www.eclipse.org) et

Installation des outils

Nous procédons à l’installation premièrement du JDK8 en double-cliquant

Dans cette boîte de dialogue, je clique sur Next :

5|Java pour Débutant

Je clique également sur Next :

A la fin d’installation, le programme me demande de proposer le dossier (chemin

7|Java pour Débutant

L’installation de Eclipse ne se fait pas de la même façon que le jdk, étant

Je fais un clic-droit sur le fichier Eclipse téléchargé :

L’extraction du fichier commence

Après la copie, j’ouvre le dossier eclipse et je copie le raccourci du fichier exécutable

9|Java pour Débutant

Pour le premier lancement d’Eclipse, il m’est demandé d’indiquer l’espace

Dans la boite de dialogue je saisis le nom du Projet : (PremierProgramme)

Je vois apparaitre un éditeur de texte au milieu de ma fenêtre avec un code

Dans ce programme, nous avons cinq éléments importants :

 public class HelloWord : c’est la déclaration de la classe. Java étant un

("Bienvenu au cours de Java \nPrésenté par \nKumuré") ;

Bienvenu au cours de Java

 il existe une différence entre println et print :

System.out.print("Bienvenu au cours de Java") ;

Nous aurons à la sortie :

Bienvenu au cours de JavaPrésenté par

Il existe plusieurs types de variables en java. A ce niveau, nous allons nous

Types primitifs sont représentés dans le tableau suivant :

Type Classe Valeurs Portée Défaut

2) Les chaînes de caractères

Les chaînes de caractères ne sont pas considérées en Java comme un type

Déclaration d’une variable

Pour déclarer une on suit la syntaxe suivante :

Type_variable nom_variable = initialisation ;

Il faut noter que :

Pour déclarer une constante on utilise le mot final comme suit :

final type NOM_CONSTANTE = Valeur ;

Généralement, le nom de la constate est toujours en majuscule pour faire la

final double PI = 3.14 ;

Pour afficher le contenu d’une variable, on écrit seulement le nom de la

A l’exécution nous aurons :

On peut également afficher un texte et le contenu d’une variable. Sur ce,

System.out.println("votre âge est " + age) ;

Les opérations sur les variables

Les opérateurs arithmétiques utilisés en Java sont