Faire une boucle, changer ou faire une pause? Décider et itérer avec des instructions Java

Les applications Java évaluent les expressions dans le contexte d' instructions , qui sont utilisées pour des tâches telles que la déclaration d'une variable, la prise de décision ou l'itération d'instructions. Une instruction peut être exprimée sous la forme d'une instruction simple ou composée:

  • Une instruction simple est une instruction autonome unique pour exécuter une tâche; il doit se terminer par un caractère point-virgule ( ;).
  • Une instruction composée est une séquence d' instructions simples et d'autres instructions composées situées entre des accolades ouvertes et fermées ( {et }), qui délimitent les limites de l'instruction composée. Les instructions composées peuvent être vides, apparaîtront partout où des instructions simples apparaissent et sont également appelées blocs . Une instruction composée ne se termine pas par un point-virgule.

Dans ce didacticiel, vous apprendrez à utiliser des instructions dans vos programmes Java. Vous pouvez utiliser des déclarations telles que if, if-else, switch, foret whileaux variables Déclarez et spécifier des expressions, prendre des décisions, itérer (ou boucle) sur les déclarations, la rupture et l' itération continue, et plus encore. Je laisserai certaines des instructions les plus exotiques - telles que les instructions pour renvoyer les valeurs des méthodes appelées et pour lancer des exceptions - pour les futurs didacticiels Java 101.

Changer d'expressions dans Java 12

Notez que ce didacticiel a été mis à jour pour Java 12 et comprend une brève introduction aux switchexpressions.

télécharger Obtenir le code Téléchargez le code source des exemples d'applications dans ce didacticiel. Créé par Jeff Friesen pour JavaWorld.

Déclarations et affectations de variables

J'ai déjà introduit les variables Java et expliqué qu'elles doivent être déclarées avant d'être utilisées. Parce qu'une déclaration de variable est un îlot de code autonome, c'est en fait une instruction - une simple instruction , pour être exact. Tous ces éléments sont des instructions de déclaration de variables:

int age = 25; float interest_rate; char[] text = { 'J', 'a', 'v', 'a' }; String name;

Une déclaration de variable se compose au minimum d'un nom de type, éventuellement suivi d'une séquence de paires de crochets, suivi d'un nom, éventuellement suivi d'une séquence de paires de crochets, et se terminant par un point-virgule. Une variable peut également être explicitement initialisée lors de sa déclaration.

Considérons maintenant l' instruction d'affectation , qui est étroitement liée à l'instruction de déclaration de variable. Une instruction d'affectation affecte une valeur (éventuellement une référence à un tableau ou une référence à un objet) à une variable. Voici quelques exemples:

age = 30; interest_rate = 4.0F; age += 10; text[1] = 'A'; text[2] = 'V'; text[3] = 'A'; name = "John Doe";

Une instruction d'affectation est un exemple d' instruction d'expression , qui est une expression qui peut être utilisée comme instruction si elle est suivie d'un point-virgule. Les expressions suivantes peuvent également être qualifiées d'instructions d'expression:

  • Préincrément (par exemple ++x;)
  • Prédécrémenter (par exemple, --y;)
  • Postincrément (par exemple, x++;)
  • Postdécrément (par exemple, y--;)
  • Appel de méthode (par exemple System.out.println("Hello");)
  • Création d'objets (par exemple new String("ABC");)

Déclarations de variables avec jshell

Vous pouvez utiliser jshellpour expérimenter des déclarations de variables et des instructions d'expression. Voici quelques exemples pour vous aider à démarrer (voir «Apprendre Java à partir de zéro» pour une introduction à Java Shell):

jshell> int age = 25 age ==> 25 jshell> float interest_rate interest_rate ==> 0.0 jshell> char[] text = { 'J', 'a', 'v', 'a' } text ==> char[4] { 'J', 'a', 'v', 'a' } jshell> String name name ==> null jshell> age = 30 age ==> 30 jshell> interest_rate = 4.0F interest_rate ==> 4.0 jshell> age += 10 $7 ==> 40 jshell> text[1] = 'A' $8 ==> 'A' jshell> text[2] = 'V' $9 ==> 'V' jshell> text[3] = 'A' $10 ==> 'A' jshell> name = "John Doe" name ==> "John Doe" jshell> text text ==> char[4] { 'J', 'A', 'V', 'A' } jshell> age++ $13 ==> 40 jshell> age age ==> 41

