De nombreux traitements informatiques peuvent se schématiser suivant
les trois étapes suivantes:
Pour bien comprendre le sens des termes lecture, traitement et affichage,
mettez vous à la place de l'ordinateur.
Votre rôle est d'additionner mentalement deux nombres pour un sourd-muet qui ne sait pas calculer
(l'utilisateur).
Comme il ne peut pas parler, il vous écrit les deux nombres à additionner sur un bout de papier,
qui joue le role de l'écran.
Vous ne pouvez pas additionner les deux nombres si vous ne les connaissez pas.
Il faut donc commencer par les lire. C'est la première étape de lecture des données.
A présent, les deux nombres à additionner sont dans votre mémoire. Vous pouvez donc effectuer le traitement,
qui consiste à additionner mentalement ces deux nombres.
C'est l'étape de traitement des données.
Vous avez le résultat. Mais si vous ne le communiquez pas à l'utilisateur, c'est comme si vous n'aviez
rien fait. Comme il est sourd vous allez écrire le résultat sur le bout de papier. C'est la troisième étape:
l'affichage des résultats du traitement.
Pour un ordinateur c'est un peu la même chose:
- Lire les données signifie transférer des informations affichées à l'écran vers la mémoire, ou plus
précisémment vers une variable-donnée, c'est à dire
une variable prévue pour stocker une donnée du traitement.
- Traiter les données signifie grosso-modo faire des calculs qui dépendent des
données pour produire des résultats. En principe, mais ce n'est pas obligatoire,
chaque résultat est stockée dans une variable-résultat. La programmation de cette étape
sera vue plus loin dans le cours lorsque nous parlerons d'expression et d'affectation.
- Si les résultats ont été sauvegardés dans des variables résultats,
Afficher les résultats signifie afficher la valeur de chacune de ces variables
à l'écran. Il est également possible d'afficher les résultats d'un traitement sans les avoir
au préalable sauvegardés dans des variables. Mais il serait difficile pour l'instant d'expliquer comment.
Nous verrons cela un peu plus loin.
Reprenons l'exemple de l'addition de deux nombres.
Lire les données signifierait dans ce cas lire les valeurs des deux nombres à additionner
depuis (par exemple) deux champs de texte pour les stocker dans deux variables données X et Y.
Traiter les données signifierait additionner les valeurs des variables X et Y,
puis mémoriser
le résultat dans une variable Somme.
Enfin, afficher les résultats signifierait afficher la valeur de la variable somme dans
le champ de texte prévu à cet effet.
Avant l'apparution des interfaces graphiques, tous les langages de programmation
avaient des 'instructions'
(il ne s'agit pas réellement d'instructions, mais de procédures. Cette notion sera abordée dans le cours sur les
sous-programmes)
pour lire et afficher.
En Pascal, par exemple, elles s'appellent readln (pour la lecture) et
writeln (pour l'écriture).
L'instruction writeln, vous permettait d'afficher un texte à l'écran. Par exemple l'instruction:
writeln ('Hello world !');
vous affichait le texte 'Hello Word' à l'écran, comme ceci (en supposant que l'écran soit vide avant
l'exécution de l'instruction):
Avec writeln, vous pouviez également afficher la valeur d'une variable
à l'écran. Par exemple, en supposant que la variable Somme contienne la valeur 2013,
l'instruction:
writeln (Somme);
vous affichait 2013 à l'écran, comme ceci:
Chaque writeln, affichait donc une nouvelle ligne à la suite des lignes déjà affichées à l'écran.
L'instruction readln permettait de lire la valeur
d'une variable tapée au clavier (et donc affichée à l'écran).
Supposons par exemple qu'un programme exécute l'instruction suivante:
readln (X);
où X représente un nombre entier.
Dès que l'instruction est exécutée, le programme est momentanément interrompu.
Le système d'exploitation prend alors la main et range chaque caractère saisi par l'utilisateur dans un
buffer
associé au clavier. Dès que l'utilisateur appuie sur la touche Entrée le contenu
du buffer est renvoyé au programme qui stocke alors la valeur correspondante dans la variable X et
continue son exécution.
JavaETBib est une librairie Java que j'ai écrite afin d'introduire des 'instructions'
(il faudrait plutot parler de sous-programmes, nous reviendrons là-dessus dans le cours
consacré à cette notion) équivalentes
à readln et writeln fonctionnant avec une interface graphique.
Ce sont les instructions suivantes:
- es.Lire, es.LireEntier et
es.LireDouble : pour lire une variable depuis un champ de texte.
- es.Afficher, pour afficher une variable dans un champ
de texte ou une zone de texte.
- es.AfficherMessage, pour afficher une variable de type
chaine de caractères dans une boite de dialogue.
- es.Effacer pour effacer le contenu d'un champ de texte ou d'une zone de texte.
Ces 'instructions' ont été introduites pour des raisons pédagogiques
(explications pour le lecteur averti).
Donc gardez bien à l'esprit qu'elles ne font pas partie du langage Java.
Pour expliquer le fonctionnement des 'instructions' de JavaETBib, nous allons prendre un exemple
de programme: le projet Population. Si vous avez téléchargé les exemples de ce cours,
vous trouverez ce projet dans le dossier
Exemple-Java-Premieres-Notions/Population.
Il s'agit d'un programme qui permet de lire et d'afficher trois variables:
- Ville de type String, est destinée à contenir le nom d'une ville.
Sa valeur sera lue et affichée dans le champ de texte CT_Ville.
- CP de type int pour le code postal de la ville,
lue et affichée dans le champ de texte CT_CodePostal.
- NH de type double pour le nombre d'habitants de la ville
exprimé en milliers. Remarquez que ce nombre n'est pas forcément entier : 264.2 représente par exemple
264200 habitants.
Le champ de texte correspondant se nomme CT_Hab.
Voici l'interface graphique du programme :
Nous verrons ici le fonctionnement des quatres premiers boutons. Celui du bouton Afficher phrase sera
vu ultérieurement lorsque nous aborderons
l'affichage d'expressions.
La lecture des trois variables est déclenchée par le bouton Lire. Voici la procédure évènementielle associée:
private void BT_LireActionPerformed
(java.awt.event.ActionEvent evt) {
Ville = es.Lire(CT_Ville);
NH = es.LireDouble(CT_Hab);
CP = es.LireEntier(CT_CodePostal);
}
L'instruction de lecture à utiliser dépend du type de la variable: es.Lire pour lire une variable
de type String,
es.LireEntier pour lire une variable de type int et es.LireDouble pour lire
une variable de type Double.
Entre parenthèses figure le nom du champ de texte. A gauche du signe = figure le nom de la variable.
Rappelez vous que chaque champ de texte est associé à un
buffer qui
se rempli avec les caractères frappés au clavier.
Lorsque la variable est de type chaine de caractères, l'instruction de lecture ne fait que recopier ces
caractères dans la variable.
S'il s'agit d'une variable de type int ou double, il ne suffit pas de
recopier le buffer dans la variable.
Le contenu du buffer est tout d'abord codé en
base 2,
puis c'est le résultat de ce codage qui est stocké dans la variable.
Le bouton Afficher permet d'afficher les valeurs des trois variables dans les champs de texte.
Voici la procédure évènementielle associée:
private void BT_AfficherActionPerformed
(java.awt.event.ActionEvent evt) {
es.Afficher(Ville, CT_Ville);
es.Afficher(CP, CT_CodePostal);
es.Afficher(NH, CT_Hab,1);
}
Contrairement à la lecture, il n'est pas nécessaire de choisir l'instruction d'affichage
en fonction du type de la variable. es.Afficher permet aussi bien d'afficher
une variable de type String, int
ou double.
Dans les parenthèses, on précise le nom de la variable à afficher, puis le nom du champ de texte dans lequel
on souhaite l'afficher.
Remarquez que pour une variable numérique de type double, il est possible
(mais non obligatoire) de préciser le nombre de chiffres après la virgule. Dans notre exemple l'instruction:
es.Afficher(NH, CT_Hab,1);
affiche le nombre d'habitant avec un chiffre après la virgule. Mais on aurait très bien pu ne pas préciser
le nombre de chiffres après la virgules, en écrivant:
es.Afficher(NH, CT_Hab);
Si la variable est de type String,
la procédure es.Afficher recopie simplement le contenu de la variable dans le buffer
qui est ensuite affiché
dans le champ de texte par le système d'exploitation.
Dans le cas contraire, un décodage préalable est
nécessaire avant de recopier
la chaine de caractères représentant le nombre dans le buffer.
Dans certaines circonstances, il peut être utile d'afficher des informations en dehors de la fenêtre de
l'application, dans une fenêtre séparée ou plus précisément dans une boite de dialogue.
Vous pouvez réaliser ceci avec l'instruction es.AfficherMessage.
Dans l'exemple du projet Population, elle est utilisée dans la procédure évènementielle
associée au bouton
Afficher Ville. Si la variable Ville contient "Strasbourg", le résultat sera le suivant:
La boite de dialogue disparait dès que l'utilisateur clique sur le bouton OK.
Voici le code de la procédure évènementielle associée au bouton Afficher Ville:
private void BT_AfficherVilleActionPerformed
(java.awt.event.ActionEvent evt) {
es.AfficherMessage (Ville) ;
}
Dans les parenthèses, on précise donc le nom de la variable à afficher.
Attention: cette variable doit être obligatoirement de type chaine de caractères.
L'effacement des champs de texte s'effectue avec le bouton Effacer dont voici la procédure
évènementielle:
private void BT_EffacerActionPerformed
(java.awt.event.ActionEvent evt) {
es.Effacer(CT_Ville);
es.Effacer(CT_Hab);
es.Effacer(CT_CodePostal);
}
Il suffit ici de préciser entre parenthèse le nom du champ de texte à effacer.
Cette section s'adresse au lecteur averti désirant comprendre
la raison pour laquelle j'ai introduit les procédures de lecture et d'affichage
de la librairie JavaETBib.
Reprenons notre exemple. Voici comment lire les trois variables sans utiliser
les procédures es.Lire, es.LireEntier et es.LireDouble:
private void BT_LireActionPerformed
(java.awt.event.ActionEvent evt) {
Ville = CT_Ville.getText();
CP = Integer.parseInt(CT_CodePostal.getText());
NH = Double.parseDouble(CT_Hab.getText());
}
Ce qui me gène ici (mise à part la lourdeur évidente du code) est l'utilisation
obligatoire de la programmation objet.
Pour lire la valeur d'un champ de texte, il faut appliquer la méthode getText
de la classe JTextField à un objet de cette classe. De plus, lorsque l'on souhaite affecter la valeur
lue à une variable de type numérique, il faut effectuer une conversion à l'aide des méthodes
parseInt de la classe Integer ou parseDouble de la classe Double.
Le problème est le même pour l'affichage.
Or, je pense que l'on peut difficilement commencer un cours de programmation avec des
notions de programmation objet. A mon sens la programmation objet, ne peut être abordée qu'après avoir bien
assimilé les types (puisque les classes sont en quelque sorte des types étendus)
et les sous-programmes (puisque les méthodes sont des sous-programmes associés à des classes).
Mis à part la programmation objet, d'autres arguments peuvent être ajoutés
en faveur de l'utilisation des procédures de lecture et d'affichage:
- cela rend le code plus lisible.
- cela oblige les étudiants à programmer plus proprement: les données doivent obligatoirement
être transférées dans des variables avant d'être utilisées. On ne travail pas directement sur
les champs de texte pour faire des calculs.