Java 1

Chapitre 1 – Bases du langage

Table des matières

1 Objectifs pédagogiques...........................................................................................................................................................................2
2 Introduction et définitions.......................................................................................................................................................................2
2.1 Bref historique sur Java..................................................................................................................................................................2
2.2 Caractéristiques du langage............................................................................................................................................................2
2.3 Java SE et Java EE..........................................................................................................................................................................3
2.4 JRE et JDK.....................................................................................................................................................................................3
2.5 Exemple de programme Java..........................................................................................................................................................3
2.6 Compilation et exécution d'un programme Java.............................................................................................................................3
3 Variables, opérateurs et expressions........................................................................................................................................................4
3.1 Commentaires.................................................................................................................................................................................4
3.2 Ensemble des types primitifs..........................................................................................................................................................4
3.3 Le type String.................................................................................................................................................................................4
3.4 Déclaration et initialisation d'une variable.....................................................................................................................................4
3.5 Opérateurs.......................................................................................................................................................................................5
3.5.1 Opérateurs de calculs.............................................................................................................................................................5
3.5.2 Opérateurs d'assignation........................................................................................................................................................5
3.5.3 Opérateurs de comparaison....................................................................................................................................................6
3.5.4 Opérateurs logiques (booléens)..............................................................................................................................................6
3.5.5 Concaténation.........................................................................................................................................................................7
4 Entrée/sortie basiques..............................................................................................................................................................................7
4.1 Saisie au clavier..............................................................................................................................................................................7
4.2 Affichage à l'écran..........................................................................................................................................................................8
4.2.1 Affichage de variables avec un message................................................................................................................................8
4.2.2 Sortie formatée.......................................................................................................................................................................8
5 Structures de contrôles............................................................................................................................................................................9
5.1 Structure de contrôle conditionnelle : if ... else..............................................................................................................................9
5.2 Structure de contrôle conditionnelle : switch ... case...................................................................................................................10
5.3 Structure de contrôle itérative : while...........................................................................................................................................11
5.4 Structure de contrôle itérative : do... while...................................................................................................................................11
5.5 Structure de contrôle itérative : for...............................................................................................................................................11
6 Méthodes...............................................................................................................................................................................................12
7 Tableaux................................................................................................................................................................................................13
7.1 Rappel du concept de tableau en algorithmique...........................................................................................................................13
7.2 Déclaration d'un tableau en Java..................................................................................................................................................13
7.3 Initialisation d'un tableau..............................................................................................................................................................13
7.4 Accès à une valeur d'un tableau....................................................................................................................................................13
7.5 Taille d'un tableau.........................................................................................................................................................................14
7.6 Parcours d'un tableau....................................................................................................................................................................14

Page 1/14
 1 Objectifs pédagogiques
A la fin de ce cours, je dois être capable de :
• Connaître les principales caractéristiques du langage Java
• Connaître les définitions de JDK, JRE, JSE, J2E
• Savoir déclarer une classe et la méthode principale d'un programme Java
• Savoir déclarer et initialiser des variables en Java
• Savoir évaluer une expression en Java
• Savoir effectuer des entrées/sorties au clavier/écran en Java
• Savoir écrire des structures de contrôles conditionnelles (if...) et itératives (while...) en Java
• Savoir manipuler des tableaux et écrire des algorithmes simples sur les tableaux en Java
• Savoir écrire des méthodes en Java (équivalent des procédures/fonctions en algorithmes)

2 Introduction et définitions
2.1 Bref historique sur Java
Java a été créé par créé par James Gosling et Patrick Naughton (Sun)
• 1995 : Premier lancement commercial de Java dans sa première version
• 2000 : Lancement de la version 1.2, formant la séparation entre JSE et JEE (J2E)
• 2010 : Rachat de Sun par Oracle
Aujourd'hui (septembre 2015), la version actuelle de Java est la 1.8, souvent appelée Java 8.

2.2 Caractéristiques du langage

