Cours pour commencer le JAVA


Télécharger Cours pour commencer le JAVA
1.51.5 étoiles sur 5 a partir de 2 votes.
Votez ce document:

Télécharger aussi :


Chapitre 2

L’essentiel pour commencer

L’objectif de ce chapitre est de vous donner les bases du langage Java vous permettant d’e´crire vos propres programmes. Nous y passons donc rapidement en revue les e´le´ments de base du langage Java, en vous expliquant a quoi ils servent` et comment ils s’ecrivent´ . Nous ne serons e´videmment pas exhaustifs, c’est pourquoi les notions abordeés dans ce chapitre feront l’objet soit de chapitres particuliers dans la suite du cours, soit d’annexes dans les notes.

Pour illustrer notre propos, nous allons reprendre l’exemple de la conversion d’une somme des euros vers les francs :

Probleme` : Calculer et afficher la conversion en francs d’une somme en euros saisie au clavier.

Listing 2.1 – (lien vers le code brut)

public class Conversion { public stat ic void main ( String [ ] args ) { double euros , francs ;

Terminal . e c r i r e S t r i n g l n ( ”Somme en euros ? ” ) ; euros = Terminal . lireDouble ( ) ; francs = euros ? 6.559;

                         Terminal . e c r i r e S t r i n g l n ( ”La somme en          francs : ”+         francs ) ;

}

}

2.1  Structure gen´ erale d’un programme Java´

Ce programme a un squelette identique a` tout autre programme Java. Le voici :

Listing 2.2 – (pas de lien)

public class . . . { public stat ic void main ( String [ ] args ) {

. . . .

}

}

Autrement dit :

1

–    Tout programme Java est compose´ au minimum d’une classe (mot-cle´ class) dite principale, qui elle meˆme, contient une methode´ de nom main (c’est aussi un mot-cle´). Les notions de classe et de methode´ seront abordeés plus tard.

–    public, class, static, void, main : sont des mots reserve´s c’est a` dire qu’ils ont un sens particuliers pour Java. On ne peut donc pas les utiliser comme nom pour des classes, des variables, etc

–    La classe principale : celle qui contient la me´thode main. Elle est de´clareé par public classNomclasse C’est vous qui choisissez le nom de la classe.

Le code qui de´finit une classe est de´limite´ par les caractères { et }

–    Nom du programme : Le nom de la classe principale donne son nom au programme tout entier et doit eˆtre e´galement celui du fichier contenant le programme, comple´te´ de l’extension .java

–    La methode´ main: obligatoire dans tout programme Java : c’est elle qui “commande” l’exe´cution. De´finie par une suite de de´clarations et d’actions de´limiteés par { et }. Pour l’instant, et jusqu’a` ce que l’on sache de´finir des sous-programmes, c’est ici que vous e´crirez vos programmes.

Autrement dit, pour e´crire un programme que vous voulez appeler "truc",ouvrez un fichier dans un e´diteur de texte, appelez ce fichier ""; Ecrivez dans ce fichier le squelette donne´ plus haut, puis remplissez les :

2.2    comprendre le code

Le programme Java exprime la chose suivante dans le langage Java (c’est-a`-dire au moyen de phrases comprises par le compilateur Java) :

(ligne 4 :) de´clarer 2 variables appeleés euros et francs destineés a` contenir des reéls puis

(ligne 6 :) afficher a` l’e´cran la phrase Somme en euros? : puis

(ligne 7 :) re´cupe´rer la valeur entreé au clavier et la stocker dans la variable euros, puis

(ligne 8 :) Multiplier la valeur de la variable euros par 6.559 et stocker le re´sultat de ce calcul dans la variable francs, puis

(ligne 9 :) afficher a` l’e´cran la valeur de francs

La premie`re chose importante a` remarquer est que pour e´crire un programme, on e´crit une suite d’ordres se´pare´s par des ;. L’exe´cution du programme se fera en exe´cutant d’abord le premier ordre, puis le second, etc. C’est ce qu’on appelle le principe de sequentialit´ e de l’ex´ ecution´ .

Dans ce programme on a trois cate´gories d’ordres :

–    des de´clarations de variables. Les de´clarations servent a` donner un nom a` une case me´moire, de fac¸on a pouvoir y stocker, le temps de l’exe´cution du programme, des valeurs. Une fois qu’une variable est de´clareé et qu’elle posse`de une valeur, on peut consulter sa valeur.

–    des instructions d’entreé-sortie. Un programme a bien souvent (mais pas toujours) besoin d’informations pour lui viennent de l’exte´rieur. Notre programme calcule la valeur en francs d’une somme en euros qui est donnee au moment de l’ex´ ecution´ par l’utilisateur. On a donc besoin de dire qu’il faut faire entrer dans le programme une donneé par le biais du clavier. Il y a en Java, comme dans tout autre langage de programmation, des ordres pre´de´finis qui permettent de faire cela (aller chercher une valeur au clavier, dans un fichier, sortir du programme vers l’e´cran ou un fichier une valeur etc ).

–    l’instruction d’affectation (=) qui permet de manipuler les variables de´clareés. Elle permet de

mettre la valeur de ce qui est a droite de = dans la variable nommeé a` gauche du =.

2.3. LESVARIABLES

2.3    Les variables

Les variables sont utiliseés pour stocker les donneés du programme. A chaque variable correspond un emplacement en memoire´ , ou` la donneé est stockeé, et un nom qui sert a` de´signer cette donneé tout au long du programme.

Une variable doit eˆtre de´clareé dans le programme. On peut alors consulter sa valeur ou modifier sa valeur.

2.3.1    declaration´

Nous avons de´ja` vu une de´claration : double euros, francs;

