Ce cours initie aux bases de la programmation en utilisant le langage Java : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en Java)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Variables : lecture/écriture
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
230 notes
À partir de la leçon
Initiation à la programmation
Cette semaine vous accueille dans le cours et vous présente les premiers concepts de base de la programmation.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
Jusqu'à présent, nous avions vu comment déclarer, comment initialiser,
et aussi comment affecter une variable.
Intéressons-nous ici à comment afficher une variable,
puis à comment lire sa valeur depuis le clavier.
Commençons par l'affichage.
Si l'on regarde le programme d'exemples simples suivants, les lignes d'affichage,
ce sont ces trois lignes, ici, en bas.
Examinons-les maintenant, plus en détails.
La ligne qui nous intéresse est donc la suivante, qui, si l'on suppose
que l'on a une variable, n, de type, entier, qui contient la valeur, 4,
va nous afficher le message, la variable n contient 4.
Cette ligne est composée de deux parties.
Il y a, tout d'abord, ici, la description,
dans le langage Java, de ce qui correspond à ce qu'on appelle, techniquement,
la sortie standard, et, plus communément, donc ce qui correspond au terminal.
Et la deuxième partie, ici, est le message que l'on va envoyer sur le terminal.
Ce message est, lui-même, comme vous le voyez, composé de plusieurs morceaux.
On a tout d'abord, ici, entre double quote,
une chaîne littérale, qui va s'écrire, telle quelle, sur la sortie, puis l'on a,
ici, une expression Java, c'est-à-dire quelque chose qui va être évalué,
avant d'être affiché, donc ici une expression Java qui reprend la valeur de,
n ; qui va donc, ici, afficher, 4.
Puis, on retrouve, enfin, une troisième, ici, et dernière partie, qui est,
de nouveau, un messsage qui, ici, est simplement réduit au point,
qui va permettre d'afficher ce point.
Ces différentes parties sont composées à l'aide du signe, +, ici.
Attention, le signe, +,
pour des messages rajoute simplement les messages les uns derrière les autres.
Si j'écris un, entre double quote, ici, suivi de, message,
ceci correspond à la chaîne, un message.
Ici, c'est donc bien tout à fait une concaténation de messages, un collage
de messages l'un derrière l'autre, que l'on a, et non pas, du tout, une addition.
De l'autre côté on a donc la description du terminal, en toute rigueur,
ici, System.out, suivi, donc, d'une fonction,
d'une méthode, println, qui veut dire, print line,
qui veut dire que donc le message en question va en fait, retourner à la ligne,
va faire ce qu'on appelle un saut de ligne, une fois qu'il s'est affiché.
Si l'on ne souhaite pas faire ce saut de ligne,
ici, on peut simplement aussi, utiliser la méthode, print, tout simplement,
qui ne fera pas le retour à la ligne.
Donc, pour résumer, si vous voulez afficher une expression,
un message, vous commencez par donc, taper, System.out.println,
si vous voulez un saut à la ligne, et puis ensuite, derrière, entre guillemets, ici,
les messages littéraux, affichés tels que vous les écrivez,
et puis des expressions, concaténées, donc, combinées avec ce signe, +.
Si vous ne souhaitez pas faire le saut à la ligne, à ce moment-là,
vous utilisez la fonction, print, au lieu de la fonction, println.
Ce qui fait que les différents messages s'afficheront,
cette fois-ci, les uns derrière les autres,
collés, et non pas les uns à la suite des autres, ligne à ligne.
On peut donc tout à fait utiliser ce système pour, simplement,
afficher une simple valeur de variable qui est juste réduite, donc,
à une expression qui se réduit à cette valeur.
Mais vous pouvez aussi combiner avec n'importe quelle expression Java.
Donc, par exemple, ici, vous pouvez tout à fait afficher un message qui comporte le
début de phrase, Le double de, puis ensuite qui va évaluer la valeur de, n,
ensuite rajouter le message tel quel, est, et puis, ici, évaluer une expression Java,
c'est une expression Java aussi compliquée que vous voulez,
dont la valeur sera donc affichée en tant que telle.
Tout à l'heure, j'ai aussi insisté sur le fait que le signe utilisé, ici,
pour coller les chaînes, concaténer les chaînes,
n'était pas du tout une addition arithmétique.
Donc, comment faire si vous voulez afficher une expression qui contient
une addition?
Pour cela il faudra absolument utiliser, et protéger, par des parenthèses, de
sorte que l'expression parenthésée, ici, soit évaluée dans un sens arithmétique, et
non pas dans un sens de valeur de chaînes, collées les unes derrière les autres.
Par exemple si, n vaut 4, et puis que, n carré vaut 16,
alors ici, cette expression va évaluer n, qui fait 4,
plus au sens de l'arithmétique, ici, 16, qui va nous donner la valeur, 20.
Et ensuite cette valeur va être, ici, affichée en tant que telle.
Et donc, ça nous affichera, n plus nCarre =, ici, 20.
Si par contre, on avait omis les parenthèses, ici,
si on ne fait pas ceci, alors à ce moment-là on va afficher, n plus nCarre,
suivi de la valeur, 4, suivi, collée directement derrière, de la valeur, 16.
Et donc on aurait comme message, n plus nCarre = 416.
Ce qui n'est certainement pas ce que l'on veut,
et donc pour pouvoir garantir que l'évaluation, n plus nCarre, ici,
est évaluée au sens arithmétique, il faut la protéger par des parenthèses.
Déroulons maintenant, pas à pas, l'exemple du cours.
On commence pour cela par déclarer une variable,
ici, n, que l'on initialise à la valeur, 4.
Ensuite on déclare une variable, nCarre, que l'on n'initialise pas,
donc on ne connaît pas sa valeur initiale.
Puis on fait une affectation, avec tout d'abord donc l'évaluation, ici,
de l'expression, n, qui va nous donner donc, 4 * n, qui nous redonne la valeur,
4, qui va donc bien sûr s'évaluer à, 16.
Et puis cette valeur, 16, va donc être recopiée dans, nCarre,
et donc on aura ici, en mémoire, 4, dans n, et 16, dans, nCarre.
Ce qui fait qu'on va, ensuite, afficher, ici, un message, la variable n contient,
qui va s'afficher tel quel.
Puis, ici, évaluation de l'expression, n,
c'est-à-dire remplacée par la valeur de, n.
Et on aura donc le message, la variable contient 4.
Puis on passe à la ligne suivante, qui va, ici, afficher le message, le carre de n,
puis évaluer l'expression, ici, n, au sens Java, donc le remplacer par sa valeur, 4.
Puis afficher littéralement la chaîne, est, puis évaluer l'expression,
nCarre, ici, donc la remplacer par la valeur, 16, puis ensuite concaténer,
et rajouter derrière la chaîne littérale qui contient le point.
Ce qui fait que l'on va avoir, donc, le message, Le carre de 4 est 16.
Enfin, dans la dernière ligne, on aura, de la même façon, affichage du message,
le double de n est, notez ici que c'est bien la lettre,
n, puisqu'elle est comprise entre les doubles quotes, qui est affichée.
C'est la lettre, le mot, n, qui est affiché, ce n'est pas une expression,
comme on avait précédemment, ici, ou comme on peut avoir, à cet endroit-là.
Donc, le double de n est, suivi donc de l'expression, 2 * n,
où l'on va donc, rechercher la valeur de n, 4, la multiplier par 2,
et donc qui va s'évaluer à, 8, pour afficher ici le message, 8, suivi, donc,
du message, point, et enfin du retour à la ligne, à cause du, println.
Une petite question, maintenant.
Détaillons pas à pas l'exécution du code de la question.
On commence par déclarer une variable, a, de type entier,
que l'on initialise à la valeur, 2.
Puis l'on déclare une variable, b, de type entier,
que l'on initialise à la valeur, 1.
Puis ensuite on a une affectation, où on a, ici, une expression,
qui va évaluer donc, a qui vaut 2, puis qui va évaluer ici,
b + 2, c'est-à-dire, 1 + 2, ce qui va nous donner la valeur, 3.
On va donc ici avoir la valeur, 2 * 3, qui va être mise dans b.
Donc pour résumer,
ici l'expression s'évalue à, 6, et donc on met la valeur, 6, dans b.
Puis ensuite on va arriver à la dernière ligne, qui va afficher l'expression de,
a, ici, 2, puis afficher la chaîne virgule,,
; puis afficher la valeur de b, ici, c'est-à-dire 6.
Une deuxième question?
Regardons le déroulement, pas à pas, du code de la question précédente.
On commence par déclarer une variable, a, de type entier,
que l'on initialise à la valeur, 1.
Puis l'on déclare une variable b, de type entier, que l'on initialise à la valeur,
2.
Puis on arrive à une affectation, où on évalue, ici, l'expression,
b, qui va donc nous retourner, 2, et on va mettre, 2, ici, dans a.
Puis on évalue l'expression qui suit, ici,
a, et on va recopier cette expression dans b.
Ce qui fait que, au final, lors de l'affichage,
on va avoir ici l'évaluation de l'expression a, 2.
Évaluation de la chaîne virgule,, ; telle quelle.
Puis ensuite évaluation de l'expression b, qui vaut 2, et donc ça nous affichera,
2,2 ; à ce stade-là on peut donc se demander comment échanger la valeur
de deux variables, puisque l'on voit que dans l'exemple précédent,
en fait on n'a pas du tout échangé les deux variables, mais on a simplement
recopié la valeur de b, partout, dans les deux variables, dans, a et dans, b.
Pour échanger les deux variables, la question qu'on pourrait se poser, c'est
comment vous le feriez, si vous aviez à échanger le contenu de deux verres?
Supposons que vous ayez un verre de grenadine,
et que vous ayez un verre de menthe, ici.
Donc le verre de menthe, je vais l'appeler b, le verre de grenadine,
je vais l'appeler, a.
Comment vous pouvez faire pour échanger le contenu des deux verres?
La bonne solution c'est simplement d'introduire un troisième verre.
Un troisième verre, disons-le, appelons-le, simplement, tmp.
Eh bien ce n'est pas plus difficile en programmation.
Si on veut échanger le contenu de deux variables, Il suffit d'introduire une
variable temporaire temp ici qui va nous permettre de transférer les valeurs.
Par exemple, ici on a donc a initialisé à 1 et b initialisé à 2.
Et on va donc introduire une variable temporaire temp,
dans laquelle on commence par recopier la valeur de a ici.
Puis ensuite, ce que l'on va pouvoir faire, c'est recopier la valeur de b
dans a, puisque la valeur de a ayant été sauvegardée dans temp, on peut
maintenant tranquillement remplacer dans a la valeur initiale par la valeur de b.
Puis ensuite, en dernier lieu,
on va recopier la valeur que l'on avait sauvegardé dans temp dans la variable b
ici, ce qui va nous mettre donc la valeur 1 dans la variable b.
Ce qui fait bien que au début, on avait 1 dans a et 2 dans b.
Et on voit bien qu'on a ici échangé le contenu initial des deux variables a et b.
Passons maintenant à la lecture de la valeur d'une variable depuis le clavier.
Reprenons pour cela notre exemple favori avec le calcul et l'affichage
du carré ou du double de n.
Et supposons que ce, maintenant ce programme,
on veuille non pas le faire pour une valeur n = 4,
mais que l'on veuille demander la valeur de n au clavier à l'utilisateur.
Comment faire?
Pour cela, on va simplement remplacer la ligne qui affectait la valeur 4 à n par un
ensemble de lignes qui vont nous permettre et que l'on va détailler juste dans la
suite, qui vont nous permettre d'affecter une valeur lue au clavier à la variable n.
Pour cela,
il faut commencer par importer ce que l'on appelle techniquement la classe Scanner.
C'est ce que vous faites en ajoutant cette ligne une fois au début de votre
programme, import java.util.Scanner avec toujours le point-virgule.
Une fois que vous avez mis cette ligne, vous pouvez donc déclarer une variable,
je l'ai appelée ici keyb, une variable keyb donc de type Scanner.
Et l'initialiser en la liant au clavier,
ce qu'on appelle techniquement l'entrée standard in comme input, entrée.
L'entrée standard donc, le clavier ici, représenté par System.in.
Donc, tout ce que vous avez à faire, c'est d'écrire cette ligne.
Scanner avec un nom de variable,
donc keyb ici, égal new Scanner (System.in), point-virgule.
Et à partir de là, vous pourrez utiliser
la variable keyb pour pouvoir lire des variables au clavier.
Cette ligne doit être écrite une fois et une seule pour tout le programme.
Vous n'avez besoin que de faire une fois le lien vers le clavier.
A ce stade du cours, vous l'écrirez dans le main().
Et à partir de cette ligne,
vous pourrez donc utiliser la variable keyb pour pouvoir lire des valeurs.
On peut par exemple vouloir lire un entier au clavier pour pouvoir initialiser
une variable comme fait ici.
Donc, je déclare une variable n de type entier que j'initialise
avec une lecture au clavier qui s'écrit de la façon suivante.
Donc, keyb, la variable Scanner que j'avais précédemment déclarée,
keyb point, et puis ici une lecture d'un entier,
donc nextInt(), pour lire le prochain entier, parenthèse, parenthèse.
Et puis on termine donc l'instruction d'initialisation de notre variable.
Tout ceci est peut-être un peu technique, mais il suffit en fait simplement de
suivre la procédure expliquée ici en trois étapes que je vous résume encore une fois.
Tout d'abord, vous ajoutez cette ligne une fois au tout début de votre programme.
Ensuite, vous ajoutez cette ligne une seule fois là où vous en avez besoin pour
l'instant, disons dans le main(), pour déclarer une variable de type Scanner.
Et ensuite, vous utilisez autant de fois que vous avez besoin
la lecture de par exemple ici un entier avec nextInt().
La méthode nextInt() fonctionne plus exactement de la façon suivante.
Donc, elle commence par arrêter momentanément le programme.
Et elle va ensuite attendre que l'utilisateur saisisse une valeur et
appuie sur la touche Entrée, la touche return.
Et puis, cette valeur, il va la lire comme un entier.
La convertir en entier et enfin donc le résultat sera la valeur en
type entier de ce qui a été tapé au clavier.
Ce sera, dans l'étape donc numéro trois, affecté à la variable n.
Puis, le programme pourra donc continuer, nextInt() étant ce qu'on appelle une
méthode, si vous voulez, une fonction, un traitement associé à l'objet Scanner.
Il existe bien sûr la possibilité de lire plein d'autres choses,
plein de valeurs d'autres types.
Par exemple, si l'on veut lire une valeur décimale, donc une valeur de type double,
ce qu'on va utiliser, c'est la fonction nextDouble().
Donc par exemple, pour initialiser une variable x de type double
avec une valeur lue au clavier, on écrira donc la déclaration, double x.
Et puis ici, donc l'initialisation, égal, keyb.nextDouble(),
ce qui lira au clavier une valeur de type double, donc une valeur décimale.
Prenons un exemple pas à pas.
Ici, donc on commence avec la ligne de déclaration usuelle
par créer un Scanner qui va nous associer le clavier
à donc un Scanner que j'ai décidé ici d'appeler keyb.
Ensuite, ce qu'il faut,
c'est avertir l'utilisateur qu'on veut entrer une valeur.
Donc pour cela,
on va lui afficher avec la technique que l'on a vu précédemment un message.
Ici, entrez une valeur pour n, par exemple.
Puis, on va aller lire la valeur ici au clavier,
avec donc la méthode nextInt() de l'objet que l'on a créé, keyb.
Supposons donc à ce stade-là par exemple, l'utilisateur tape au clavier la valeur 2.
Et donc, cette méthode ici va s'évaluer, va aller lire sur le clavier
et va s'évaluer à la valeur 2, ce qui fait que donc ensuite 2 va se mettre
comme valeur initiale dans la variable n.
Et on peut passer donc à l'étape suivante.
De façon classique ici, on va évaluer n * n qui va nous faire 4.
On va mettre 4 dans la variable nCarré,
puis on va afficher ici le message La variable contient,
évaluation de l'expression n, ce qui nous permettra donc d'afficher
ici par exemple la valeur, on a décidé d'afficher ici la valeur de n 2.
En plus des fonctions nextInt() qui lit un entier et
nextDouble qui lit un nombre décimal, une fonction qui pourrait vous être utile est
la fonction nextLine() qui permet de lire d'un seul coup toute une ligne complète.
Prenons un exemple.
Comme d'habitude donc, nous déclarons ici un Scanner que j'appelle keyb.
Et que donc j'associe au clavier.
Et puis, une fois qu'on a fait cette déclaration,
on peut donc faire un appel comme cela, keyb.nextLine(),
qui va permettre donc de lire toute une ligne entière.
Si par exemple, on a tapé un message comme bonjour tout le monde,
l'appel à la fonction nextLine() va alors lire tout la ligne comme cela qui a été
tapée par l'utilisateur, tous les caractères qui ont été entrés,
jusqu'à ce qu'il ait tapé sur la touche Entrée, la touche return.
La question est donc dans quelle variable allons-nous stocker un tel message?
Quel doit être le type d'une telle variable?
Pour l'instant, en anticipant sur quelque chose qui sera présenté dans une vidéo
ultérieure, je vous demande simplement de recopier simplement la ligne comme cela.
String s, donc String est le type de cette variable que nous allons
utiliser pour sauvegarder le message, et s bien sûr est le nom de cette variable.
Une fois qu'on a tapé donc cette ligne String s = keyb.nextLine(),
alors s va contenir tous les caractères qui auront été tapés par l'utilisateur.
Jusqu'à l'appui sur la touche return.
Attention, cependant, avec l'utilisation de la méthode nextLine()
qui ne se mélange pas très très bien avec les fonctions nextint() et nextDouble().
Si je prends un exemple, supposons donc que je déclare
un variable i de type entier et que je l'initialise avec une lecture au clavier,
au travers donc de nextInt().
Et que juste après, j'ai envie de lire un message, une ligne entière,
donc nextLine() que je mets dans s1.
Puis je lis une deuxième ligne de nouveau avec un nextLine()
que je mets donc dans l'initialisation d'une variable s2.
Donc, l'idée est ici de lire un entier,
puis de lire la fin de la ligne, puis de lire encore une ligne entière.
Donc par exemple,
si on tape le message 25 francs, retour à la ligne, suivi de 23 francs.
Ce qui va se passer, c'est qu'on va d'abord lire un entier.
Donc i contiendra 25.
Puis ensuite, on va lire la fin de la ligne, ici donc jusqu'à francs.
Donc s1 contiendra effectivement francs.
Puis enfin, on lira toute une ligne ici donc on lira 23 francs.
Jusque là, pas de problème.
Par contre, si on tape la séquence suivante, 14, euros,
43, qu'est-ce qui se passe?
Regardons pas à pas.
Tout d'abord, on demande donc de lire un entier.
On va donc lire ici l'entier 14 et i contiendra bien 14.
Ensuite, on demande de lire la fin de la ligne.
Ici, on va donc aller lire la fin de la ligne.
La fin de la ligne, elle est ici.
Elle est vide et donc effectivement s1 sera vide.
Parce qu'on a demandé de lire une fin de ligne.
Puis ensuite, on ira lire la ligne suivante.
Et donc, la ligne suivante ici euros ira dans s2.
Et donc, s2 contiendra euros.
Donc, ce qui se passe ici,
c'est qu'on voit que la combinaison d'un nextInt() suivi d'un
nextLine() lorsqu'on lit au clavier, ne fonctionne toujours pas très bien.
En particulier, parce que l'utilisateur a tapé un retour à la ligne ici derrière
le nombre entier ici 14.
Et donc, la lecture comme cela d'un nextLine() après un nextInt() tapé au
clavier va aller lire ici la fin de la ligne qui correspond au retour à la ligne,
à la touche return qu'a tapé l'utilisateur, parce que nextInt() arrête
sa lecture juste après un nombre entier, ici 14 et ne lit pas nextInt(),
en tant que tel lui-même, ne lit pas le caractère de retour, la touche return.
Donc, comment faire en pratique?
Eh bien, chaque fois que vous avez comme cela besoin de lire un nombre avec
nextInt() ou nextDouble() et puis que la lecture suivante doit lire une ligne,
ce qu'il faut, c'est anticiper donc la non lecture du retour à la ligne par nextInt()
ou nextDouble() en rajoutant donc ici une lecture de cette fin de ligne.
Avec un nextLine() supplémentaire inséré
ici entre la lecture d'un entier ou d'un nombre décimal,
nextInt(), nextDouble() et la lecture du message suivant que vous voulez vraiment.
Vous rajoutez ici une lecture dans une variable que vous auriez bien sûr
déclaré au préalable.
Donc, String s = keyb.nextLine(), point-virgule.
On pourra bien sûr plus tard,
lorsque l'on connaîtra les structures de contrôles et en particulier les
branchements conditionnels ou les boucles conditionnelles,
vérifier qu'effectivement cette lecture ici de s a bien lu une chaîne vide.
Et si ce n'est pas le cas la prendre comme le message à lire.
Et si c'est le cas,
prendre la prochaine lecture comme étant le message que l'on désire.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