Java est compilé et interprété Le code source est compilé bytecode puis exécuté par un interpréteur Java : la Java Virtual Machine
(JVM). Ce concept est à la base du slogan de Sun pour Java : WORA (Write Once, Run Anywhere :
écrire une fois, exécuter partout). En effet, le bytecode peut être exécuté et obtenir les mêmes
résultats sur toutes les machines disposant d'une JVM.
Java est portable : il est Il n'y a pas de compilation spécifique pour chaque plate forme. Le code reste indépendant de la
indépendant de toute plate- machine sur laquelle il s'exécute. Il est possible d'exécuter des programmes Java sur tous les
forme environnements qui possèdent une Java Virtual Machine.
Java est orienté objet. Chaque fichier source contient la définition d'une ou plusieurs classes qui sont utilisées les unes
avec les autres pour former une application.
Java est simple Le choix de ses auteurs a été d'abandonner des éléments mal compris ou mal exploités des autres
langages tels que la notion de pointeurs (pour éviter les incidents en manipulant directement la
mémoire), l'héritage multiple et la surcharge des opérateurs.
Java est fortement typé Toutes les variables sont typées et il n'existe pas de conversion automatique qui risquerait une perte
de données.
Java assure la gestion de la L'allocation de la mémoire pour un objet est automatique à sa création et Java récupère
mémoire automatiquement la mémoire inutilisée grâce au garbage collector qui restitue les zones de
mémoire laissées libres suite à la destruction des objets.
Java est multitâche Il permet l'utilisation de threads qui sont des unités d'exécutions isolées. La JVM, elle même, utilise
plusieurs threads.
Java est sûr La sécurité fait partie intégrante du système d'exécution et du compilateur. Un programme Java
planté ne menace pas le système d'exploitation. Il ne peut pas y avoir d'accès direct à la mémoire.
L'accès au disque dur est réglementé dans une applet (programme Java s'exécutant dans un
navigateur web).

Page 2/14
 2.3 Java SE et Java EE
Java SE (anciennement J2SE) : framework destiné aux applications pour poste de travail.
Java EE (anciennement J2EE) : framework spécialisé dans les applications serveurs. Il contient pour ce faire un grand nombre d’API
et d’extensions.

2.4 JRE et JDK

JRE: Java Runtime Environement, c'est le kit destiné au client pour pouvoir exécuter un programme Java. Il se compose
essentiellement d'une machine virtuelle Java (JVM) capable d'exécuter le byte-code et les bibliothèques standard de Java.
SDK: Standard Development Kit, c'est le kit destiné au programmeur. Ce kit est composé d'un JRE, d'un compilateur et de nombreux
programmes utiles, des exemples de programmes Java, les sources de toutes les classes de l'api.
JDK: Java Development Kit, c'est le nouveau nom du SDK. Le SDK a été renommé JDK depuis la version 1.2.2.

2.5 Exemple de programme Java

public class PremierProgramme {
public static void main(String[] args) {
System.out.println("Bonjour KINSHASA !");
}
}

• Tout programme Java s'écrit dans une classe (nous reviendront sur cette notion au prochian chapitre). Le nom de la classe
est également le nom du fichier, ici PremierProgramme.java. Appeler la classe avec un nom différent de celui du fichier
produira une erreur à la compilation.
• La méthode principale d'un programme est la méthode main : c'est là que le programme commence. Cette méthode a
toujours la même signature. Le paramètre "args" permet de récupérer les paramètres saisis au programme en ligne de
commande (il s'agit d'un tableau de chaîne de caractères).
• Pour afficher un message, on utilise "System.out.println". "System" est une classe Java, out représente la sortie du
programme, et est un attribut de "System". "println" est une méthode (semblable à une fonction) qui affiche une chaine de
caractères sur la sortie standard, c'est à dire l'écran.

2.6 Compilation et exécution d'un programme Java

Le langage Java est compilé puis interprété.
On dispose au départ de fichiers contenant le code source Java, les fichiers .java. On compile ces fichiers sources à l'aide du
compilateur java, qui est javac. Cela entraine la production d'un fichier .class, qui est le bytecode java. Enfin, il ne reste qu'à exécuter
le programme java, avec l'interpréteur en ligne de commande, appelé tout simplement java.
On peut résumer ce processus avec le diagramme suivant :

Voici ce que cela donne en ligne de commande, avec la classe PremierProgramme :