Cette de´claration de´clare 2 variables a` la fois de nom respectif euros et francs. La forme la plus simple de de´claration de variables est la de´claration d’une seule variable a` la fois. On aurait pu remplacer notre de´claration pre´ce´dente par celles ci :

double euros; double francs;

Ici, on de´clare d’abord la variable francs puis la variable euros.

le nom des variables

euros ou francs sont les noms des variables et ont donc e´te´ choisis librement par l’auteur du programme. Il y a cependant quelques contraintes dans le choix des symboles constituant les noms de variables. Les voici :

–    Les noms de variables sont des identificateur c’est a` dire commencent ne´cessairement par une lettre, majuscule ou minuscule, qui peut eˆtre ou non suivie d’autant de caracte`res que l’on veut parmi l’ensemble a z, A Z, 0..9, _, $ Unicode.

–    Un nom de variable ne peut pas eˆtre un mot reserve´ : (abstract, boolean, if, public, class, private, static, etc).

–    Certains caracte`res ne peuvent pas apparaˆ?tre dans un nom de variable (ˆ, [, ], {, +, -,

).

Exemples : a, ida et X1 sont des noms de variables valides, alors que 1X et X-X ne le sont pas.

le type de la variable

Dans notre exemple de de´claration double euros;, le mot double est le nom d’un type pre´de´fini en Java. Un type est un ensemble de valeurs particulie`res connues de la machine. Nous allons pendant quelques temps travailler avec les types java suivants :

–    Le type int de´signe l’ensemble de tous les nombres entiers repre´sentables en machine sur 32 bits (31 plus le signe) {?231, ,231}. Les e´le´ments de cet ensemble sont 0, 1, 2

–    le type double de´signe les reéls (a` pre´cision double 64 bits). Les e´léments de cet ensemble sont 0.0, 0.1, 18.58

–    Le type boolean mode´lise les deux valeurs de ve´rite´ dans la logique propositionnelle. Ses e´le´ments sont true (vrai) et false (faux).

–    Le type char mode´lise l’ensemble des caracte`res Unicode (sur 16 bits). Ses e´le´ments sont des caracte`res entoure´s de guillemets simples, par exemple : ‘a‘, ‘2‘, ‘@‘;

–    le type string mode´lise les chaˆ?nes de caracte`res. Ses e´le´ments sont les suites de caracte`res entoureés de guillemets doubles : "coucou", "entrer une somme en euros :?", "a"

syntaxe des declarations de variables´

Ainsi, pour de´clarer une variable, il faut donner un nom de type parmi int, double, char, boolean, string suivi d’un nom de variable que vous inventez.

Pour de´clarer plusieurs variables de meˆme type en meˆme temps, il faut donner un nom de type suivi des noms de vos variables (se´pare´s par des virgules).

C’est ce qu’on appelle la syntaxe Java des de´clarations de variables. Il faut absolument se conformer a` cette re`gle pour de´clarer des variables en Java, faute de quoi, votre code ne sera pas compris par le compilateur et produira une erreur. Ainsi, int x; string "coucou" sont corrects alors que entier x; ou encore x int; seront rejete´s.

Execution des declarations de variables´

L’exe´cution d’un programme, rapellons le, consiste en l’exe´cution successive de chacune de ses instructions.

Que se passe-t-il lorsqu’une de´claration est rencontreé ? Une place me´moire libre de taille suffisante pour stocker une valeur du type de la variable est rechercheé, puis le nom de la variable est associe´ a cette case me´moire. Ainsi, dans la suite du programme, le nom de la variable pourra eˆtre utilise´ et de´signera cet emplacement me´moire.

Une question un peu subtile se pose : combien de temps cette liaison entre le nom de la variable et la case me´moire est elle valable ? Autrement dit, jusqu’à quand la variable est-elle connue ? Pour l’instant, nous pouvons re´pondre simplement : cette liaison existe durant l’exe´cution de toutes les instructions qui suivent la de´claration de la variable et jusqu’a` la fin du programme.

Cette notion (la porteé des variables) se compliquera lorsque nous connaˆ?trons plus de choses en Java, notamment la notion de bloc. Nous y reviendrons a` ce moment la`.

2.3.2   Affecter une valeur a une variable`

Une fois qu’une variable a e´te´ declareé, on peut lui donner une valeur, c’est a` dire mettre une valeur dans la case me´moire qui lui est associeé. Pour cela, il faut utiliser l’instruction d’affectation dont la syntaxe est nomvariable = expression ; par exemple x=2;

Il est de bonne habitude de donner une valeur initiale a` une variable de`s qu’elle est de´clareé. Java nous permet d’affecter une valeur a` une variable au moment de sa de´claration : par exemple int x=2;

Des valeurs du bon type

A droite de =, on peut mettre n’importe quelle valeur du bon type, y compris des variables. Comme 2 est une valeur du type int, notre exemple ne sera possible que si plus haut dans notre programme,

2.3. LESVARIABLES

on a la de´claration int x;.

Les expressions

Les valeurs ne sont pas force´ment simples, elles peuvent eˆtre le re´sultat d’un calcul. On pourrait par exemple e´crire x=(18+20)*2;. On peut e´crire l’expression (18+20)*2 car + et * sont des operateurs´ connus dans le langage Java, de´signant comme on s’y attend l’addition et la multiplication et que ces ope´rateurs, applique´s a` des entiers, calculent un nouvel entier. En effet, 18+20 donne 38 (un entier) et 38×2 donne 76 qui est un entier.

–    Pour construire des expressions arithme´tiques, c’est a` dire des expressions dont le re´sultat est de type int ou double on peut utiliser les ope´rateurs :+,-,*,/,%(reste de la division entière)

–    Pour construire des expressions booleénnes (i.e dont le re´sultat est de type boolean, on peut utiliser les ope´rateurs : &&(et), || (ou), !(non).

–    Les ope´rateurs de comparaison permettent de comparer deux valeurs ou expressions toutes les deux de de type nume´rique ou char et renvoient une valeur booleénne en re´sultat.

== (egalite´), < (plus petit), > (plus grand), >= (plus grand ou e´gal), <= (plus petit ou e´gal), != (diffe´rent).

Execution d’une affectation´

L’exe´cution d’une affectation se fait en deux temps :

1.    On calcule le re´sultat de l’expression a droite` de = (on dit e´valuer l’expression). Si c’est une valeur simple, il n’y a rien a faire, si c’est une variable, on va chercher sa valeur, si c’est une expression avec des ope´rateurs, on applique les ope´rateurs a` leurs arguments. Cela nous donne une valeur qui doit eˆtre du meˆme type que la variable a` gauche de =.

2.    On met cette valeur dans l’emplacement me´moire associe´ a` la variable a gauche`           de =.

C’est ce qui explique que l’on peut e´crire le programme suivant :

Listing 2.3 – (lien vers le code brut)

public class es sai Vari able { public stat ic void main ( String [ ] args ) {

int x ; int y ;

y=2; x=y+5; x=x+2;

}

}

Les lignes 3 et 4 de´clarent les variables x et y. Elle sont donc connues dans la suite du programme. Puis (l5) la valeur 2 est donneé a` y. Ensuite est calcule´ y+5. La valeur de y en ce point de l’exe´cution est 2 donc y+5 vaut 7. A l’issue de l’exe´cution de la ligne 6, x vaut 7. Finalement, (l7), on e´value x+2. x a` ce moment vaut 7 donc x+2 vaut 9. On donne a` x la valeur 9.

Cet exemple illustre le fait qu’une variable peut (puisque l’exe´cution d’un programme est se´quentielle) avoir plusieurs valeurs successives (d’ou` son nom de variable), et que l’on peut faire apparaˆ?tre une meˆme variable a` gauche et a` droite d’une affectation : on met a` jour son contenu en tenant compte de la valeur qu’elle contient juste avant.

2.4   Les appels de methodes pr´ ed´ efinies´

Revenons a` notre exemple de de´part, la conversion en francs d’une somme en euros. Nous avions explique´ que les lignes 6 et 7 du programme effectuaient des ope´rations d’entreé sortie. Nous allons analyser cela plus en de´tail.

