Chapitre II : Introduction aux applications Java ;

Entrée/Sortie et Opérateurs

2.1 Présentation
Ce chapitre présente la programmation Java. Nous commençons par des exemples de
programmes qui affichent (sortent) des messages à l'écran. Nous présentons ensuite un
programme qui obtient (entre) deux nombres d'un utilisateur, calcule leur somme et
affiche le résultat. Vous apprendrez à demander à l'ordinateur d'effectuer des calculs
arithmétiques et d'enregistrer leurs résultats pour une utilisation ultérieure.
Le dernier exemple montre comment prendre des décisions. L'application compare
deux nombres, puis affiche des messages indiquant les résultats de la comparaison.
Vous utiliserez les outils de ligne de commande du JDK pour compiler et exécuter les
programmes de ce chapitre. Si vous préférez utiliser un environnement de
développement intégré (IDE), nous avons également publié des vidéos de démarrage
sur
[Link]
pour les trois IDE Java les plus populaires : Eclipse, NetBeans et IntelliJ IDEA.
2.2 Votre premier programme en Java : imprimer une ligne de texte
Une application Java est un programme informatique qui s'exécute lorsque vous utilisez
la commande java pour lancer la machine virtuelle Java (JVM). Les sections 2.2.1 à 2.2.2
expliquent comment compiler et exécuter une application Java. Considérons d'abord
une application simple qui affiche une ligne de texte. La figure 2.1 montre le programme
suivi d'une boîte qui affiche sa sortie.
1 // Fig. 2.1: [Link]
2 // Text-printing program.
3
4 public class Welcome1 {
5 // main method begins execution of Java application
6 public static void main(String[] args) {
7 [Link]("Welcome to Java Programming!");
8 } // end method main
9 } // end class Welcome1
Fig. 2.1 | Programme d’impression de texte. (Part 1 of 2.)

Welcome to Java Programming!

Fig. 2.1 | Programme d’impression de texte. (Part 2 of 2.)

1
Nous utilisons les numéros de ligne à des fins pédagogiques - ils ne font pas partie d'un
programme Java.
Cet exemple illustre plusieurs fonctionnalités Java importantes. Nous verrons que la
ligne 7 fait le travail en affichant la phrase "Bienvenue dans la programmation Java!"
sur l'écran.
Commenter vos programmes
Nous insérons des commentaires pour documenter les programmes et améliorer leur
lisibilité. Le compilateur Java ignore les commentaires, de sorte qu'ils n'entraînent
aucune action de l'ordinateur lors de l'exécution du programme.
Par convention, nous commençons chaque programme par un commentaire indiquant
le numéro de la figure et le nom du fichier du programme. Le commentaire de la ligne
1
// Fig. 2.1: [Link]

commence par //, indiquant qu'il s'agit d'un commentaire de fin de ligne - il se
termine à la fin de la ligne sur laquelle le // apparaît. Un commentaire de fin de ligne
n'a pas besoin de commencer une ligne ; il peut également commencer au milieu d'une
ligne et continuer jusqu'à la fin (comme dans les lignes 5, 8 et 9). La ligne 2,
// Text-printing program.

selon notre convention, est un commentaire qui décrit le but du programme.

Java a également des commentaires traditionnels, qui peuvent être répartis sur
plusieurs lignes comme dans
/* This is a traditional comment.
It can be split over multiple lines */

Ceux-ci commencent par le délimiteur /* et se terminent par */. Le compilateur ignore

tout le texte entre les délimiteurs. Java a incorporé les commentaires traditionnels et les
commentaires de fin de ligne des langages de programmation C et C++,
respectivement.
Java fournit des commentaires d'un troisième type : les commentaires Javadoc. Ceux-
ci sont délimités par /** et */. Le compilateur ignore tout le texte entre les délimiteurs.
Les commentaires Javadoc vous permettent d'intégrer la documentation du programme
directement dans vos programmes. Ces commentaires sont le format de documentation