> javac PremierProgramme.java

> java PremierProgramme

Page 3/14
La première ligne sert à compiler le programme Java.
La seconde ligne sert à exécuter le programme. Remarquez que l'on n'écrit pas "java PremierProgramme.class". En effet,
l'interpréteur Java n'attend pas le nom d'un fichier compilé (.class), mais le nom d'une classe, telle qu'elle a été déclarée.

3 Variables, opérateurs et expressions

3.1 Commentaires
Partout dans le code Java, on peut écrire des commentaires. Les commentaires ne sont pas compilés, ni exécutés, ni quoi que ce soit :
ils sont tout simplement ignorés par Java. L'utilité des commentaires est de laisser des messages au développeur pour qu'il comprenne
bien le code source.
Il existe deux moyens pour écrire des commentaires en Java :

Commentaire sur une seule ligne // commentaire

Commentaire qui peut être sur /* commentaire */
plusieurs lignes

Voici un exemple de code Java avec des commentaires :

int a; // Je déclare une variable qui s'appelle a et qui est de type int
a = 5; // La variable a reçoit la valeur 5
/* Je voudrais maintenant faire un gros calcul :
a va recevoir le résultat du produit de 5 par 4, augmenté de 9 */
a = 5 * 4 + 9;

3.2 Types primitifs

Java possède plusieurs types dit "primitifs". C'est à dire que ce sont des types de base du langage, déjà définis et utilisables. Voici
l'ensemble de ces types :

Nom Equivalent algo Taille en octets Valeur par défaut Exemple de valeur
boolean Booléen 1 false true
byte Entier 1 0 12
short Entier 2 0 52000
int Entier 4 0 -4848
long Entier 8 0 30061960
char Caractère 2 '\0' 'A'
float Décimal 4 0.0 5.5
double Décimal 8 0.0 -6.5

On peut remarquer que chacun de ces types commence par une minuscule.

3.3 Le type String

Java possède également un type pour les chaines de caractères, le type String. Toutefois, String n'est pas un type primitif (nous
verrons dans un prochaine chapitre qu'il s'agit en réalité d'une classe).

3.4 Déclaration et initialisation d'une variable

Pour déclarer une variable, on précise d'abord son type, puis son nom :

typeVariable nomVariable;

La déclaration de variable est une instruction comme une autre. Elle se termine par un point virgule, comme toutes les instructions.
On peut déclarer plusieurs variables d'un même type à la fois :

Page 4/14
typeVariable nomVariable1, nomVariable2, nomVariable3, ...;

On peut initialiser les variables partout dans son code en Java, pas nécessairement au début d'un bloc. Cependant, une variable doit
toujours avoir été déclarée ET initialisée avant d'être utilisée dans une expression. Lors d'une assignation, le type de la variable, et le
type de l'expression que l'on va assigner doivent être compatibles (on ne peut pas mettre des int dans des String, ni des char dans des
int, mais on peut mettre des int dans des double...).
L'opérateur d'assignation est le signe égal, "=" (comme dans le langage C).

nomVariable = expression;

On peut initialiser une variable au moment de sa déclaration, comme ceci :

typeVariable nomVariable = expression;

Voici quelques exemples de déclaration et d'initialisation de variables.

int a, baba;
char c;
a = 85;
baba = -454;
c = 'O';
String texte = "KINSHASA";

3.5 Opérateurs

3.5.1 Opérateurs de calculs