2.4.1    La methode´ Terminal.ecrireStringln

La ligne 6 donne l’ordre d’afficher a` l’e´cran le message somme en euros? :

Elle le fait en utilisant un programme tout fait que nous avons e´crit pour vous. On appelle cela en Java une methode´ .

Ce programme s’appelle ecrireStringln. Il fait partie de la classe Terminal.

A condition d’avoir copie´ le fichier Terminal.javacontenant cette classe dans votre re´pertoire de travail, vous pourrez utiliser autant de fois que vous le de´sirez cette me´thode. Utiliser une me´thode existante dans un programme s’appelle faire un appel de la me´thode.

Pour fonctionner, cette me´thode a besoin que l’utilisateur, lorsqu’il l’utilise, lui transmette une information : la chaˆ?ne de caracte`re qu’il veut afficher a` l’e´cran. Cette information transmise par l’utilisateur de la me´thode est ce qui se trouve entre les parenthe`ses qui suivent le nom de la me´thode. C’est ce qu’on appelle l’argument ou le parametre` de la me´thode.



On a ici utilise´ Terminal.ecrireStringlnpour afficher le message Somme en euros? :

en faisant l’appel Terminal.ecrireStringln("Somme en euros? :);

Pour afficher coucou, il faut faire l’appel Terminal.ecrireStringln("coucou").

Lors d’un appel, vous devez ne´cessairement transmettre une et une seule chaˆ?ne de caracte`re de votre choix a` Terminal.ecrireStringln: c’est l’auteur de la me´thode qui a fixe´ le nombre, le type et l’ordre des arguments de cette me´thode, lorsqu’il l’a e´crit. Ainsi on ne pourra e´crire Terminal.ecrireStringln( ni Terminal.ecrireStringln("coucou","bidule"). Ces 2 lignes provoqueront des erreurs de compilation.

2.4.2    La methode´ Terminal.lireInt

La ligne 7 donne l’ordre de re´cupe´rer une valeur au clavier.

euros=Terminal.lireDouble();

Cette ligne est une affectation =. On trouve a` droite du = un appel de me´thode.

La me´thode appeleé s’appelle lireDouble et se trouve dans la classe Terminal.

2.4. LESAPPELSDEMETHODESPR´  ED´ EFINIES´

Le fait qu’il n’y ait rien entre les parenthe`ses indique que cette me´thode n’a pas besoin que l’utilisateur lui fournisse des informations. C’est une me´thode sans arguments.

En revanche, le fait que cet appel se trouve a` droite d’une affectation indique que le re´sultat de son exe´cution produit un re´sultat (celui qui sera mis dans la variable euros). En effet, ce re´sultat est la valeur provenant du clavier. C’est ce qu’on appelle la valeur de retour de la me´thode.