2
Java préféré dans l'industrie. Le programme utilitaire javadoc (qui fait partie du JDK)
lit les commentaires Javadoc et les utilise pour préparer la documentation du
programme au format de page Web HTML5. Nous utilisons // des commentaires tout
au long de notre code, plutôt que des commentaires traditionnels ou Javadoc, pour
économiser de l'espace. Nous démontrons les commentaires Javadoc et l'utilitaire
javadoc dans l'annexe G en ligne, Création de documentation avec javadoc.
Erreur courante de programmation 2.1
Oublier l'un des délimiteurs d'un commentaire traditionnel ou Javadoc est une erreur de
syntaxe. Une erreur de syntaxe se produit lorsque le compilateur rencontre un code qui
viole les règles du langage Java (c'est-à-dire sa syntaxe). Ces règles sont similaires aux
règles de grammaire en langage naturel spécifiant la structure des phrases, telles que celles
en anglais, français, espagnol, etc. Les erreurs de syntaxe sont également appelées erreurs
de compilation, erreurs de compilation ou erreurs de compilation, car le compilateur les
détecte lors de la compilation du programme. Lorsqu'une erreur de syntaxe est rencontrée,
le compilateur émet un message d'erreur. Vous devez éliminer toutes les erreurs de
compilation avant que votre programme ne se compile correctement
Bonne pratique de programmation 2.1
Certaines organisations exigent que chaque programme commence par un commentaire
indiquant le but du programme et l'auteur, la date et l'heure de la dernière modification
du programme.
Utiliser des lignes vides
Les lignes vides (comme la ligne 3), les caractères d'espacement et les tabulations
peuvent faciliter la lecture des programmes. Ensemble, ils sont connus sous le nom
d'espace blanc. Le compilateur ignore les espaces blancs.
Bonne pratique de programmation 2.2
Utilisez des espaces blancs pour améliorer la lisibilité du programme.
Déclarer une classe
public class Welcome1 {

Commence une déclaration de classe pour la classe Welcome1. Chaque programme

Java se compose d'au moins une classe que vous définissez. Le mot-clé class introduit
une déclaration de classe et est immédiatement suivi du nom de la classe (Welcome1).

3
Les mots-clés sont réservés à une utilisation par Java et sont orthographiés avec toutes
les lettres minuscules. La liste complète des mots clés est présentée à l'annexe C.
Dans les chapitres 2 à 7, chaque classe que nous définissons commence par le mot-clé
public. Pour l'instant, nous l'exigeons simplement. Vous en apprendrez plus sur les
classes publiques et non publiques au chapitre 8.
Nom de fichier pour une classe publique
Une classe publique doit être placée dans un fichier dont le nom se présente sous la
forme [Link], de sorte que la classe Welcome1 est stockée dans le fichier
[Link].
Erreur de programmation commune 2.2
Une erreur de compilation se produit si le nom de fichier d'une classe publique n'est pas
exactement le même nom que la classe (en termes d'orthographe et de casse) suivi de
l'extension .java.
Noms de classe et identificateurs
Par convention, les noms de classe commencent par une lettre majuscule et mettent en
majuscule la première lettre de chaque mot qu'ils incluent (par exemple,
SampleClassName). Un nom de classe est un identifiant—une série de caractères
composée de lettres, de chiffres, de traits de soulignement (_) et de signes dollar ($) qui
ne commence pas par un chiffre et ne contient pas d'espaces. Certains identifiants
valides sont Welcome1, $value, _value, m_inputField1 et button7. Le nom 7button n'est
pas un identifiant valide car il commence par un chiffre, et le champ de saisie du nom
n'est pas un identifiant valide car il contient un espace. Normalement, un identifiant qui
ne commence pas par une majuscule n'est pas un nom de classe. Java est sensible à la
casse - les lettres majuscules et minuscules sont distinctes - donc la valeur et la valeur
sont des identifiants différents (mais tous deux valides)
Bonne pratique de programmation 2.3
Par convention, chaque mot d'un identificateur de nom de classe commence par une lettre
majuscule. Par exemple, l'identifiant de nom de classe DollarAmount commence son
premier mot, Dollar, par un D majuscule et son deuxième mot, Montant, par un A
majuscule. Cette convention de dénomination est connue sous le nom de casse camel, car les
lettres majuscules se détachent comme celles d'un chameau. bosses.

4
Soulignement (_) dans Java 9
Depuis Java 9, vous ne pouvez plus utiliser un trait de soulignement (_) seul comme
identifiant.
Corps de classe
Une accolade gauche (à la fin de la ligne 4), {, commence le corps de chaque déclaration
de classe. Une accolade droite correspondante (à la ligne 9), }, doit terminer chaque
déclaration de classe. Les lignes 5 à 8 sont en retrait.
Bonne pratique de programmation 2.4
Indentez le corps entier de chaque déclaration de classe d'un "niveau" entre les accolades
qui délimitent la classe. Ce format met l'accent sur la structure de la déclaration de classe
et facilite sa lecture. Nous utilisons trois espaces pour former un niveau d'indentation - de
nombreux programmeurs préfèrent deux ou quatre espaces. Quoi que vous choisissiez,
utilisez-le systématiquement.

Bonne pratique de programmation 2.5

Les IDE indentent généralement le code pour vous. La touche Tab peut également être
utilisée pour indenter le code. Vous pouvez configurer chaque IDE pour spécifier le nombre
d'espaces insérés lorsque vous appuyez sur Tab.

Erreur courante de programmation 2.3

C'est une erreur de syntaxe si les accolades n'apparaissent pas dans les paires
correspondantes.

Conseil de prévention d’erreurs 2.1

Lorsque vous tapez une accolade gauche ouvrante, {, tapez immédiatement l'accolade droite
fermante, }, puis repositionnez le curseur entre les accolades et l'indentation pour
commencer à taper le corps. Cette pratique permet d'éviter les erreurs dues à des accolades
manquantes. De nombreux IDE le font pour vous.

5
Déclarer une méthode
// la méthode principale commence l'exécution de l'application Java

est un commentaire indiquant le but des lignes 6 à 8 du programme. Ligne 6

public static void main(String[] args)

est le point de départ de toute application Java. Les parenthèses après l'identifiant main
indiquent qu'il s'agit d'un bloc de construction de programme appelé une méthode. Les
déclarations de classe Java contiennent normalement une ou plusieurs méthodes. Pour
une application Java, une des méthodes doit s'appeler main et être définie comme à la
ligne 6 ; sinon, le programme ne s'exécutera pas.
Les méthodes exécutent des tâches et peuvent renvoyer des informations lorsqu'elles
terminent leurs tâches. Nous expliquerons le but du mot-clé statique dans la section
3.2.5. Le mot-clé void indique que cette méthode ne renverra aucune information. Plus
tard, nous verrons comment une méthode peut renvoyer des informations. Pour
l'instant, imitez simplement la première ligne de main dans vos programmes. Les
arguments String[] entre parenthèses sont une partie obligatoire de la déclaration de
main - nous en discuterons au chapitre 7. L'accolade gauche à la fin de la ligne 6
commence le corps de la déclaration de la méthode. Une accolade droite
correspondante la termine (ligne 8). La ligne 7 est en retrait entre les accolades.
Bonne pratique de programmation 2.6
Indentez le corps entier de chaque déclaration de méthode d'un "niveau" entre les accolades
qui définissent le corps de la méthode. Cela met l'accent sur la structure de la méthode et
la rend plus facile à lire.

Exécution de la sortie avec [Link]

Ligne 7
[Link]("Welcome to Java Programming!");
demande à l'ordinateur d'effectuer une action, à savoir d'afficher les caractères entre
guillemets doubles. Les guillemets eux-mêmes ne sont pas affichés. Ensemble, les
guillemets et les caractères entre eux forment une chaîne, également appelée chaîne
de caractères ou chaîne de littéral. Les espaces blancs dans les chaînes ne sont pas
ignorés par le compilateur. Les chaînes ne peuvent pas s'étendre sur plusieurs lignes de
code. Plus tard, nous montrerons comment traiter facilement les longues chaînes.

6
L'objet [Link], qui est prédéfini pour vous, est appelé objet de sortie standard.
Il permet à un programme d'afficher des informations dans la fenêtre de commande
à partir de laquelle le programme s'exécute. Dans Microsoft Windows, la fenêtre de
commande est l'invite de commande. Sous UNIX/Linux/macOS, la fenêtre de
commande est appelée un terminal ou un shell. De nombreux programmeurs
l'appellent simplement la ligne de commande.
La méthode [Link] affiche (ou imprime) une ligne de texte dans la fenêtre
de commande. La chaîne entre parenthèses à la ligne 7 est l'argument de la méthode.
Lorsque [Link] termine sa tâche, il positionne le curseur de sortie
(l'emplacement où le caractère suivant sera affiché) au début de la ligne suivante dans la
fenêtre de commande. Ceci est similaire à ce qui se passe lorsque vous appuyez sur la
touche Entrée tout en tapant dans un éditeur de texte : le curseur apparaît au début de
la ligne suivante dans le document.
La ligne entière 7, y compris [Link], l'argument "Welcome to Java
Programming!" entre parenthèses et le point-virgule (;), s'appelle une instruction. Une
méthode contient généralement des instructions qui exécutent sa tâche. La plupart des
instructions se terminent par un point-virgule.
Utilisation des commentaires de fin de ligne sur les accolades droites pour la
lisibilité
Pour aider les novices en programmation, nous incluons un commentaire de fin de ligne
après une accolade fermante qui termine une déclaration de méthode et après une
accolade fermante qui termine une déclaration de classe.
Par exemple, la ligne 8
} // end method main
indique l'accolade fermante de la méthode main, et la ligne 9
} // end class Welcome1
indique l'accolade fermante de la classe Welcome1. Chaque commentaire indique la
méthode ou la classe à laquelle l'accolade droite se termine. Nous omettrons ces
commentaires de fin après ce chapitre.
2.2.1 Compilation de la demande
Nous sommes maintenant prêts à compiler et exécuter le programme. Nous supposons
que vous utilisez les outils de ligne de commande du kit de développement Java, pas un
IDE. Les instructions suivantes supposent que les exemples du livre se trouvent dans

7
c:\examples sous Windows ou dans le dossier Documents/examples de votre compte
utilisateur sous Linux/macOS.
Pour préparer la compilation du programme, ouvrez une fenêtre de commande et
accédez au répertoire dans lequel le programme est stocké. De nombreux systèmes
d'exploitation utilisent la commande cd pour changer de répertoire (ou de dossier). Sous
Windows, par exemple
cd c:\examples\ch02\fig02_01

passe au répertoire fig02_01. Sous UNIX/Linux/macOS, la commande

cd ~/Documents/examples/ch02/fig02_01

passe au répertoire fig02_01. Pour compiler le programme, tapez

javac [Link]

Si le programme ne contient pas d'erreurs de compilation, cette commande crée le

fichier appelé [Link] (connu sous le nom de fichier de classe de Welcome1)
contenant les bytecodes Java indépendants de la plate-forme qui représentent notre
application. Lorsque nous utilisons la commande java pour exécuter l'application sur
une plate-forme donnée, la JVM traduit ces bytecodes en instructions comprises par le
système d'exploitation et le matériel sous-jacents.
Erreur de programmation commune 2.4
Le message d'erreur du compilateur "la classe Welcome1 est publique, doit être déclarée
dans un fichier nommé [Link]" indique que le nom du fichier ne correspond pas
au nom de la classe publique dans le fichier ou que vous avez mal saisi le nom de la classe
lors de la compilation du classe.
Lorsque vous apprenez à programmer, il est parfois utile de "casser" un programme en
cours de fonctionnement pour se familiariser avec les messages d'erreur du compilateur.
Ces messages n'indiquent pas toujours le problème exact dans le code. Lorsque vous
rencontrez une erreur, cela vous donnera une idée de ce qui l'a causée. Essayez de
supprimer un point-virgule ou une accolade du programme de la figure 2.1, puis de
recompiler pour voir les messages d'erreur générés par l'omission.
Conseil de prévention d’erreurs 2.2
Lorsque le compilateur signale une erreur de syntaxe, il se peut qu'elle ne se trouve pas sur
la ligne indiquée par le message d'erreur. Vérifiez d'abord la ligne pour laquelle l'erreur a

8
été signalée. Si vous ne trouvez pas d'erreur sur cette ligne, vérifiez plusieurs lignes
précédentes.
Chaque message d'erreur de compilation contient le nom du fichier et le numéro de
ligne où l'erreur s'est produite. Par exemple, [Link] indique qu'une erreur s'est
produite à la ligne 6 dans [Link]. Le reste du message fournit des informations
sur l'erreur de syntaxe.
2.2.2 Exécution de la demande
Maintenant que vous avez compilé le programme, tapez la commande suivante et
appuyez sur Entrée :
java Welcome1
pour lancer la JVM et charger le fichier [Link]. La commande omet l'extension
de nom de fichier .class ; sinon, la JVM n'exécutera pas le programme. La JVM appelle
la méthode principale de Welcome1. Ensuite, la ligne 7 de l'écran principal affiche
"Welcome to Java Programming!".
La figure 2.2 montre le programme s'exécutant dans une fenêtre d'invite de commande
Microsoft Windows. [Remarque : de nombreux environnements affichent des fenêtres
de commande avec des arrière-plans noirs et du texte blanc. Nous avons ajusté ces
paramètres pour rendre nos captures d'écran plus lisibles.]
Conseil de prévention des erreurs 2.3
Lorsque vous tentez d'exécuter un programme Java, si vous recevez un message tel que
"Exception dans le thread "main" [Link]: Welcome1", votre
variable d'environnement CLASSPATH n'a pas été définie correctement. Veuillez lire
attentivement les instructions d'installation dans la section Avant de commencer de ce
manuel. Sur certains systèmes, vous devrez peut-être redémarrer votre ordinateur ou ouvrir
une nouvelle fenêtre de commande après avoir configuré le CLASSPATH.

Fig. 2.2 | Exécution de Welcome1 à partir de la ligne de commande

9
2.3 Modification de votre premier programme Java
Dans cette section, nous modifions l'exemple de la Fig. 2.1 pour imprimer du texte sur
une ligne en utilisant plusieurs instructions et pour imprimer du texte sur plusieurs
lignes en utilisant une seule instruction.
Affichage d'une seule ligne de texte avec plusieurs instructions
Bienvenue dans la programmation Java ! peut être affiché de plusieurs manières. La
classe Welcome2, illustrée à la Fig. 2.3, utilise deux instructions (lignes 7–8) pour
produire la sortie illustrée à la Fig. 2.1. [Remarque : À partir de maintenant, nous
mettons en évidence avec un fond jaune les nouvelles fonctionnalités clés de chaque
liste de codes, comme nous l'avons fait pour les lignes 7 à 8.]
1 // Fig. 2.3: [Link]
2 // Printing a line of text with multiple statements.
3
4 public class Welcome2 {
5 // main method begins execution of Java application
6 public static void main(String[] args) {
7 [Link]("Welcome to ");
8 [Link]("Java Programming!");
9 } // end method main
10 } // end class Welcome2
Welcome to Java Programming!
Fig. 2.3 | Affichage d'une seule ligne de texte avec plusieurs instructions.

Le programme est similaire à la Fig. 2.1, nous n'abordons donc que les changements ici.
Ligne 2
// Printing a line of text with multiple statements.
est un commentaire de fin de ligne indiquant le but du programme. La ligne 4
commence la déclaration de classe Welcome2. Lignes 7–8 dans method main
[Link]("Welcome to ");
[Link]("Java Programming!");

afficher une ligne de texte. La première instruction utilise la méthode print de

[Link] pour afficher une chaîne. Chaque instruction print ou println reprend
l'affichage des caractères là où la dernière instruction print ou println a cessé d'afficher

10
les caractères. Contrairement à println, après avoir affiché son argument, print ne
positionne pas le curseur de sortie au début de la ligne suivante — le prochain caractère
affiché par le programme apparaîtra immédiatement après le dernier caractère affiché
par print. Ainsi, la ligne 8 positionne le premier caractère de son argument (la lettre "J")
immédiatement après le dernier caractère affiché par la ligne 7 (le caractère espace avant
le guillemet double de fermeture de la chaîne).
Affichage de plusieurs lignes de texte avec une seule instruction
Une seule instruction peut afficher plusieurs lignes en utilisant des caractères de retour
à la ligne (\n), qui indiquent aux méthodes print et println de [Link] quand
positionner le curseur de sortie au début de la ligne suivante dans la fenêtre de
commande. Comme les lignes vides, les caractères d'espacement et les caractères de
tabulation, les caractères de retour à la ligne sont des caractères d'espacement. Le
programme de la Fig. 2.4 génère quatre lignes de texte, en utilisant des caractères de
saut de ligne pour déterminer quand commencer chaque nouvelle ligne. La majeure
partie du programme est identique à ceux des Fig. 2.1 et 2.3.
1 // Fig. 2.4: [Link]
2 // Printing multiple lines of text with a single statement.
3
4 public class Welcome3 {
5 // main method begins execution of Java application
6 public static void main(String[] args) {
7 [Link]("Welcome\nto\nJava\nProgramming!");
8 } // end method main
9 } // end class Welcome3

Welcome
to
Java
Programming!
Fig. 2.4 | Impression de plusieurs lignes de texte avec une seule instruction .

Ligne 7
[Link]("Welcome\nto\nJava\nProgramming!");
affiche quatre lignes de texte dans la fenêtre de commande. Normalement, les caractères
d'une chaîne sont affichés exactement tels qu'ils apparaissent entre guillemets doubles.
Cependant, les caractères appariés \ et n (répétés trois fois dans l'instruction)
n'apparaissent pas à l'écran. La barre oblique inverse (\) est un caractère

11
d'échappement, qui a une signification particulière pour les méthodes print et println
de [Link]. Lorsqu'une barre oblique inverse apparaît dans une chaîne, Java la
combine avec le caractère suivant pour former une séquence d'échappement—\n
représente le caractère de retour à la ligne. Lorsqu'un caractère de nouvelle ligne apparaît
dans une chaîne en cours de sortie avec [Link], le caractère de nouvelle ligne
déplace le curseur de sortie de l'écran au début de la ligne suivante dans la fenêtre de
commande.
La figure 2.5 répertorie plusieurs séquences d'échappement et décrit comment elles
affectent l'affichage des caractères dans la fenêtre de commande. Pour la liste complète
des séquences d'échappement, visitez
[Link] 3.10.6

séquence Description
d'échappement
\n Nouvelle ligne. Positionnez le curseur à l'écran au début de la ligne
suivante.
\t Onglet horizontal. Déplacez le curseur à l'écran jusqu'au taquet de
tabulation suivant.
\r Retour chariot. Positionnez le curseur à l'écran au début de la ligne
en cours—n'avancez pas à la ligne suivante. Tous les caractères
sortis après le retour chariot écrasent les caractères précédemment
sortis sur cette ligne.
\\ Barre oblique inverse. Utilisé pour imprimer un caractère barre
oblique inverse.
\" Double citation. Utilisé pour imprimer un caractère de guillemet
double. Par exemple,
[Link]("\"in quotes\"");
affiche " in quotes ".
Fig. 2.5 | Quelques séquences d'échappement courantes.

2.4 Afficher du texte avec printf

La méthode [Link] (f signifie « formaté ») affiche les données formatées. La
figure 2.6 l'utilise pour sortir sur deux lignes les chaînes "Welcome to" et "Java
Programming!".
1 // Fig. 2.6: [Link]
2 // Displaying multiple lines with method
[Link].
3

12
4 public class Welcome4 {
5 // main method begins execution of Java application
6 public static void main(String[] args) {
7 [Link]("%s%n%s%n", "Welcome to", "Java
Programming!");
8 } // end method main
9 } // end class Welcome4
Welcome to
Java Programming!

Fig. 2.6 | Affichage de plusieurs lignes avec la méthode [Link].

Ligne 7
[Link]("%s%n%s%n", "Welcome to", "Java Programming!");

appelle la méthode [Link] pour afficher la sortie du programme. L'appel de

méthode spécifie trois arguments. Lorsqu'une méthode nécessite plusieurs arguments,
ils sont placés dans une liste séparée par des virgules. Appeler une méthode est
également appelé invoquer une méthode.
Pratique de programmation 2.7
Placez un espace après chaque virgule (,) dans une liste d'arguments pour rendre les
programmes plus lisibles.
Le premier argument de la méthode printf est une chaîne de format qui peut consister
en un texte fixe et des spécificateurs de format. Le texte fixe est sorti par printf
comme il le serait par print ou println.
Chaque spécificateur de format est un espace réservé pour une valeur et spécifie le type
de données à sortir. Les spécificateurs de format peuvent également inclure des
informations de formatage facultatives.
Les spécificateurs de format commencent par un signe de pourcentage (%) suivi d'un
caractère qui représente le type de données. Par exemple, le spécificateur de format %s
est un espace réservé pour une chaîne. La chaîne de format spécifie que printf doit
afficher deux chaînes, chacune suivie d'un caractère de saut de ligne. A la première
position du spécificateur de format, printf substitue la valeur du premier argument après
la chaîne de format. À chaque position de spécificateur de format suivante, printf
remplace la valeur de l'argument suivant. Cet exemple remplace donc "Welcome to" par

13
le premier %s et "Java Programming!" pour le deuxième %s. La sortie montre que deux
lignes de texte sont affichées sur deux lignes.
Notez qu'au lieu d'utiliser la séquence d'échappement \n, nous avons utilisé le
spécificateur de format %n, qui est un séparateur de ligne portable sur tous les systèmes
d'exploitation. Vous ne pouvez pas utiliser %n dans l'argument de [Link] ou
[Link] ; cependant, le séparateur de lignes généré par [Link]
après avoir affiché son argument est portable sur tous les systèmes d'exploitation.
L'annexe I en ligne présente plus de détails sur le formatage de la sortie avec printf.

2.5 Une autre application : ajouter des entiers

Notre prochaine application lit (ou entre) deux nombres entiers (nombres entiers, tels
que –22, 7, 0 et 1024) tapés par un utilisateur au clavier, calcule leur somme et l'affiche.
Ce programme doit conserver une trace des nombres fournis par l'utilisateur pour le
calcul ultérieur dans le programme. Les programmes se souviennent des nombres et
d'autres données dans la mémoire de l'ordinateur et accèdent à ces données via des
éléments de programme appelés variables. Le programme de la Fig. 2.7 illustre ces
concepts. Dans l'exemple de sortie, nous utilisons du texte en gras pour identifier
l'entrée de l'utilisateur (c'est-à-dire 45 et 72). Selon notre convention dans les
programmes précédents, les lignes 1–2 indiquent le numéro de la figure, le nom du
fichier et le but du programme.
1 // Fig. 2.7: [Link]
2 // Addition program that inputs two numbers then displays their sum.
3 import [Link]; // program uses class Scanner
4
5 public class Addition {
6 // main method begins execution of Java application
7 public static void main(String[] args) {
8 // create a Scanner to obtain input from the command window
9 Scanner input = new Scanner([Link]);
10
11 [Link]("Enter first integer: "); // prompt
12 int number1 = [Link](); // read first number from user
13
14 [Link]("Enter second integer: "); // prompt
15 int number2 = [Link](); // read second number from user
16
17 int sum = number1 + number2; // add numbers, then store total in sum

14
18
19 [Link]("Sum is %d%n", sum); // display sum
20 } // end method main
} // end class Addition
Enter first integer: 45
Enter second integer: 72
Sum is 117
Fig. 2.7 | Programme d'addition qui entre deux nombres puis affiche leur somme.

2.5.1 Déclarations d'importation (import)

Une grande force de Java est son riche ensemble de classes prédéfinies que vous pouvez
réutiliser plutôt que de "réinventer la roue". Ces classes sont regroupées en packages
(groupes nommés de classes associées) et sont collectivement appelées la bibliothèque
de classes Java ou l'interface de programmation d'applications Java (Java API).
Ligne 3
import [Link]; // program uses class Scanner
est une déclaration d'importation qui aide le compilateur à localiser une classe utilisée
dans ce programme. Cela indique que le programme utilise la classe Scanner prédéfinie
(discutée brièvement) du package nommé [Link]. Le compilateur s'assure alors que
vous utilisez correctement la classe.
Erreur de programmation commune 2.5
Toutes les déclarations d'importation doivent apparaître avant la première déclaration de
classe dans le dossier. Placer une déclaration d'importation à l'intérieur ou après une
déclaration de classe est une erreur de syntaxe.

Erreur de programmation commune 2.6

Oublier d'inclure une déclaration d'importation pour une classe qui doit être importée
entraîne une erreur de compilation contenant un message tel que "symbole introuvable".
Lorsque cela se produit, vérifiez que vous avez fourni les déclarations d'importation
appropriées et que les noms qu'elles contiennent sont corrects, y compris les majuscules
appropriées.

15
2.5.2 Déclarer et créer un objet Scanner pour obtenir une entrée utilisateur à
partir du clavier
Une variable est un emplacement dans la mémoire de l'ordinateur où une valeur peut
être stockée pour une utilisation ultérieure dans un programme. Toutes les variables
Java doivent être déclarées avec un nom et un type avant de pouvoir être utilisées. Le
nom d'une variable permet au programme d'accéder à la valeur de la variable en
mémoire. Un nom de variable peut être n'importe quel identificateur valide—encore
une fois, une série de caractères composés de lettres, de chiffres, de traits de
soulignement (_) et de signes dollar ($) qui ne commencent pas par un chiffre et ne
contiennent pas d'espaces. Le type d'une variable spécifie le type d'informations
stockées à cet emplacement en mémoire. Comme les autres instructions, les instructions
de déclaration se terminent par un point-virgule (;).
Ligne 9 de la méthode main
Scanner input = new Scanner([Link]);
est une instruction de déclaration de variable qui spécifie le nom (entrée) et le type
(Scanner) d'une variable utilisée dans ce programme. Un scanner (package [Link])
permet à un programme de lire des données (par exemple, des nombres et des chaînes)
à utiliser dans un programme. Les données peuvent provenir de nombreuses sources,
telles que l'utilisateur au clavier ou un fichier sur disque. Avant d'utiliser un scanner,
vous devez le créer et spécifier la source des données.
Le = à la ligne 9 indique que l'entrée de la variable Scanner doit être initialisée (c'est-
à-dire préparée pour être utilisée dans le programme) dans sa déclaration avec le résultat
de l'expression à droite
du signe égal—new Scanner([Link]). Cette expression utilise le nouveau mot-clé
pour créer un objet Scanner qui lit les caractères tapés par l'utilisateur au clavier. L'objet
d'entrée standard, [Link], permet aux applications de lire des octets de données
saisis par l'utilisateur. Le scanner traduit ces octets en types (comme ints) qui peuvent
être utilisés dans un programme.
Bonne pratique de programmation 2.8
Le choix des noms de variables significatifs aide à auto-documenter un programme (c'est-
à-dire que l'on peut comprendre le programme simplement en le lisant plutôt qu'en lisant
la documentation associée ou en créant et en visionnant un nombre excessif de
commentaires).

16
Bonne pratique de programmation 2.9
Par convention, les identificateurs de noms variables utilisent la convention de dénomination
Camel-case avec une première lettre en minuscules - par exemple, firstNumber.
2.5.3 Inviter l'utilisateur à entrer des données
Ligne 11
[Link]("Enter first integer: "); // prompt
utilise [Link] pour afficher le message "Entrez le premier entier : ". Ce
message est appelé une invite ou prompt car il demande à l'utilisateur d'effectuer une
action spécifique. Nous utilisons ici la méthode print plutôt que println afin que l'entrée
de l'utilisateur apparaisse sur la même ligne que l'invite. Rappelez-vous de la section 2.2
que les identifiants commençant par des lettres majuscules représentent généralement
des noms de classe. Le système de classe fait partie du package [Link].
Observation de Génie Logiciel 2.1
Par défaut, le package [Link] est importé dans chaque programme Java ; ainsi, les
classes de [Link] sont les seules de l'API Java qui ne nécessitent pas de déclaration
d'importation.
2.5.4 Déclarer une variable pour obtenir un entier à partir du clavier et le
stocker
L'instruction de déclaration de variable à la ligne 12
int number1 = [Link](); // read first number from user

déclare que la variable number1 contient des données de type int, c'est-à-dire des valeurs
entières, qui sont des nombres entiers tels que 72, –1127 et 0. La plage de valeurs pour
un int est de –2 147 483 648 à +2 147 483 647. Les valeurs int que vous utilisez dans
un programme ne doivent pas contenir de virgules ; cependant, pour plus de lisibilité,
vous pouvez placer des traits de soulignement dans les nombres. Donc 60_000_000
représente la valeur int 60 000 000.
Certains autres types de données sont float et double, pour contenir des nombres réels,
et char, pour contenir des données de caractères. Les nombres réels contiennent des
points décimaux, comme dans 3.4, 0.0 et –11.19. Les variables de type char représentent
des caractères individuels, comme une lettre majuscule (par exemple, A), un chiffre (par
exemple, 7), un caractère spécial (par exemple, * ou %) ou une séquence d'échappement

17
(par exemple, le caractère de tabulation, \t ). Les types int, float, double et char sont
appelés types primitifs. Les noms de type primitif sont des mots-clés et doivent
apparaître en toutes lettres minuscules. L'annexe D résume les caractéristiques des huit
types primitifs (boolean, byte, char, short, int, long, float et double).
Le = à la ligne 12 indique que la variable int number1 doit être initialisée dans sa
déclaration avec le résultat de [Link](). Cela utilise la méthode nextInt de l'entrée
de l'objet Scanner pour obtenir un entier de l'utilisateur au clavier. À ce stade, le
programme attend que l'utilisateur tape le numéro et appuie sur la touche Entrée pour
soumettre le numéro au programme.
Notre programme suppose que l'utilisateur entre une valeur entière valide. Sinon, une
erreur logique se produira et le programme se terminera. Le chapitre 11, Gestion des
exceptions : un regard plus approfondi, explique comment rendre vos programmes plus
robustes en leur permettant de gérer de telles erreurs. Ceci est également connu sous le
nom de rendre votre programme tolérant aux pannes.
2.5.5 Obtention d'un deuxième entier
Ligne 14
[Link]("Enter second integer: "); // prompt

invite l'utilisateur à saisir le deuxième entier. Ligne 15

int number2 = [Link](); // read second number from user

déclare la variable int number2 et l'initialise avec un deuxième entier lu par l'utilisateur
au clavier.
2.5.6 Utilisation de variables dans un calcul
Ligne 17
int sum = number1 + number2; // add numbers then store total in sum

déclare la variable int sum et l'initialise avec le résultat de number1 + number2. Lorsque
le programme rencontre l'opération d'addition, il effectue le calcul en utilisant les valeurs
stockées dans les variables numéro1 et numéro2.
Dans l'instruction précédente, l'opérateur d'addition est un opérateur binaire, car il
comporte deux opérandes : nombre1 et nombre2. Les parties d'instructions qui
contiennent des calculs sont appelées des expressions. En fait, une expression est toute
partie d'une instruction qui a une valeur. La valeur de l'expression nombre1 + nombre2
est la somme des nombres. De même, la valeur de l'expression [Link]() (lignes
12 et 15) est l'entier saisi par l'utilisateur.

18
Bonne pratique de programmation 2.10
Placez des espaces de chaque côté d'un opérateur binaire pour plus de lisibilité.
2.5.7 Affichage du résultat du calcul
Une fois le calcul effectué, la ligne 19
[Link]("Sum is %d%n", sum); // display sum

utilise la méthode [Link] pour afficher la somme. Le spécificateur de format

%d est un espace réservé pour une valeur int (dans ce cas, la valeur de sum) - la lettre d
signifie "entier décimal". Les caractères restants dans la chaîne de format sont tous du
texte fixe. Ainsi, la méthode printf affiche « Sum is », suivi de la valeur de sum (à la
position du spécificateur de format %d) et d'une nouvelle ligne.
Les calculs peuvent également être effectués à l'intérieur des instructions printf. Nous
aurions pu combiner les déclarations aux lignes 17 et 19 dans la déclaration
[Link]("Sum is %d%n", (number1 + number2));

Les parenthèses autour de l'expression nombre1 + nombre2 sont facultatives—elles

sont incluses pour souligner que la valeur de l'expression entière est sortie à la position
du spécificateur de format %d. De telles parenthèses sont dites redondantes.
2.5.8 Documentation de l'API Java
Pour chaque nouvelle classe d'API Java que nous utilisons, nous indiquons le package
dans lequel elle se trouve. Ces informations vous aident à localiser les descriptions de
chaque package et classe dans la documentation de l'API Java. Une version Web de
cette documentation est disponible à l'adresse
[Link]

Vous pouvez le télécharger à partir de la section Ressources supplémentaires

[Link]

de l'annexe F qui montre comment utiliser cette documentation.

2.5.9 Déclaration et initialisation de variables dans des instructions séparées
Chaque variable doit avoir une valeur avant que vous puissiez utiliser la variable dans
un calcul (ou une autre expression). L'instruction de déclaration de variable à la ligne 12
déclarait numéro1 et l'initialisé avec une valeur entrée par l'utilisateur.
Parfois, vous déclarez une variable dans une instruction, puis vous initialisez dans une
autre. Par exemple, la ligne 12 aurait pu être écrite en deux déclarations comme

19
 int number1; // declare the int variable number1
number1 = [Link](); // assign the user's input to number1

La première instruction déclare number1, mais ne l'initialise pas. La deuxième

instruction utilise l'opérateur d'affectation, =, pour affecter (c'est-à-dire donner) à
number1 la valeur entrée par l'utilisateur. Vous pouvez lire cette instruction comme
"number1 obtient la valeur de [Link] ()". Tout ce qui se trouve à droite de
l'opérateur d'affectation, =, est toujours évalué avant que l'affectation ne soit effectuée.
2.6 Concepts de mémoire
Les noms de variables tels que nombre1, nombre2 et somme correspondent en fait à
des emplacements dans la mémoire de l'ordinateur. Chaque variable a un nom, un type,
une taille (en octets) et une valeur.
Dans le programme d'addition de la Fig. 2.7, lorsque l'instruction suivante (ligne 12)
s'exécute :
int number1 = [Link](); // read first number from user

le numéro tapé par l'utilisateur est placé dans un emplacement mémoire correspondant
au nom numéro1. Supposons que l'utilisateur entre 45. L'ordinateur place cette valeur
entière dans l'emplacement numéro1 (Fig. 2.8), remplaçant la valeur précédente (le cas
échéant) à cet emplacement. La valeur précédente est perdue, ce processus est donc dit
destructif.
number1 45

Fig. 2.8 | Emplacement mémoire indiquant le nom et la valeur de la variable number1.

Lorsque la déclaration (ligne 15)

int number2 = [Link](); // read second number from user

s'exécute, supposons que l'utilisateur entre 72. L'ordinateur place cette valeur entière
dans l'emplacement numéro2. La mémoire apparaît maintenant comme indiqué dans la
Fig. 2.9.
number1 45

number2 72

Fig. 2.9 | Emplacements de mémoire après le stockage des valeurs pour number1 et number2.

20
Une fois que le programme de la Fig. 2.7 a obtenu les valeurs de nombre1 et nombre2,
il additionne les valeurs et place le total dans la somme variable. La déclaration (ligne
17)
int sum = number1 + number2; // add numbers, then store total in sum

effectue l'addition, puis remplace toute valeur précédente dans la somme. Une fois la
somme calculée, la mémoire apparaît comme illustré à la Fig. 2.10. Les valeurs de
nombre1 et nombre2 apparaissent exactement telles qu'elles étaient avant d'être utilisées
dans le calcul de la somme. Ces valeurs ont été utilisées, mais pas détruites, car
l'ordinateur a effectué le calcul. Lorsqu'une valeur est lue à partir d'un emplacement
mémoire, le processus est non destructif.
number1 45

number2 72

sum 117

Fig.2.10 | Emplacements de mémoire après avoir enregistré la somme de nombre1 et nombre2.

2.7 Arithmétique
La plupart des programmes effectuent des calculs arithmétiques. Les opérateurs
arithmétiques sont résumés dans la Fig. 2.11. Notez l'utilisation de divers symboles
spéciaux non utilisés en algèbre. L'astérisque (*) indique la multiplication et le signe
de pourcentage (%) est l'opérateur de modulo, dont nous parlerons bientôt. Les
opérateurs arithmétiques de la Fig. 2.11 sont des opérateurs binaires, car chacun opère
sur deux opérandes. Par exemple, l'expression f + 7 contient l'opérateur binaire + et les
deux opérandes f et 7.
Expression
Opération Opérateur Java Expression Java
algébrique
Addition + f+7 f+7
Soustraction – p–c p-c
Multiplication * f+7 b*m
Division / x / y or -x- or x ÷ y x / y
Modulo % r mod s r%s
Fig.2.11 | Opérateurs arithmétiques.

21
La division entière donne un quotient entier. Par exemple, l'expression 7/4 est évaluée
à 1 et l'expression 17/5 est évaluée à 3. Toute partie fractionnaire dans la division entière
est simplement tronquée (c'est-à-dire ignorée) - aucun arrondi ne se produit. Java
fournit l'opérateur de reste, %, qui donne le reste après division. L'expression x % y
donne le reste après la division de x par y. Ainsi, 7 % 4 donne 3 et 17 % 5 donne 2. Cet
opérateur est le plus souvent utilisé avec des opérandes entiers mais il peut aussi être
utilisé avec d'autres types arithmétiques. Dans les exercices de ce chapitre et dans les
chapitres suivants, nous considérons plusieurs applications intéressantes de l'opérateur
de reste, comme déterminer si un nombre est un multiple d'un autre.
Expressions arithmétiques sous forme de ligne droite
Les expressions arithmétiques en Java doivent être écrites sous forme de ligne droite
pour faciliter la saisie de programmes dans les ordinateurs. Ainsi, des expressions telles
que « a divisé par b » doivent être écrites sous la forme a/b, de sorte que toutes les
constantes, variables et opérateurs apparaissent sur une ligne droite. La notation
algébrique suivante n'est généralement pas acceptable pour les compilateurs :
𝑎
𝑏
Parenthèses pour regrouper des sous-expressions
Les parenthèses sont utilisées pour regrouper les termes dans les expressions Java de la
même manière que dans les expressions algébriques. Par exemple, pour multiplier a par
la quantité b + c, on écrit
un * (b + c)

Si une expression contient des parenthèses imbriquées, telles que

((a + b) * c)

l'expression dans le jeu de parenthèses le plus interne (a + b dans ce cas) est évaluée en
premier.
Règles de priorité des opérateurs
Java applique les opérateurs arithmétiques dans une séquence précise déterminée par
les règles de priorité des opérateurs, qui sont généralement les mêmes que celles
suivies en algèbre :
1. Les opérations de multiplication, de division et de reste sont appliquées en premier.
Si une expression contient plusieurs de ces opérations, elles sont appliquées de gauche

22
à droite. Les opérateurs de multiplication, de division et de reste ont le même niveau de
priorité.
2. Les opérations d'addition et de soustraction sont ensuite appliquées. Si une
expression contient plusieurs opérations de ce type, les opérateurs sont appliqués de
gauche à droite. Les opérateurs d'addition et de soustraction ont le même niveau de
priorité.
Ces règles permettent à Java d'appliquer les opérateurs dans le bon ordre1. Lorsque nous
disons que les opérateurs sont appliqués de gauche à droite, nous faisons référence à
leur associativité. Certains s'associent de droite à gauche. La figure 2.12 résume ces
règles de priorité des opérateurs. Un tableau de priorité complet est inclus dans l'annexe
A.
Opérateur(s) Opération Ordre d'évaluation (priorité)
* Multiplication
/ Division Evalué en premier. S'il y a plusieurs opérateurs
de ce type, ils sont évalués de gauche à droite.
% Modulo
+ Addition
Évalué ensuite. S'il y a plusieurs opérateurs de ce
– Soustraction type, ils sont évalués de gauche à droite.
= Affectation Évalué en dernier.
Fig.2.12 | Priorité des opérateurs arithmétiques.

Exemples d'expressions algébriques et Java

Considérons plusieurs exemples d'expressions. Chaque exemple montre une expression
algébrique et son équivalent Java. Voici un exemple d'une moyenne de cinq termes :
a+b+c+d+e
Algèbre
5
Java (a + b + c + d + e)/5

Les parenthèses sont obligatoires car la division a une priorité plus élevée que l'addition.
La quantité entière (a + b + c + d + e) doit être divisée par 5. Si les parenthèses sont
omises par erreur, nous obtenons a + b + c + d + e / 5, ce qui donne l'expression
différente

1
Nous utilisons des exemples simples pour expliquer l'ordre d'évaluation. Des problèmes subtils d'ordre
d'évaluation se produisent dans les expressions plus complexes. Pour plus d'informations, reportez-vous au
chapitre 15 de Java™ ™ Language Specification ([Link]

23
 𝑒
𝑎 + 𝑏 + 𝑐 + 𝑑 +
5
Voici un exemple de l'équation d'une droite :
Algèbre y = mx + b
Java y = m * x + b;

Aucune parenthèse n'est requise. L'opérateur de multiplication est appliqué en premier

car la multiplication a une priorité plus élevée que l'addition. L'affectation se produit en
dernier car elle a une priorité inférieure à la multiplication ou à l'addition.
L'exemple suivant contient des opérations de reste (%), de multiplication, de division,
d'addition et de soustraction :
Algèbre z = pr%q + w/x – y
Java z = p * r % q + w / x - y;

6 1 2 4 3 5
Les nombres encerclés sous l'instruction indiquent l'ordre dans lequel Java applique les
opérateurs. Les opérations *, % et / sont évaluées en premier dans l'ordre de gauche à
droite (c'est-à-dire qu'elles s'associent de gauche à droite), car elles ont une priorité plus
élevée que + et -. Les opérations + et - sont ensuite évaluées. Ces opérations
s'appliquent également de gauche à droite. L'opération d'affectation (=) est évaluée en
dernier.
Évaluation d'un polynôme du second degré
Pour développer une meilleure compréhension des règles de priorité des opérateurs,
considérons l'évaluation d'une expression d'affectation qui comprend un polynôme du
second degré ax² + bx + c :
Java y = a * x * x + b * x + c;

6 1 2 4 3 5
Les opérations de multiplication sont ’ évaluées en premier dans l'ordre de gauche à
droite (c'est-à-dire qu'elles s'associent de gauche à droite), car elles ont une priorité plus
élevée que l'addition. (Java n'a pas d'opérateur arithmétique pour l'exponentiation, donc
x2 est représenté par x * x. La section 5.4 montre une alternative pour effectuer
l'exponentiation.) Les opérations d'addition sont ensuite évaluées de gauche à droite.
Supposons que a, b, c et x soient initialisés (valeurs données) comme suit : a= 2, b= 3,
c=7 et x= 5. La figure 2.13 illustre l'ordre dans lequel les opérateurs sont appliqués.

24
Vous pouvez utiliser des parenthèses redondantes pour rendre une expression plus
claire. Par exemple, l'instruction précédente peut être entre parenthèses comme suit :
y = (a * x * x) + (b * x) + c ;

2.8 Prise de décision : égalité et opérateurs relationnels

Une condition est une expression qui peut être vraie ou fausse. Cette section présente
l'instruction de sélection if de Java, qui permet à un programme de prendre une
décision en fonction de la valeur d'une condition. Par exemple, la condition « la note
est supérieure ou égale à 60 » détermine si un élève a réussi un test. Si la condition d'une
instruction if est vraie, son corps s'exécute. Si la condition est fausse, son corps ne
s'exécute pas.
Les conditions dans les instructions if peuvent être formées en utilisant les opérateurs
d'égalité (== et !=) et les opérateurs relationnels (>, <, >= et <=) résumés dans la
Fig. 2.14. Les deux opérateurs d'égalité ont le même niveau de précédence, qui est
inférieur à celui des opérateurs relationnels. Les opérateurs d'égalité s'associent de
gauche à droite. Les opérateurs relationnels ont tous le même niveau de priorité et
s'associent également de gauche à droite.
Opérateur Égalité Java ou Exemple de Signification de la
algébrique opérateur condition Java condition Java
relationnel
Opérateurs d'égalité
= == x == y x est égal à y
≠ != x != y x n'est pas égal à y
Opérateurs relationnels
> > x>y x est supérieur à y
< < x<y x est inférieur à y
≥ >= x >= y x est supérieur ou égal à y
≤ <= x <= y x est inférieur ou égal à y
Fig.2.14 | Égalité et opérateurs relationnels.

La figure 2.15 utilise six instructions if pour comparer deux nombres entiers entrés par
l'utilisateur. Si la condition dans l'une de ces instructions if est vraie, l'instruction
associée à cette instruction if s'exécute ; sinon, l'instruction est ignorée. Nous utilisons
un scanner pour entrer les nombres entiers de l'utilisateur et les stocker dans les
variables number1 et number2. Le programme compare les nombres et affiche les

25
résultats des comparaisons qui sont vraies. Nous montrons trois exemples de sorties
pour différentes valeurs saisies par l'utilisateur.

26