Ce document présente les bases de la programmation en Java, y compris les types primitifs, la déclaration et l'initialisation des variables, ainsi que les structures de contrôle comme les conditions et les boucles. Les bonnes pratiques de programmation sont également abordées pour améliorer la lisibilité du code. À la fin, les lecteurs doivent être en mesure de créer des applications Java en mode console et d'utiliser efficacement les principales structures de programmation.

1. LES BASES DE LA
PROGRAMMATION JAVA
>> Alan Jay Perlis
« Un langage qui n'affecte pas votre manière de penser
la programmation ne vaut pas la peine d'être connu. »

2. A.BENGUEDDACH Chapitre 1 Les bases de la programmation JAVA P a g e | 2
Les bases de la programmation
en JAVA
Concepts Clés
Les types primitives : int, double, boolean, l’opérateur new, les conditions : if, switch, les
boucles : for, while, do, les tableaux int[n], la classe Math, le système d’entrées/sorties
d’un programme system.out (println()), system.in (nextInt(), nextDouble()).
Les Objectifs
A la fin de ce chapitre, vous serez en mesure de :
 Créer un projet java sous Intellij IDEA
 Créer des applications Java en mode console en respectant les bonnes pratiques en
programmation
 Déclarer une variable en Java
 Comprendre le mécanisme d’initialisation des variables en Java
 Analyser et exécuter une instruction en Java
 Comprendre le mécanisme d’affectation en Java
 Apprendre l'affichage, la saisie des données et la lecture des différents types
 Utiliser les fonctions prédéfinis de la classe Math
 Distinguer entre l’usage des deux structures : if et switch
 Ecrire des programmes en java avec les structures de contrôle : condition et boucles
 Déclarer des variables de type tableau
1. Structure d’un code en java
1.1. Les bonnes pratiques en programmation

3. A.BENGUEDDACH Chapitre 1 Les bases de la programmation JAVA P a g e | 3
Adopté un bon style de programmation facilite la lecture de notre code. Il est important pour un
développeur de respecter un certain nombre de règles :
 Nom de variable significative : choisir des noms de variables significatives, par exemple il est
apprécié de déclarer une variable qui caractérise le nom d’un client dans une banque par : String
nomClient; au lieu de String a qui est dépourvu de sens et reste quelconque largeur d’un
rectangle ou un nombre entier ...etc.
 Inclure l’indentation dans le code : pour faciliter la lecture d’un code, il est important de
générer les bons espaces comme séparer les déclarations de variables des méthodes ou encore
dans une alternative de type if…else, il est important de décaler l’ensemble des instructions pour
montrer l’imbrication et faciliter l’interprétation du code pour le programmeur.
 Favoriser l’utilisation des espaces blancs dans le code : une autre manière d’améliorer la
lisibilité de son code est de générer des espaces blancs à l’intérieur des instructions, par exemple
il est préférable d’ajouter des espace avant et après des opérateurs =, +, *, …etc.
1.2. Les types primitifs
En Java, il existe 8 types primitifs dans l’API java.util.
 boolean : vrai ou faux
 char : un caractère Unicode de 16 bits
 byte : un nombre entier signé de 8 bits
 short : un nombre entier signé de 16 bits
 int : un nombre entier signé de 32 bits
 long : un nombre entier signé de 64 bits
 float : un nombre réel signé de 4 octets
 double : un nombre réel signé de 8 octets
Le transtypage
(type) nomVariable ;
type variable = (type) expression ;
Note : Les booléens ne peuvent jamais être transtypé.
1.3. Déclaration des variables
Les variables sont déclarées avec la syntaxe suivante :
type nomVar ; //une seule variable

4. A.BENGUEDDACH Chapitre 1 Les bases de la programmation JAVA P a g e | 4
type nomVarl, nomVar2, nomVar3 ; //le cas de plusieurs variables
L’initialisation
Les types primitifs sont initialisés à l'aide de l'opérateur d'affectation : l'opérateur d'affectation =
La syntaxe est :
variable = valeur ;
Exemples :
 nombre = 3 ;
 lettre = ‘D’ ; /* utilisez des guillemets simples pour indiquer un
caractère Unicode */
 boolean b = false ;
 double d = Math.sqt(2) ;
 int x = 0, y = 0, z = -2 ;
 char ch = ‘X’, int i = 5 ; // erreur syntaxique
1.4. Le type String
En Java, les chaînes de caractères sont un type de classe.
Exemples :
 String str = new String (‘Hello world !’) ;
 String str = ‘Hello World !’ ;
Les méthodes sur les chaines de caractères
Exemples :
 String str = "Hello" + " world !";
 String str = "Hello".concat(" world !") ;
 String s1 = "Hello" ;
 String s2 = world ! ;
 String str = s1+s2 ;