Comme pour les arguments de la me´thode, le fait que les me´thodes retournent ou pas une valeur est fixe´ par l’auteur de la me´thode une fois pour toutes. Il a fixe´ aussi le type de cette valeur de retour. Une me´thode, lorsqu’elle retourne une valeur, retourne une valeur toujours du meˆme type. Pour lireDouble, cette valeur est de type Double.

Lorsqu’ils retournent un re´sultat, les appels de me´thode peuvent figurer dans des expressions.

Exemple : La me´thode :prends 2 arguments de type int et retourne une valeur de type

int : le plus petit de ses deux arguments. Ainsi l’instruction x = 3 + ((4,10) + 2); donne a` x la valeur 9 car 3+(4+2) vaut 9.

L’instruction x = 3 + (Terminal.lireInt() + 2); a aussi un sens. Elle s’exe´cutera de la fac¸on suivante : Pour calculer la valeur de droite, l’exe´cution se mettra en attente qu’une touche du clavier soit presseé (un curseur clignotant a l’e´cran indiquera cela). De`s que l’utilisateur presse une touche, le calcul de Terminal.lireInt() se termine avec pour re´sultat cette valeur. Imaginons que l’utilisateur ait presse´ 6. 3+6+2 donne 11. La valeur de x sera donc 11.

Que se passera-t-il si l’utilisateur presse une touche ne correspondant pas a` un entier ? Une erreur se produira, et l’exe´cution du programme tout entier sera arreˆteé. Nous verrons plus tard qu’il y a un moyen de re´cupe´rer cette erreur pour relancer l’exe´cution.

2.4.3   Les appels de methodes en g´ en´ eral´

De nombreuses classes contenant des me´thodes existent en Java, soit dans la bibliothe`que commune au langage, soit dans des re´pertoires particulier qu’il faut alors indiquer (nous verrons cela plus tard).

Toute me´thode existante posse`de un nom, appartient a` une classe, posse`de des arguments dont le nombre le type et l’ordre sont fixe´s. Une me´thode peut renvoyer une valeur ; le type de la valeur de retour est alors fixe´.

On trouve ces informations dans la documentation associeé aux classes. Pour Terminal.ecrireStringln ces informations seraient donneés de la fac¸on suivante :

void ecrireStringln(String ch) : void avant le nom indique que cette me´thode ne renvoie pas de re´sultat, (String ch) indique qu’elle a un seul argument de type String. double lireDouble(): double avant le nom indique que cette me´thode renvoie un re´sultat de type Double, () indique qu’elle a n’a pas d’argument Pour la me´thode min de la classe Math on trouverait :

int min(int a, int b) :prends 2 arguments de type int et retourne une valeur de type int : le plus petit de ses deux arguments.

Pour appeler une me´thode, il faut connaˆ?tre toutes ces informations. l’appel de me´thode sera conforme a` la syntaxe suivante :

NomClasse.NomMethode(arg1, ,argn);

Ainsi, on peut voir un sous-programme comme une boˆ?te noire capable de re´aliser des traitements sur les arguments ou entreés du sous-programme. Si l’on de´sire effectuer les traitements, on invoque ou appelle le sous-programme en lui passant les donneés a` traiter, qui peuvent varier pour chaque appel. En sortie on obtient : ou bien une valeur, re´sultat des calculs effectue´s, ou bien un changement dans l’etat de la machine´ appele´ aussi effet ; parfois, les deux.

Sous-programme

traitements sur les parame`tres

parametre1 ??

parametre2 ??==> Valeur re´sultat                              et/ou    Effet

2.5   Les methodes pr´ ed´ efinies d’entr´ ee-sortie´

Disons maintenant quelques mots sur les me´thodes d’entreé-sortie.

Java est un langage qui privile´gie la communication par interfaces graphiques. En particulier, la saisie des donneés est ge´reé plus facilement avec des feneˆtres graphiques de´dieés, des boutons, etc. Mais, pour de´buter en programmation, il est beaucoup plus simple de programmer la saisie et l’affichage des donneés au terminal : la saisie a` partir du clavier et l’affichage a` l’e´cran. Nous vous proposons de suivre cette approche en utilisant la bibliothe`que Terminal.

La bibliotheque` Terminal

La classe Terminal (e´crite par nous), regroupe les principales me´thodes de saisie et d’affichage au terminal pour les types prede´finis que nous utiliserons dans ce cours : int, double, boolean, char et String. Le fichier source , doit se trouver pre´sent dans le meˆme re´pertoire que vos programmes. Pour l’employer, il suffit de faire appel a` la me´thode qui vous inte´resse pre´ce´de´ du nom de la classe. Par exemple, Terminal.lireInt() renvoie le premier entier saisit au clavier.

Saisie avecTerminal : Se fait toujours par un appel de me´thode de la forme :

Type();

ou` Type est le nom du type que l’on souhaite saisir au clavier. La saisie se fait jusqu’a` validation par un changement de ligne. Voici la saisie d’un int dans x, d’un double dans y et d’un char dans c :

int x; double y; char c; // Declarations x = Terminal.lireInt(); y = Terminal.lireDouble(); c = Terminal.lireChar();

Me´thodes de saisie dansTerminal :

–    Terminal.lireInt()

2.5. LESMETHODESPR´ ED´ EFINIESD’ENTR´ EE-SORTIE´

–    Terminal.lireDouble()

–    Terminal.lireChar()

–    Terminal.lireBoolean()

–    Terminal.lireString()

Affichage avec Terminal : Les me´thodes d’affichage traitent les meˆmes types que celles de lecture.

Il y a deux formats d’affichage :

–    Terminal.ecrireType(v); affiche la valeur v qui doit eˆtre du type indique´ par le nom de la me´thode.

–    Terminal.ecrireTypeln(v); affiche comme avant plus un saut a` la ligne.