Remarquez que age++cela ne semble pas avoir accompli quoi que ce soit. Ici, vous voyez que cela 40a été affecté à la variable scratch $13. Cependant, l'opérateur de post-incrémentation effectue l'incrémentation après avoir renvoyé la valeur actuelle. (En fait, il stocke la valeur actuelle quelque part, effectue l'incrémentation, puis renvoie la valeur stockée.) La saisie de l' âge prouve qu'il agecontient 41, le résultat de l'opération de post-incrémentation.

Java Shell fournit diverses commandes et fonctionnalités qui simplifient l'utilisation des extraits de code. Par exemple, la /listcommande affiche tous les extraits de code qui ont été saisis dans la session en cours:

jshell> /list 1 : int age = 25; 2 : float interest_rate; 3 : char[] text = { 'J', 'a', 'v', 'a' }; 4 : String name; 5 : age = 30 6 : interest_rate = 4.0F 7 : age += 10 8 : text[1] = 'A' 9 : text[2] = 'V' 10 : text[3] = 'A' 11 : name = "John Doe" 12 : text 13 : age++ 14 : age

Le nombre dans la colonne de gauche identifie de manière unique un extrait de code. Vous pouvez utiliser ce numéro pour réexécuter un extrait de code, répertorier l'extrait, déposer (supprimer) un extrait, etc.

jshell> /12 text text ==> char[4] { 'J', 'A', 'V', 'A' } jshell> /list 13 13 : age++ jshell> /drop 7 | dropped variable $7 jshell> /list 1 : int age = 25; 2 : float interest_rate; 3 : char[] text = { 'J', 'a', 'v', 'a' }; 4 : String name; 5 : age = 30 6 : interest_rate = 4.0F 8 : text[1] = 'A' 9 : text[2] = 'V' 10 : text[3] = 'A' 11 : name = "John Doe" 12 : text 13 : age++ 14 : age 15 : text

Ici, nous avons entré / 12 pour réexécuter l'extrait n ° 12, qui renvoie le contenu de text. Nous avons ensuite entré / list 13 pour lister l'extrait n ° 13, qui s'incrémente age. Ensuite, nous avons entré / drop 7 pour supprimer l'extrait de code 7 (plus d' age += 10extrait de code). Enfin, nous avons entré / list pour ré-lister tous les extraits. Notez que l'extrait de code 7 a été supprimé et qu'un extrait de code 15 a été ajouté grâce à la /12commande.

Prendre des décisions: if, if-else et switch

Les instructions de décision permettent aux applications de choisir entre plusieurs chemins d'exécution. Par exemple, si un vendeur vend plus de 500 articles ce mois-ci, offrez un bonus au vendeur. De plus, si la note d'un élève à un test d'algèbre est supérieure à 85%, félicitez l'élève de bien réussir; sinon, recommandez à l'étudiant d'étudier plus dur pour le prochain test.

Java prend en charge les if, if-elseet les switchdéclarations de décision. De plus, une nouvelle switchfonctionnalité d'expressions a été ajoutée à Java 12.

L'instruction if

La plus simple des instructions de décision de Java est l' ifinstruction, qui évalue une expression booléenne et exécute une autre instruction lorsque cette expression prend la valeur true. L' ifinstruction a la syntaxe suivante:

if (Boolean expression) statement

L' ifinstruction commence par un mot réservé ifet se poursuit par une expression booléenne entre parenthèses, qui est suivie de l'instruction à exécuter lorsque l'expression booléenne prend la valeur true.

L'exemple suivant illustre l' ifinstruction. Lorsque la agevariable contient une valeur de 55 ou plus, ifs'exécute System.out.println(...);pour afficher le message:

if (age >= 55) System.out.println("You are or were eligible for early retirement.");

De nombreuses personnes préfèrent placer toute instruction simple qui suit l' ifinstruction entre accolades, la convertissant ainsi en une instruction composée équivalente:

if (age >= 55) { System.out.println("You are or were eligible for early retirement."); }

Bien que les accolades clarifient ce qui est exécuté par l' ifinstruction, je pense que l'indentation apporte cette clarté et que les accolades ne sont pas nécessaires.

Expérimenter avec des instructions if

Let's try out this example usingjshell. Restart jshell and then introduce an age variable (of type int) that's initialized to 55:

jshell> int age = 55

Next, enter the first example if statement (without the curly braces surrounding its body):

jshell> if (age >= 55) ...> System.out.println("You are or were eligible for early retirement."); You are or were eligible for early retirement. jshell>

Notice that the jshell> prompt changes to the ...> continuation prompt when you enter a multiline snippet. Pressing Enter after the last snippet line causes jshell to immediately execute the snippet.

Execute /list to list all snippets. I observe that the if statement snippet has been assigned 2 in my session. Executing /2 causes jshell to list and then execute this snippet, and the same message is output.

Now, suppose you assign 25 to age and then re-execute /2 (or the equivalent snippet number in your session). This time, you should not observe the message in the output.

The if-else statement

The if-else statement evaluates a Boolean expression and executes a statement. The statement executed depends on whether the expression evaluates to true or false. Here's the syntax for the if-else statement:

if (Boolean expression) statement1 else statement2

The if-else statement is similar to the if statement, but it includes the reserved word else, followed by a statement to execute when the Boolean expression is false.

The following example demonstrates an if-else statement that tells someone who is less than 55 years old how many years are left until early retirement:

if (age >= 55) System.out.println("You are or were eligible for early retirement."); else System.out.println("You have " + (55 - age) + " years to go until early retirement.");

Conditional operator vs if-else

The conditional operator (?:) is similar to an if-else statement. However, this operator cannot be used to execute alternate statements. Instead, it can only return one of two values of the same type. (The conditional operator is also sometimes known as the ternary operator.)

Chaining if-else statements

Java lets you chain multiple if-else statements together for situations where you need to choose one of multiple statements to execute:

if (Boolean expression1) statement1 else if (Boolean expression2) statement2 else ... else statementN

Chaining works by executing a subsequent if-else statement whenever the current if statement's Boolean expression evaluates to false. Consider a demonstration:

if (temperature  100.0) System.out.println("boiling"); else System.out.println("normal");

The first if-else statement determines if temperature's value is negative. If so, it executes System.out.println("freezing");. If not, it executes a second if-else statement.

The second if-else statement determines if temperature's value is greater than 100. If so, it executes System.out.println("boiling");. Otherwise, it executes System.out.println("normal");.

The dangling-else problem

When if and if-else are used together, and the source code isn't properly indented, it can be difficult to determine which if associates with the else. You can see the problem in the code below:

int x = 0; int y = 2; if (x > 0) if (y > 0) System.out.println("x > 0 and y > 0"); else System.out.println("x <= 0");

You would probably expect to see x <= 0 as the output from this code, but it will never happen; instead, nothing will output. The problem is that the else matches up to its nearest if, which is if (y > 0). Reformatting the code makes it clearer what is happening:

int x = 0; int y = 2; if (x > 0) if (y > 0) System.out.println("x > 0 and y > 0"); else System.out.println("x <= 0");

Here it's clearer than an if (y > 0) ... else ...if-else statement follows the if (x > 0) statement. To match the intent of the previous example, you need to introduce brace characters around if (y > 0) and its subsequent statement. Essentially, a block will follow if (x > 0):

int x = 0; int y = 2; if (x > 0) { if (y > 0) System.out.println("x > 0 and y > 0"); } else System.out.println("x <= 0");

Because x > 0 evaluates to false, System.out.println("x <= 0"); executes. The else reserved word clearly matches up to if (x > 0).

The switch statement

When you need to choose between several execution paths, the switch statement offers a more efficient alternative to chaining. Have a look at the switch statement:

switch (selector expression) { case value1: statement1 [break;] case value2: statement2 [break;] ... case valueN: statementN [break;] [default: statement] }

The switch statement begins with reserved word switch and continues with a selector expression that selects one of the subsequent cases or the default case to execute. The selector expression evaluates to an integer, a character, or a string.

Switch and enum constants

The selector expression can also evaluate to an enum constant. I'll introduce enums in a future tutorial.

Chaque cas identifie une instruction à exécuter. Le cas commence par le mot réservé caseet une valeur qui étiquette le cas. Après un caractère deux-points ( :) se trouve l'instruction à exécuter. L'instruction peut être éventuellement suivie de break;, pour transférer l'exécution vers la première instruction après switch. Si aucune des étiquettes de cas ne correspond à la valeur de l'expression du sélecteur, la casse par défaut facultative, qui commence par un mot réservé default, s'exécutera.

Ci-dessous se trouve une switchinstruction utilisée pour déterminer si une valeur entière est paire ou impaire (en utilisant l'opérateur de reste). Il sort alors un message approprié via le cas dont l'étiquette correspond au reste:

int i = 27; switch (i % 2) { case 0: System.out.println("even"); break; case 1: System.out.println("odd"); }