2. Les structures de contrôle
Il a été démontré que pour représenter n'importe quel algorithme, il faut disposer des trois possibilités
suivantes :
• la structure de séquence qui indique que les opérations doivent être exécutées les unes après les
autres
• la structure de choix qui indique quel ensemble d'instructions doit être exécutée suivant les
circonstances
• la structure de répétition qui indique qu'un ensemble d'instructions doit être exécuté plusieurs
fois.
2.1. Les conditions
Qu’est-ce qu’une condition ?
Une condition est une comparaison. Cette définition est essentielle ! Elle signifie qu’une condition est
composée de trois éléments :
• une valeur
• un opérateur de comparaison

5. A.BENGUEDDACH Chapitre 1 Les bases de la programmation JAVA P a g e | 5
• une autre valeur
Les valeurs peuvent être a priori de n’importe quel type (numériques, caractères…). Mais si l’on veut
que la comparaison ait un sens, il faut que les deux valeurs de la comparaison soient du même type !
Les opérateurs de comparaison sont :
 = égal à…
 != différent de…
 < strictement plus petit que…
 > strictement plus grand que…
 <= plus petit ou égal à…
 >= plus grand ou égal à…
L’ensemble des trois éléments constituant la condition constitue donc, si l’on veut, une affirmation,
qui a un moment donné est VRAIE ou FAUSSE.
2.2.1. L’alternative simple (if … alors) : (1 cas)
Formalisme :
if (condition) {
séquence
}
Principe :
Si la condition est vraie alors la séquence d’instructions s’exécute sinon ne rien faire.
Exemple :
Ecrire un programme qui calcule la somme, la soustraction et la division de deux nombres réels.
public void main (String args []){
double A,B,D,S,m ;
nextDouble(A) ;
nextDouble(B) ;
S = A+B ;
D= A-B ;
If (B != 0) m = A/B ;
println(S, D, m) ;}
2.2.2. L’alternative composée (if{…}else{…} ): (2 cas)
Formalisme :
If (condition) {
séquence1
} else {
séquence2 }
Principe : Si la condition est vérifiée alors séquence1 s’exécute et si elle n’est pas vérifiée, c’est la
séquence2 qui va s’exécuter.
Exemple :
public void main (String args []){
double A,B ;
nextDouble(A) ;
nextDouble(B) ;
if (A< B) println (A, ‘est inférieur à’, B) ;
else println (A, ‘est supérieur à’, B) ;

6. A.BENGUEDDACH Chapitre 1 Les bases de la programmation JAVA P a g e | 6
}
2.2.3. L’alternative imbriquée (if …else if…else…)
Formalisme : 3 cas
if (condition1) {
séquence1 ;
}else if (condition2){
séquence2 ;
} else {
séquence3 ;
}
Exemple :
- Ecrire un programme qui calcule S dans les cas suivants :
S =100 si a>b
S = 0 si a=b
S = -100 si a<b
Solution
public void main (String args []){
int a,b,S ;
nextIn(a,b)
if (a>b) {
S = 100 ;
} else if (a=b) {
S = 100 ;
}else {
S = 0 ;
}
println(S)
}
2.3. Les boucles
On dispose de trois structures pour contrôler un traitement répétitif :
 La boucle Pour…faire.
 La boucle Tant que…faire.
 La boucle Répéter…jusqu’à
2.3.1. La boucle pour
Formalisme :
for( int i=0 ; i<= N ; i++){
(Séquence d’instructions)}
Principe :
 i : représente le compteur de la boucle qui gère le nombre de répétition.
 1 : la valeur initiale du compteur
 N : la valeur finale du compteur, une fois la valeur N atteinte, la boucle doit s’arrêter.
Note : Après chaque exécution, il y a augmentation du compteur et un test qui vérifie si la valeur finale du compteur est
atteinte ou pas
Exemple :
- Calcul de la moyenne de chaque étudiant sachant que chacun possède 2 notes.

7. A.BENGUEDDACH Chapitre 1 Les bases de la programmation JAVA P a g e | 7
double N, N1, N2, m ;
nextInt(N) ;
for( int i=0 ; i< = N ; i++){
nextInt (N1 ,N2) ;
m = (N1+N2)/2 ;
println (m) ;}
2.3.2. La boucle tant que
Formalisme :
while (condition) {
(Séquence d’instructions)
}
Principe :
Tant que la condition est vérifiée, elle ne s’arrêtera que lorsque la condition est invérifiable.
Exemple :
double N, N1, N2, m ;
nextInt(N)
i=0 ;
while (i<= N) {
nextInt (N1 ,N2) ;
m = (N1+N2)/2 ;
println (m) ;
i= i+1 ;}
2.3.3. La boucle répéter
Formalisme :
do {
(Séquence d’instructions)
}while (condition) ;
Principe : La boucle exécutera la séquence d’instructions plusieurs fois, elle s’arrêtera lorsque la
« condition » deviendra vraie.
Exemple :
double N, N1, N2, m ;
nextInt(N)
i = 0 ;
do {
nextInt (N1 ,N2) ;
m = (N1+N2)/2 ;
println (m) ;
i= i+1 ;
}while (i> N);