Terminal.ecrireInt(5);

Terminal.ecrireInt(’a’);

Terminal.ecrireIntln(5);

Terminal.ecrireDoubleln(1.3);

Ce programme affiche :

5a5

5

1.3

L’affichage de messages, ou chaˆ?nes de caracte`res (type String), autorise l’adjonction d’autres messages ou valeurs en utilisant l’ope´rateur de concatenation´ +.

Terminal.ecrireString("bonjour " + 5 + 2 ); ---> affiche: bonjour 52

Terminal.ecrireString("bonjour " + (5 + 2) ); ---> affiche: bonjour 7 Terminal.ecrireString(5 + 2); ---> Erreur de Typage!

Me´thodes d’affichage :

–    Terminal.ecrireInt(n);

–    Terminal.ecrireDouble(n);

–    Terminal.ecrireBoolean(n); – Terminal.ecrireChar(n);

–    Terminal.ecrireString(n);

–    Terminal.ecrireIntln(n); – Terminal.ecrireDoubleln(n)

Affichage avec la bibliotheque` System

La bibliothe`que Systempropose les meˆmes fonctionnalite´s d’affichage au terminal pour les types de base que notre bibliothe`que Terminal. Elles sont simples d’utilisation et assez fre´quentes dans les ouvrages et exemples que vous trouverez ailleurs. Nous les pre´sentons brie`vement a` titre d’information.

–    .print : affiche une valeur de base ou un message qui lui est passe´ en parame`tre.

.print(5); ---> affiche 5

.print(bonjour); ---> affiche le contenu de bonjour

.print("bonjour"); ---> affiche bonjour

Lorsque l’argument passe´ est un message ou chaˆ?ne de caracteres` , on peut lui joindre une autre valeur ou message en utilisant l’ope´rateur de concatenation´ +. Attention si les ope´randes de + sont exclusivement nume´riques, c’est leur addition qui est afficheé!

.print("bonjour " + 5 ); ---> affiche: bonjour 5

.print(5 + 2); ---> affiche 7

–    .println: Meˆme comporte´ment qu’avant, mais avec passage a` la ligne en fin d’affichage.

2.6    Conditionnelle

Nous voudrions maintenant e´crire un programme qui, e´tant donne´ un prix Hors Taxe (HT) donne´ par l’utilisateur, calcule et affiche le prix correspondant TTC.

Il y a 2 taux possible de TVA : la TVA normale a` 19.6% et le taux re´duit a` 5.5%. On va demander aussi a` l’utilisateur la cate´gorie du taux qu’il faut appliquer.

donnees´

–    entreé : un prix HT de type double (pHT), un taux de type int (t) (0 pour normal et 1 pour re´duit)

–    sortie : un prix TTC de type double (pTTC) algorithme

1.    afficher un message demandant une somme HT a` l’utilisateur.

2.    recueillir la re´ponse dans pHT

3.    afficher un message demandant le taux (0 ou 1).

4.    recueillir la re´ponse dans t

5.    2 cas :

(a)    Cas 1 :le taux demande´ est normal pTTC= pht+ (pht*0.196)

(b)    Cas 2 :le taux demande´ est re´duit pTTC= pht+ (pht*0.05)

6.    afficher pTTC

Avec ce que nous connaissons de´ja` en Java, nous ne pouvons coder cet algorithme. La ligne 5 pose proble`me : elle dit qu’il faut dans un certain cas exe´cuter une taˆche, et dans l’autre exe´cuter une autre taˆche. Nous ne pouvons pas exprimer cela en Java pour l’instant, car nous ne savons qu’exe´cuter, les unes apre`s les autres de fac¸on inconditionnelle la suite d’instructions qui constitue notre programme.

Pour faire cela, il y a une instruction particulie`re en Java, comme dans tout autre langage de programmation : l’instruction conditionnelle, qui a` la forme suivante :

if (condition) {instructions1} else {instructions2}

et s’exe´cute de la fac¸on suivante : si la condition est vraie c’est la suite d’instructions instructions1

qui est exe´cuteé ; si la condition est fausse, c’est la suite d’instructions instructions2 qui est exe´cuteé.

La condition doit eˆtre une expression booleénne c’est a` dire une expression dont la valeur est soit true soit false.

Voila` le programme Java utilisant une conditionnelle qui calcule le prix TTC :

2.6. CONDITIONNELLE

Listing 2.4 – (lien vers le code brut)

public class PrixTTC { public stat ic void main ( String [ ] args ) {

double pHT, pTTC;

int     t ;

Terminal . e c r i r e S t r i n g ( ” Entrer le prix HT: ” ) ; pHT = Terminal . lireDouble ( ) ;

Terminal . e c r i r e S t r i n g ( ” Entrer taux ( normal?>0 r e du i t ?>1) ” ) ; t = Terminal . l i r e I n t ( ) ; if ( t ==0){

pTTC=pHT + (pHT?0.196);

}

else {

pTTC=pHT + (pHT?0.05);

}

                         Terminal . e c r i r e S t r i n g l n ( ”La somme TTC:        ”+ pTTC    ) ;

}

}

Ce programme est constitue´ d’une suite de 8 instructions. Il s’exe´cutera en exe´cutant se´quentiellement chacune de ces instructions :

1.    de´claration de pHT et pTTC

2.    de´claration de t

3.    affichage du message "Entrer le prix HT :"

4.    la variable pHT rec¸oit la valeur entreé au clavier.

5.    affichage du message "Entrer taux (normal->0 reduit ->1)"