Opérateur Description Exemple Résultat
+ Addition 5 + 2 10
- Soustraction 5 - 2 4
* Multiplication 5 * 2 21
Division entière : opérandes de type int 5 / 2 2
/
Division décimale : au moins une opérande de type float ou double 5.0 / 2 2.5
% Modulo (reste de la division) 5 % 2 1
- Négation (opposé d'une valeur) -5 -5

3.5.2 Opérateurs d'assignation

Nous avons déjà vu l'opérateur d'assignation simple, avec le symbole "=". Il existe d'autres opérateurs d'assignations, qui ne sont que
des raccourcis de syntaxe.
Ces opérateurs permettent de simplifier des opérations du type "faire un calcul sur une variable et stocker le résultat dans cette même
variable".
Dans le cas d'une addition, si on souhaite augmenter une variable entière de 2, on écrirait: x=x+2. Avec les opérateurs d'assignation il
est possible d'écrire cette opération sous la forme suivante :x+=2. Ainsi, si la valeur de x était 3 avant opération, elle sera de 5 ensuite.
Les autres opérateurs du même type sont les suivants :

Opérateur Description Exemple sans Exemple équivalent avec l'opérateur

l'opérateur simplifié simplifié
+= Additionne une variable et modifie celle-ci a = a + 2; a += 2;
-= Soustrait une variable et modifie celle-ci a = a – 2; a -= 2;
*= Multiplie une variable et modifie celle-ci a = a * 2; a *= 2;
/= Divise une variable et modifie celle-ci a = a / 2; a /= 2;
%= "Module" une variable et modifie celle-ci a = a % 2; a %= 2;

Page 5/14
Il existe deux opérateur d'incrémentation/décrémentation, que l'on utilise très souvent : ++ et --. Ce sont juste des raccourcis de
syntaxe.

Opérateur Description Exemple sans l'opérateur simplifié Exemple équivalent avec l'opérateur simplifié
++ Augmente de 1 a = a + 1; a++;
-- Diminue de 1 a = a – 1; a--;

Une assignation est faite à l'aide d'un opérateur. De ce fait, une assignation renvoie une valeur. La valeur renvoyée par une
assignation est la valeur que l'on vient de calculer.
De ce fait, on peut tout à fait écrire :

int a, b, c;
a = b = c = 2;
Cela va initialiser les trois variables à 2.

3.5.3 Opérateurs de comparaison

Opérateur Description Exemple Résultat
== Egalité 5 == 2 false
!= Différence 5 != 2 true
< Infériorité stricte 5 < 2 false
> Supériorité stricte 5 > 2 false
<= Infériorité ou égalité 5 <= 5 true
>= Supériorité ou égalité 4 >= 2 false

3.5.4 Opérateurs logiques (booléens)

Opérateur Description Exemple Résultat
|| OU Logique false || false false
false || true true
true || false true
true || true true
&& ET Logique false && false false
false && true false
true && false false
true && true true
! NON Logique !true false
!false true

Java utilise l'évaluation paresseuse. C'est à dire que :

• avec le OU logique, dès qu'une opérande vaut true, on cesse de calculer la suite, car le résultat sera nécessairement true
• avec le ET logique, dès qu'une opérande vaut false, on cesse de calculer la suite, car le résultat sera nécessairement false
Voici des exemples illustrant ce principe:

Exemple de code Java Valeur de b Commentaire

int a = 5; true On n'a pas évalué a < -5, ce n'était pas la peine.
boolean b = a > 2 || a < -5;
int a = 5; false On n'a pas évalué a > 3, ce n'était pas la peine.
boolean b = a < 4 && a > 3;
int a = 5; false On n'a pas évalué (a / 0 == 0), ce n'était pas la peine.

Page 6/14
boolean b = a < 4 && (a / 0 == 0); Donc pas d'erreur à l'exécution, car la division par 0 n'a
pas été exécutée !

3.5.5 Concaténation
La concaténation est l'opération permettant de "coller" deux chaines de caractères, c'est à dire de les mettre toutes deux bout à bout,
l'une à côté de l'autre, afin d'obtenir une nouvelle chaine. Par exemple, si on concatène "A" et "B", on obtient "AB".
En Java, la concaténation se fait avec l'opérateur +. C'est le même opérateur que l'addition. Toutefois, Java fera la différence avec
une addition si au moins une des deux opérandes est de type String. De plus, si l'une des deux opérandes n'est pas de type String, alors
Java essaiera de la convertir en String, automatiquement.
Voici un exemple de code :

String s1, s2, s3;

int a = 5;
s1 = "A";
s2 = "B";
s3 = s1 + s2; // "AB"
s3 = s1 + a; // "A5"
s3 = a + s1; // "5A"
s3 = "X" + a + 2 // "X52" !

4 Entrée/sortie basiques
4.1 Saisie au clavier
Pour faire une saisie au clavier, il faut tout d'abord déclarer un objet de type "Scanner". Nous ne nous attarderons pas pour l'instant
sur ce qu'est un objet, cela sera vu au chapitre suivant. Pour l'instant, nous appliquerons donc la syntaxe sans la comprendre
parfaitement. Le scanner est capable de lire les données tapées au clavier par l'utilisateur.
Afin de pouvoir utiliser un objet Scanner, il faudra également écrire une instruction au tout début du fichier Java : import
java.util.Scanner, afin d'indiquer à Java le nom complet de cet objet.
Voici un exemple de code Java complet qui fait la lecture d'une variable de type Entier :

import java.util.Scanner;

public class Prog {

public static void main(String[] args) {

Scanner clavier = new Scanner(System.in);

int a = clavier.nextInt();
clavier.nextLine();
}
}

L'objet Scanner a été nommé ici "clavier", mais on aurait pu lui donner n'importe quel nom de variable. On peut utiliser le même objet
Scanner pour faire plusieurs saisies successives.
La méthode "nextInt()", concrétement, fait la saisie d'un entier : c'est à ce moment que le curseur clignote et que l'utilisateur va taper
une valeur. L'appel à "nextLine()" sert à enlever le caractère de fin de ligne qui a été tapée au clavier. Si on n'appelle pas "nextLine"
après "nextInt", cela peut poser des problèmes (que nous ne détaillerons pas ici) si l'on souhaite faire certaines saisies successives.
Selon le type de variable que l'on souhaite lire, il faut utiliser une méthode du scanner différente.

Type de Méthode Exemple Equivalent Algo Commentaire

variable
int nextInt int a; Entier a Provoque une erreur
a = clavier.nextInt(); a ← LireEntier() d'exécution si l'utilisateur tape
clavier.nextLine(); une valeur qui n'est pas un
entier.
double nextDouble double a; Decimal a Provoque une erreur
a = clavier.nextDouble(); a ← LireDecimal() d'exécution si l'utilisateur tape

Page 7/14
 clavier.nextLine(); une valeur qui n'est pas un
nombre virgule.
float nextFloat float a; Decimal a Provoque une erreur
a = clavier.nextFloat(); a ← LireDecimal() d'exécution si l'utilisateur tape
clavier.nextLine(); une valeur qui n'est pas un
nombre virgule.
boolean nextBoolean boolean a; Booleen a Provoque une erreur
a = clavier.nextBoolean(); a ← LireBooleen() d'exécution si l'utilisateur tape
clavier.nextLine(); une valeur qui n'est ni "true",
ni "false". Cette méthode est à
éviter, car il est facile de mal
taper. On préfera la saisie d'un
caractère 'O' ou 'N', puis
transformer celui en booléen.
String nextLine String a; Chaine a
a = clavier.nextLine(); a ← LireChaine()
char nextLine char a; Caractere a Il n'y a pas de méthodes pour
a = a ← LireCaractere() lire un caractère seul. Un
clavier.nextLine().charAt(0); moyen de faire est donc de
lire une ligne complète, mais
de ne récupérer que le
premier caractère. C'est cela
que fait "charAt(0)"
Provoque une erreur
d'exécution si l'utilisateur ne
tape rien.

4.2 Affichage à l'écran

Pour afficher une valeur à l'écran, on pourra utiliser "System.out.println". Cette méthode affiche n'importe quel type de variable, suivi
d'un retour à la ligne. Si on ne veut pas faire de retour à la ligne, on pourra utiliser "System.out.print".

Méthode Equivalent Algo Exemple Java Affichage à l'écran

System.out.println EcrireLigne int a = 5; 5
int b = 6; 6
System.out.println(a)
System.out.println(b)
System.out.print Ecrire int a = 5; 56
int b = 6;
System.out.print(a)
System.out.print(b)

4.2.1 Affichage de variables avec un message

Pour afficher une variable avec un message explicatif, on utilisera souvent la concaténation, comme décrit plus haut. Voici un exemple
de code Java :

int a = 5;
int b = 12;
int r = a + b * a – b + b % 7;
System.out.println("a vaut " + a + " et b vaut " + b);
System.out.println("Le résultat du calcul compliqué est : " + r);

Cela va afficher :
a vaut 5 et b vaut 12
Le résultat du calcul compliqué est : 58

Page 8/14
 4.2.2 Sortie formatée
Il est parfois utile de formater le texte que l'on souhaite afficher, en particulier lorsqu'il s'agit d'un nombre. On pourra dans ce cas
utiliser System.out.printf (semblable à la fonction printf du langage C).
Voici des exemples qui montrent quelques possibilités :

Code Java Affichage à l'écran Commentaire

System.out.printf("%d", 5);
System.out.printf("%2d", 5);
System.out.printf("%2d", 10);
System.out.printf("%2d", 120);
System.out.printf("%3d", 5);
System.out.printf("%03d", 5);
System.out.printf("%f", 5.25);
System.out.printf("%.2f", 5.25);
System.out.printf("%.3f", 5.25);
System.out.printf("valeur = %.3f\n", valeur = 5,250
5.25);
System.out.printf("v1=%d, v2=%d", 8, v1=8, v2=9
9);
5 Affiche un entier sans format spécifique. "d" comme "digit"
qui signifie "chiffre" en anglais.
5 Affiche un entier sur 2 caractères si possible, aligné à droite.
Les caractères manquants sont remplacés par des espaces.
10
120
5 Idem mais sur 3 caractères si possibles.
005 Idem mais les caractères manquants remplacés par des 0.
5,250000 Affiche un décimal sans format spécifique. "f" comme
"float".
5,25 Affiche un décimal avec toujours 2 chiffres après la virgule.
5,250 Affiche un décimal avec toujours 3 chiffres après la virgule.
On peut intégrer du texte avant ou après le format. Le texte
est affiché tel qu'il est. "\n" est le caractère de fin de ligne.
On peut même afficher plusieurs valeurs en une seule fois.

5 Structures de contrôles
5.1 Structure de contrôle conditionnelle : if ... else...
Cette structure permet d'exécuter certaines instructions et pas d'autres, selon une certaine condition.
La syntaxe est la suivante :

1ère forme 2ème forme 3ème forme

if (condition c) { if (condition c) { if (condition c1) {
traitement si c est traitement si c est traitement si c1 est
évalué à true évalué à true évalué à true
} } }
else { else if (condition c2) {
traitement si c est traitement si c2 est
évalué à false évalué à true
} }
else if (condition c3) {
traitement si c3 est
évalué à true
}
...
else {
traitement si tout est
false
}

Exemples de code Java :

Scanner clavier = new Scanner(System.in);

int a = clavier.nextInt();
clavier.nextLine();

Page 9/14
if (a == 0) {
System.out.println("Vous avez tapé 0");
}
Scanner clavier = new Scanner(System.in);

int a = clavier.nextInt();
clavier.nextLine();

if (a % 2 == 0) {
System.out.println("Vous avez tapé un nombre pair");
}
else {
System.out.println("Vous avez tapé un nombre impair");
}
Scanner clavier = new Scanner(System.in);

int a = clavier.nextInt();
clavier.nextLine();

String s;

if (a == 0) {
s = "nul";
}
else if (a > 0) {
s = "positif";
}
else {
s = "negatif";
}

System.out.println("Vous avez tapé un nombre " + s);

5.2 Structure de contrôle conditionnelle : switch ... case...

Le switch est une syntaxe alternative à une imbrication de if... else if... Il permet de tester si une variable est égale à telle valeur ou
telle autre.

Syntaxe Exemple
switch (variable) { Scanner clavier = new
case valeur1: Scanner(System.in);
traitement si variable est égale à valeur1
break; int a = clavier.nextInt();
case valeur2:
traitement si variable est égale à valeur2 String s;
break; switch (a) {
... case 1:
case valeur3: s = "Un";
traitement si variable est égale à valeur3 break;
break; case 2:
default: s = "Deux";
traitement par défaut break;
} case 3:
s = "Trois";
break;
default:
s= "?";
}

System.out.println(s);

Page 10/14
 • Le default est facultatif.
• Si on enlève les break, alors on ne sort pas de la structure, mais on continue d'exécuter les traitements qui suivent, jusqu'à
rencontrer un break (ou jusqu'à arriver au dernier traitement). En général, c'est à éviter !

5.3 Structure de contrôle itérative : while...

Cette structure permet de répéter plusieurs fois un même groupe d'instructions. C'est la structure de contrôle de base pour effectuer des
boucles.

Syntaxe Exemple
while (condition) { Scanner clavier = new Scanner(System.in);
traitement répété si condition vraie
} System.out.print("Nombre d'étoiles : ");
int n = clavier.nextInt();
clavier.nextLine();

int i = 1;
while (i <= n) {
System.out.println("*");
i++;
}

5.4 Structure de contrôle itérative : do... while...

Comme le while, cette structure permet de répéter plusieurs fois un même groupe d'instructions. La différence avec le while est que la
condition est testée après le traitement à répéter. De ce fait, le traitement est toujours exécuté au moins une fois.

Syntaxe Exemple
do { Scanner clavier = new Scanner(System.in);
traitement répété si condition vraie
} System.out.println("Tapez un nombre positif : ");
while (condition)
int n;
do {
n = clavier.nextInt();
clavier.nextLine();
}
while (n < 0);

5.5 Structure de contrôle itérative : for...

C'est la boucle la plus fréquemment utilisée en Java. Son fonctionnement est similaire à un while, mais avec une syntaxe raccourcis :
La boucle for contient trois parties :
• initialisation : exécutée une seule fois au tout début
• condition : vérifiée avant tout nouveau traitement. Si elle est vraie, on exécute le traitement. Sinon, on sort de la boucle.
• evolution : exécutée après chaque traitement répétée (et avant la condition).

Syntaxe Exemple
for (initialisation; condition; evolution) { Scanner clavier = new Scanner(System.in);
traitement à répéter
} System.out.print("Nombre d'étoiles : ");
int n = clavier.nextInt();
clavier.nextLine();

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

System.out.println("*");
}

On se sert fréquemment de la boucle for pour faire varier un nombre entre deux valeurs.

Page 11/14
 6 Méthodes
En Java, lorsque l'on souhaite écrire un petit traitement réutilisable, on écrira une méthode. Une méthode est l'équivalent des
procédures et des fonctions en algorithmique.
Voici la syntaxe que nous utiliserons pour déclarer une méthode :

static typeRetour nomMethode(typeParam1 nomParam1, typeParam2 nomParam2, ...) {

Corps de la méthode
}

On déclarera les méthodes dans la classe, c'est à dire dans les accolades de la classe. On peut les déclarer avant ou après la méthode
main. Le mot-clé static sera toujours utilisé pour l'instant, car nous n'avons pas encore étudié la programmation orienté objet (chapitre
suivant).
Le type de retour peut être absolument n'importe quel type de variable. Lorsqu'une méthode ne renvoie aucune valeur, on utilisera le
mot-clé void. Pour renvoyer une valeur dans le corps de la méthode, on utilisera le mot-clé return.
Pour appeler une méthode, il suffit d'écrire son nom, et de donner les valeurs des paramètres.

nomMethode(valeurParam1, valeurParam2, ...)

Voici un exemple complet de programme Java dont le programme principal a été décomposé en trois méthodes.

import java.util.Scanner;

public class Prog {

// Méthode qui affiche un petit texte de présentation

static void afficherIntroduction() {
System.out.println(
"Ceci est un petit programme Java qui calcule le carré"
+ " de deux nombres tapés au clavier.");
}

// Méthode qui fait la lecture d'un entier au clavier

static int lireEntier() {
Scanner clavier = new Scanner(System.in);
System.out.println("Tapez un nombre : ");
int n = clavier.nextInt();
clavier.nextLine();
return n;
}

// Méthode qui affiche le carré d'un nombre à l'écran

static void afficherCarre(int x) {
int carre = x * x;
System.out.println("Le carre de " + x + " vaut " + carre);
}

// Programmme (méthode) principal

public static void main(String[] args) {
afficherIntroduction();
int n1 = lireEntier();
int n2 = lireEntier();
afficherCarre(n1);
afficherCarre(n2);
}
}

Page 12/14
 7 Tableaux
7.1 Rappel du concept de tableau en algorithmique
Un tableau, en programmation, est une suite ordonnée de valeurs. Chaque valeur est présente à un index, qui est un nombre entier,
compris entre 0 et (taille du tableau – 1). Un tableau est donc un type de variable qui contient un ensemble de plusieurs valeurs.
Voici une représentation d'un tableau de 5 entiers.

Valeur 12 3 2 21 42
Index 0 1 2 3 4

Dans cet exemple, à l'index 0, on a la valeur 12. A l'index 1, on a la valeur 3, et ainsi de suite.
Ici on a choisi d'avoir un tableau de nombres, mais on aurait très bien pu avoir un tableau de caractères, de booléens, d'objets...

7.2 Déclaration d'un tableau en Java

On déclare un tableau en java à l'aide des crochets, accolés au type de la variable.

typeTableau[] nomTableau;

Par exemple, pour obtenir un tableau d'entiers, cela donne:

int[] monTableau;

7.3 Initialisation d'un tableau

Un tableau peut être initialisé de deux manières, statique ou dynamique.
• De manière statique, à la déclaration, en précisant explicitement les valeurs entres accolades, séparées par des virgules.

typeTableau[] nomTableau = {valeur1, valeur2, ..., valeurN}

Par exemple, pour avoir un tableau avec 5 valeurs initiales, cela donne :

int[] monTableau = { 12, 3, 2, 21, 42 }

Remarquons que dans ce cas, la taille du tableau est automatiquement déduite du nombre d'éléments entre accolades.

• De manière dynamique, après la déclaration, en spécifiant uniquement la taille.

nomTableau = new typeTableau[tailleTableau]

Par exemple, pour avoir un tableau à 5 cases (chacune vaudra 0 par défaut), cela donne:

monTableau = new int[5]

Suite à cette initialisation, toutes les valeurs du tableau prennent la valeur par défaut du type de variable du tableau. Par exemple, 0
pour les entiers.
On peut aussi faire cette initialisation directement à la déclaration :

int[] monTableau = new int[5]

7.4 Accès à une valeur d'un tableau

On accède à une valeur du tableau, à partir de son index, de cette façon.

Page 13/14
nomTableau[index]
Par exemple, pour mettre 21 à l'index 3 on peut écrire :

monTableau[3] = 21

Pour stocker le contenu de la case d'index 3 d'un tableau, dans une autre variable, on peut écrire :

int a = monTableau[3];

Et que se passe-t-il si l'index est en dehors des limites du tableau, c'est à dire strictement inférieur à 0, ou supérieur ou égal à la taille
du tableau ? Java va lancer une erreur (ou plus précisément une exception). Quand on accède à un élément d'un tableau, il faut donc
être sûr de ne pas être en dehors des limites !

7.5 Taille d'un tableau

La taille d'un tableau peut s'obtenir très facilement, à tout moment, à l'aide de l'attribut "length" du tableau, quelle que soit la manière
avec laquelle il a été initialisée.

int[] monTableau = { 12, 3, 2, 21, 42 };

int tailleTableau = monTableau.length; // Renvoie 5
int[] monTableau2 = new int[8];
int tailleTableau2 = monTableau2.length; // Renvoie 8

7.6 Parcours d'un tableau

Parcourir un tableau signifie accéder à chacun des éléments du tableau, les uns après les autres.
Pour parcourir un tableau, on utilise fréquement la boucle for.

int[] monTableau = { 12, 3, 2, 21, 42 };

for (int i = 0; i < monTableau.length; i++) {
// Traitement quelconque de monTableau[i]
}

Dans cet exemple, on parcours l'intégralité du tableau. Mais on peut restreindre à une portion différentes en changeant l'initialisation
ou la condition, pour peu que ces valeurs définissent un intervalle valide, dans les limites du tableau.

Par exemple, pour afficher toutes les valeurs d'un tableau, on peut écrire le code suivant :

int[] monTableau = { 12, 3, 2, 21, 42 };

for (int i = 0; i < monTableau.length; i++) {
System.out.println(monTableau[i]);
}

Page 14/14