6.    la variable t rec¸oit la valeur entreé au clavier (0 ou 1)

7.    Java reconnaˆ?t le mot cle´ if et fait donc les choses suivantes :

(a)    il calcule l’expression qui est entre les parenthe`ses t==0. le re´sultat de t==0 de´pend de ce qu’a entre´ l’utilisateur. S’il a entre´ 0 le re´sultat sera true, sinon il sera false.

(b)    Si le re´sultat est true, les instructions entre les accolades sont exe´cuteés. Ici, il n’y en a qu’une :pTTC=pHT + (PHT*0.196); qui a pour effet de donner a pTTC le prix TTC avec taux normal. Si le re´sultat est false, il exe´cution les instructions dans les accolades figurant apre`s le else :pTTC=pHT + (PHT*0.05);

8.    la valeur de pTTC est afficheé. cette dernie`re instruction est toujours execut´ ee´ : elle n’est pas a` l’inte´rieur des accolades du if ou du else. La conditionnelle a servi a mettre une valeur diffe´rente dans la variable pTTC, mais il faut dans les deux cas afficher cette valeur.

2.6.1 if sans else

Lorsqu’on veut dire : si condition est vraie alors faire ceci, sinon ne rien faire, on peut omettre le else;

2.6.2    tests a la suite`

Lorsque le proble`me a` re´soudre ne´cessite de distinguer plus de 2 cas, on peut utiliser la forme suivante :

if (condition1){s1} else if (condition2) {s2}

else if (conditionp) {sp} else {sf}

On peut mettre autant de else if que l’on veut, mais 0 ou 1 else (et toujours a` la fin). else if signifie sinon si. Il en de´coule que les conditions sont e´valueés dans l’ordre. La premie`re qui est vraie donne lieu a` la se´quence d’instructions qui est y associeé. Si aucune condition n’est vraie, c’est le else qui est exe´cute´.

2.7    Iteration´

Ecrivons un programme qui affiche a` l’e´cran un rectangle forme´ de 5 lignes de 4 e´toiles. Ceci est facile : il suffit de faire 5 appels conse´cutifs a` la me´thode Terminal.ecrireStringln

Listing 2.5 – (lien vers le code brut)

public    class       Rectangle { public               stat ic     void main     ( String [ ]             args ) { Terminal . e c r i r e S t r i n g l n ( ”????” ) ;

Terminal . e c r i r e S t r i n g l n ( ”????” ) ;

Terminal . e c r i r e S t r i n g l n ( ”????” ) ;



Terminal . e c r i r e S t r i n g l n ( ”????” ) ;

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

Ceci est possible, mais ce n’est pas tre`s e´le´gant ! Nous avons des instructions qui nous permettent de re´pe´ter des taˆches. Elles s’appellent les instructions d’iterations´ .

2.7.1    La boucle for

La boucle for permet de re´pe´ter une taˆche un nombre de fois connus a` l’avance. Ceci est suffisant pour l’affichage de notre rectangle :

Listing 2.6 – (lien vers le code brut)

public class Rectangle { public stat ic void main ( String [ ] args ) { for ( int i =0; i <5; i= i +1){

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

RA˜  c pA¨te˜ i fois, pour i allant de 0 a` 4 les instructions qui sont dans les accolades, c’est a` dire dans notre cas : afficher une ligne de 4 *.

Cela revient bien a` dire : re´pe`te 5 fois ”afficher une ligne de 4 e´toiles”.

De´taillons cela : La boucle for fonctionne avec un compteur du nombre de re´pe´tition qui est ge´re´ dans les 3 expressions entre les parenthe`ses.

–    La premie`re :int i=0 donne un nom a ce compteur (i) et lui donne une valeur initiale 0. Ce compteur ne sera connu qu’a` l’inte´rieur de la boucle for. (il a e´te´ declare´ dans la boucle for int i)

–    La troisie`me : i=i+1 dit que les valeurs successives de i seront 0 puis 0+1 puis 1+1, puis 2+1 etc.

–    La seconde (i<5) dit quand s’arreˆte l’e´nume´ration des valeurs de i : la premie`re fois que i

Graˆce a` ces 3 informations nous savons que i va prendre les valeurs successives 0, 1, 2, 3, 4. Pour chacune de ces valeurs successives, on re´pe`tera les instructions dans les accolades.

Jouons un peu

Pour eˆtre sur d’avoir compris, examinons les programmes suivants :

Listing 2.7 – (lien vers le code brut)

public class Rectangle { public stat ic void main ( String [ ] args ) { for ( int i =0; i <5; i= i +2){

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

i va prendre les valeurs successives 0, 2, 4. Il y aura donc 3 re´pe´titions. Ce programme affiche 3 lignes de 4 e´toiles.

Listing 2.8 – (lien vers le code brut)

public class Rectangle { public stat ic void main ( String [ ] args ) { for ( int i =1; i <5; i= i +2){

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

i va prendre les valeurs successives 1, 3. Il y aura donc 2 re´pétitions. Ce programme affiche 2 lignes de 4 e´toiles.

Listing 2.9 – (lien vers le code brut)

public class Rectangle { public stat ic void main ( String [ ] args ) { for ( int i =1; i <=5; i = i +2){

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

i va prendre les valeurs successives 1, 3, 5. Il y aura donc 3 re´pe´titions. Ce programme affiche 3 lignes de 4 e´toiles.

Listing 2.10 – (lien vers le code brut)

public class Rectangle { public stat ic void main ( String [ ] args ) { for ( int i =1; i ==5; i = i +2){

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

i ne prendra aucune valeur car sa premie`re valeur (1) n’est pas e´gale a` 5. Les instructions entre

accolades ne sont jamais exe´cuteés. Ce programme n’affiche rien.

Les boucles sont necessaires´

Dans notre premier exemple, nous avons utilise´ une boucle pour abre´ger notre code. Pour certains proble`mes, l’utilisation des boucles est absolument ne´cessaire. Essayons par exemple d’e´crire un programme qui affiche un rectangle d’e´toiles dont la longueur est donneé par l’utilisateur (la largeur restera 4).

Ceci ne peut de faire sans boucle car le nombre de fois ou` il faut appeler l’instruction d’affichage de´pend de la valeur donneé par l’utilisateur.

En revanche, cela s’e´crit tre`s bien avec une boucle for :

Listing 2.11 – (lien vers le code brut)

public         class         Rectangle2 {

public       sta tic        void main        ( String []         args ) {

int     l ;

Terminal . e c r i r e S t r i n g ( ”combien de l ignes d ’ e t o i l e s  ?: ” ) ; l =Terminal . l i r e I n t ( ) ; for ( int i =0; i<l ; i = i +1){

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

La variable l est de´clareé dans la premie`re instruction. Elle a une valeur a` l’issue de la troisie`me instruction. On peut donc tout a` fait consulter sa valeur dans la quatrie`me instruction (le for).

Si l’utilisateur entre 5 au clavier, il y aura 5 e´tapes et notre programme affichera 5 lignes de 4 e´toiles. Si l’utilisateur entre 8 au clavier, il y aura 8 e´tapes et notre programme affichera 8 lignes de 4 e´toiles.

le compteur d’etapes peut intervenir dans la boucle´

Le compteur d’e´tapes est connu dans la boucle. On peut tout à fait consulter son contenu dans la boucle.

Listing 2.12 – (lien vers le code brut)

public         class         Rectangle3 {

public       sta tic        void main        ( String []         args ) {

int     l ;

Terminal . e c r i r e S t r i n g ( ”combien de l ignes d ’ e t o i l e s  ?: ” ) ; l =Terminal . l i r e I n t ( ) ; for ( int i =1; i<=l ; i = i +1){

Terminal . e c r i r e I n t ( i ) ;

Terminal . e c r i r e S t r i n g l n ( ”????” ) ; }

}

}

Ce programme affiche les lignes d’e´toiles pre´ce´deés du nume´ro de ligne.

C’est pour cela que l’on a parfois besoin que la valeur du compteur d’e´tapes ne soit pas son nume´ro dans l’ordre des e´tapes. Voici un programme qui affiche les n premiers entiers pairs avec n demande´ a` l’utilisateur.

Listing 2.13 – (lien vers le code brut)

public         class         Rectangle3 {

public       sta tic        void main        ( String []         args ) {

int n ;

Terminal . e c r i r e S t r i n g ( ”combien d ’ e n t i e r s  pa i rs  ?: ” ) ; n=Terminal . l i r e I n t ( ) ;

for     ( int        i =0; i<n?2; i = i +2){

Terminal . e c r i r e I n t ( i ) ;

                 Terminal . e c r i r e S t r i n g ( ”     ,   ” ) ;

}

}

}

Et voici un programme qui affiche les 10 premiers entiers en partant de 10 :

Listing 2.14 – (lien vers le code brut)

public class premEntiers { public stat ic void main ( String [ ] args ) { for ( int i =10; i >0; i =i ?1){

                               Terminal . e c r i r e S t r i n g ( i     + ” , ” ) ;

}

}

}

Pour en savoir plus

La syntaxe de la boucle for en Java est beaucoup plus permissive que ce qui a` e´te´ expose´ ici. Nous nous sommes contente´s de de´crire son utilisation usuelle. Nous reviendrons plus en de´tail sur les boucles dans un chapitre ulte´rieur.

2.7.2    la boucle while

Certaines fois, la boucle for ne suffit pas. Ceci arrive lorsqu’au moment ou` on e´crit la boucle, on ne peut pas de´terminer le nombre d’e´tapes.

Reprenons notre exemple de calcul de prix TTC. Dans cet exemple, nous demandions a` l’utilisateur d’entrer 0 pour que l’on calcule avec le taux normal et 1 pour le taux re´duit.

Que se passe-t-il si l’utilisateur entre 4 par exemple ? 4 est diffe`rent de 0 donc le else sera exe´cute´. Autrement dit : toute autre re´ponse que 0 est interpre´teé comme 1.

Ceci n’est pas tre`s satisfaisant. Nous voulons maintenant ame´liorer notre programme pour qu’il redemande a` l’utilisateur une re´ponse, tant que celle-ci n’est pas 0 ou 1.

Nous sentons bien qu’il faut une boucle, mais la boucle for est inadapteé : on ne peut dire a priori combien il y aura d’e´tapes, cela de´pend de la vivacite´ de l’utilisateur ! Pour cela, nous avons la boucle while qui a la forme suivante :

while (condition) {

instructions

}

Cette boucle signifie : tant que la condition est vraie, exe´cuter les instructions entre les accolades (le corps de la boucle)

Graˆce a` cette boucle, on peut re´pe´ter une taˆche tant qu’un ev´ enement dans le corps de la boucle`   ne s’est pas produit.

C’est exactement ce qu’il nous faut : nous devons re´pe´ter la demande du taux, tant que l’utilisateur n’a pas fourni une re´ponse correcte.

ecriture de la boucle´

La condition de notre boucle devra eˆtre une expression booleénne Java qui exprime le fait que la re´ponse de l’utilisateur est correcte. Pour faire cela, il suffit d’ajouter une variable a` notre programme, que nous appellerons testReponse. Notre programme doit s’arranger pour qu’elle ait la valeur true de`s que la dernie`re saisie de l’utilisateur est correcte, c’est a` dire si t vaut 0 ou 1, et fausse sinon.

Notre boucle pourra s’e´crire :

Listing 2.15 – (lien vers le code brut)

while          ( testReponse == false ){

Terminal . e c r i r e S t r i n g l n ( ” Entrer taux ( normal?>0 r e du i t ?>1) ” ) ; t = Terminal . l i r e I n t ( ) ; i f ( t ==0 | | t ==1){

testReponse =true ;

}

else {

testReponse = false ;

}

}

Il faudra, bien entendu, avoir de´clare´ testReponse avant la boucle.

comportement de la boucle

La condition de la boucle est testeé avant chaque exe´cution du corps de la boucle. On commence donc par tester la condition ; si elle est vraie le corps est exe´cute´ une fois, puis on teste a nouveau la condition et ainsi de suite. L’exe´cution de la boucle se termine la premie`re fois que la condition est fausse.

initialisation de la boucle

Puisque testReponse==falseest la premie`re chose exe´cuteé lorsque la boucle est exe´cuteé, il faut donc que testReponse ait une valeur avant l’entreé dans la boucle. C’est ce qu’on appelle l’initialisation de la boucle. ici, puisque l’on veut entrer au moins une fois dans la boucle, il faut initialiser testReponse avec false.

etat de sortie de la boucle´

Puisqu’on sort d’une boucle while la premie`re fois que la condition est fausse, nous sommes suˆrs que dans notre exemple, en sortie de boucle, nous avons dans t une re´ponse correcte : 0 ou 1.

Les instructions qui suivent la boucle sont donc le calcul du prix TTC selon des 2 taux possibles. Voici le code Java :

Listing 2.16 – (lien vers le code brut)

public         class        PrixTTC2 {

public        stat ic        void main              ( String [ ]

double pHT, pTTC;

int t =0; boolean        testReponse = false ;

args ) {

Terminal . e c r i r e S t r i n g ( ” Entrer pHT = Terminal . lireDouble ( ) ; while ( testReponse == false ){

le             prix HT:

” ) ;

Terminal . e c r i r e S t r i n g ( ” Entrer taux ( normal?>0 re d ui t ?>1) ” ) ; t = Terminal . l i r e I n t ( ) ; i f ( t ==0 | | t ==1){

testReponse =true ;

}

else {

testReponse = false ;

}

}

if      ( t ==0){

pTTC=pHT + (pHT?0.196);

}

else {

pTTC=pHT + (pHT?0.05);

}

                         Terminal . e c r i r e S t r i n g l n ( ”La somme TTC:        ”+ pTTC    ) ;

}

}

Terminaison des boucles while

On peut e´crire avec les boucles while des programmes qui ne s’arreˆtent jamais. C’est presque le cas de notre exemple : si l’utilisateur n’entre jamais une bonne re´ponse, la boucle s’exe´cutera a` l’infini.

Dans ce cours, les seuls programmes qui ne terminent pas toujours et que vous aurez le droit d’e´crire seront de cette cate´gorie : ceux qui controˆlent les saisies utilisateurs.

Pour qu’une boucle while termine, il faut s’assurer que le corps de la boucle contient des instructions qui mettent a` jour la condition de boucle. Autrement dit, le corps de la boucle est toujours constitue´ de deux morceaux :

–    le morceau de´crivant la taˆche a` effectuer a` chaque e´tape

–    le morceau de´crivant la mise a` jour de la condition de sortie

Pour qu’une boucle termine toujours, il faut que chaque mise a` jour de la condition de sortie, nous rapproche du moment ou` la condition sera fausse. C’est bien le cas dans l’exemple suivant :

Listing 2.17 – (lien vers le code brut)

public class b1 { public stat ic void main ( String [ ] args ) { int i =1;

while       ( i !=10){

Terminal . e c r i r e S t r i n g ( i + ” , ” ) ; i= i +1;

}

}

}

Au de´but de la premie`re exe´cution du corps de boucle i vaut 1, Au de´but de la deuxie`me exe´cution du corps de boucle i vaut 2, . A chaque fois, on progresse vers le moment ou` i vaut 10. Ce cas est atteint au bout de 10 e´tapes.

Attention, il ne suffit de se rapprocher du moment ou` la condition est fausse, il faut l’atteindre un jour, ne pas la rater.

Le programme suivant, par exemple, ne termine jamais :

Listing 2.18 – (lien vers le code brut)

public class b3 { public stat ic void main ( String [ ] args ) { int i =1;

while       ( i !=10){

Terminal . e c r i r e S t r i n g ( i + ” , ” ) ; i= i +2;

}

}

}

Car i progresse de 1 a` 3, puis a` 5, a` 7, a` 9, a` 11 et 10 n’est jamais atteint.

la boucle while suffit

La boucle while est plus ge´ne´rale que la boucle for. On peut traduire tous les programmes avec des boucles for en des programmes avec des boucles while. On peut donc se passer de la boucle

2.7. ITERATION´                                                                                                                       19

for; il est cependant judicieux d’employer la boucle for a` chaque fois que c’est possible, parce qu’elle est plus facile a` e´crire, a` comprendre et a` maˆ?triser.



Ceci n’est pas tout a` fait exact. Nous apprendrons plus tard que nous pouvons affecter a` une variable des valeurs d’autres types qui sont de la meˆme famille (conversion implicite de type)



2009