Java Language
Structures de contrôle de base
Recherche…
Remarques
Toutes les structures de contrôle, sauf indication contraire, utilisent des instructions de bloc . Celles-ci sont indiquées par des accolades {}
.
Cela diffère des instructions normales , qui ne nécessitent pas d'accolades, mais comportent également une réserve stricte: seule la ligne qui suit immédiatement l'instruction précédente est prise en compte.
Ainsi, il est parfaitement valable d’écrire n’importe laquelle de ces structures de contrôle sans accolades, à condition qu’une seule instruction suive le début, mais qu’elle soit fortement déconseillée , car elle peut entraîner des mises en œuvre erronées ou du code cassé.
Exemple:
// valid, but discouraged
Scanner scan = new Scanner(System.in);
int val = scan.nextInt();
if(val % 2 == 0)
System.out.println("Val was even!");
// invalid; will not compile
// note the misleading indentation here
for(int i = 0; i < 10; i++)
System.out.println(i);
System.out.println("i is currently: " + i);
Si / Sinon Si / Contrôle Else
if (i < 2) {
System.out.println("i is less than 2");
} else if (i > 2) {
System.out.println("i is more than 2");
} else {
System.out.println("i is not less than 2, and not more than 2");
}
Le bloc if
ne fonctionnera que lorsque i
est inférieur ou égal à 1.
La condition else if
est vérifiée uniquement si toutes les conditions avant (dans les constructions précédentes else if
et les constructions parent if
) ont été testées sur false
. Dans cet exemple, la condition else if
ne sera vérifiée que si i
est supérieur ou égal à 2.
Si son résultat est true
, son bloc est exécuté, et tout else if
et else
construit après son saut.
Si aucune des if
et else if
n'a été testée sur true
, le bloc else
à la fin sera exécuté.
Pour les boucles
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
Les trois composants de la boucle for
(séparés par ;
) sont la déclaration / initialisation des variables (ici int i = 0
), la condition (ici i < 100
) et l’instruction d’incrémentation (ici i++
). La déclaration de variable est effectuée une fois comme si elle était placée juste à l’intérieur du {
lors de la première exécution. Ensuite, la condition est vérifiée, s'il est true
le corps de la boucle s'exécutera, s'il est false
la boucle s'arrêtera. En supposant que la boucle se poursuive, le corps s'exécutera et finalement lorsque l'instruction }
sera atteinte, l'instruction d'incrémentation s'exécutera juste avant que la condition ne soit à nouveau vérifiée.
Les accolades sont facultatives (vous pouvez une ligne avec un point-virgule) si la boucle ne contient qu'une seule instruction. Mais, il est toujours recommandé d'utiliser des accolades pour éviter les malentendus et les bugs.
Les composants for
loop sont facultatifs. Si votre logique métier contient l'une de ces parties, vous pouvez omettre le composant correspondant de votre boucle for
.
int i = obj.getLastestValue(); // i value is fetched from a method
for (; i < 100; i++) { // here initialization is not done
System.out.println(i);
}
La structure for (;;) { function-body }
est égale à une boucle while (true)
.
Nested For Loops
Toute instruction de boucle ayant une autre instruction de boucle à l'intérieur appelée boucle imbriquée. La même façon de boucler avec plus de boucle interne est appelée «imbriquée pour la boucle».
for(;;){
//Outer Loop Statements
for(;;){
//Inner Loop Statements
}
//Outer Loop Statements
}
Il est possible de démontrer que les imbriqués pour la boucle impriment des nombres en forme de triangle.
for(int i=9;i>0;i--){//Outer Loop
System.out.println();
for(int k=i;k>0;k--){//Inner Loop -1
System.out.print(" ");
}
for(int j=i;j<=9;j++){//Inner Loop -2
System.out.print(" "+j);
}
}
Pendant que les boucles
int i = 0;
while (i < 100) { // condition gets checked BEFORE the loop body executes
System.out.println(i);
i++;
}
A while
boucle court aussi longtemps que la condition entre parenthèses est true
. Cela s'appelle aussi la structure "boucle de pré-test" car l'instruction conditionnelle doit être satisfaite avant que le corps de la boucle principale ne soit exécuté à chaque fois.
Les accolades sont facultatives si la boucle ne contient qu'une seule instruction, mais certaines conventions de style de codage préfèrent les accolades.
do ... tandis que la boucle
La boucle do...while
while diffère des autres boucles en ce sens qu'elle est garantie au moins une fois . On l'appelle aussi la structure "post-test loop" car l'instruction conditionnelle est exécutée après le corps de la boucle principale.
int i = 0;
do {
i++;
System.out.println(i);
} while (i < 100); // Condition gets checked AFTER the content of the loop executes.
Dans cet exemple, la boucle s'exécutera jusqu'à ce que le nombre 100
soit imprimé (même si la condition est i < 100
et non i <= 100
), car la condition de la boucle est évaluée après l'exécution de la boucle.
Avec la garantie d'au moins une exécution, il est possible de déclarer des variables en dehors de la boucle et de les initialiser à l'intérieur.
String theWord;
Scanner scan = new Scanner(System.in);
do {
theWord = scan.nextLine();
} while (!theWord.equals("Bird"));
System.out.println(theWord);
Dans ce contexte, le theWord
est défini en dehors de la boucle, mais comme il est garanti d'avoir une valeur basée sur son flux naturel, le theWord
sera initialisé.
Pour chaque
Avec Java 5 et plus, on peut utiliser des boucles for-each, également appelées boucles for-loops:
List strings = new ArrayList();
strings.add("This");
strings.add("is");
strings.add("a for-each loop");
for (String string : strings) {
System.out.println(string);
}
Pour chaque boucle peut être utilisée pour itérer sur Arrays et les implémentations de l'interface Iterable
, le dernier inclut les classes Collections , telles que List
ou Set
.
La variable de boucle peut être de tout type pouvant être assigné à partir du type de source.
La variable de boucle pour une boucle améliorée pour Iterable<T>
ou T[]
peut être de type S
, si
-
T extends S
- les deux
T
etS
sont des types primitifs et assignables sans fonte -
S
est un type primitif etT
peut être converti en un type assignable àS
après la conversion unboxing. -
T
est un type primitif et peut être converti enS
par conversion automatique.
Exemples:
T elements = ...
for (S s : elements) {
}
T | S | Compile |
---|---|---|
int [] | longue | Oui |
longue[] | int | non |
Iterable<Byte> | longue | Oui |
Iterable<String> | CharSequence | Oui |
Iterable<CharSequence> | Chaîne | non |
int [] | Longue | non |
int [] | Entier | Oui |
Sinon
int i = 2;
if (i < 2) {
System.out.println("i is less than 2");
} else {
System.out.println("i is greater than 2");
}
Une instruction if
exécute le code de manière conditionnelle en fonction du résultat de la condition entre parenthèses. Lorsque la condition entre parenthèses est vraie, elle entrera dans le bloc de l'instruction if qui est défini par des accolades comme {
et }
. parenthèse ouvrante jusqu'à la parenthèse fermante est la portée de l'instruction if.
Le bloc else
est facultatif et peut être omis. Il s'exécute si l'instruction if
est false
et ne s'exécute pas si l'instruction if
est vraie. Dans ce cas, if
instruction est exécutée.
Voir aussi: Si ternaire
Déclaration de changement
L'instruction switch
est l'instruction de branche multi-voies de Java. Il est utilisé pour remplacer les chaînes long if
- else if
- else
et les rendre plus lisibles. Cependant, à la différence if
les déclarations, on ne peut pas utiliser les inégalités; chaque valeur doit être définie concrètement.
L'instruction switch
comporte trois composants essentiels:
-
case
: Valeur évaluée pour l'équivalence avec l'argument de l'instructionswitch
. -
default
: il s'agit d'une expression facultative, catch-all, si aucune des instructions decase
n'est évaluée àtrue
. - Achèvement complet de la déclaration de
case
; En général,break
: Ceci est nécessaire pour empêcher l'évaluation indésirable d'autres déclarations decase
.
À l'exception de continue
, il est possible d'utiliser n'importe quelle instruction qui entraînerait l' achèvement brutal d'une déclaration . Ceci comprend:
-
break
-
return
-
throw
Dans l'exemple ci-dessous, une instruction de switch
typique est écrite avec quatre cas possibles, y compris la default
.
Scanner scan = new Scanner(System.in);
int i = scan.nextInt();
switch (i) {
case 0:
System.out.println("i is zero");
break;
case 1:
System.out.println("i is one");
break;
case 2:
System.out.println("i is two");
break;
default:
System.out.println("i is less than zero or greater than two");
}
En omettant les break
ou toute déclaration qui aboutirait brusquement, nous pouvons tirer parti de ce que nous appelons des cas «tombants», qui s’évaluent en fonction de plusieurs valeurs. Cela peut être utilisé pour créer des plages pour une valeur réussie, mais n'est pas aussi flexible que les inégalités.
Scanner scan = new Scanner(System.in);
int foo = scan.nextInt();
switch(foo) {
case 1:
System.out.println("I'm equal or greater than one");
case 2:
case 3:
System.out.println("I'm one, two, or three");
break;
default:
System.out.println("I'm not either one, two, or three");
}
Dans le cas de foo == 1
le résultat sera:
I'm equal or greater than one
I'm one, two, or three
Dans le cas de foo == 3
le résultat sera:
I'm one, two, or three
L'instruction switch peut également être utilisée avec enum
s.
enum Option {
BLUE_PILL,
RED_PILL
}
public void takeOne(Option option) {
switch(option) {
case BLUE_PILL:
System.out.println("Story ends, wake up, believe whatever you want.");
break;
case RED_PILL:
System.out.println("I show you how deep the rabbit hole goes.");
break;
}
}
L'instruction switch
peut également être utilisée avec String
s.
public void rhymingGame(String phrase) {
switch (phrase) {
case "apples and pears":
System.out.println("Stairs");
break;
case "lorry":
System.out.println("truck");
break;
default:
System.out.println("Don't know any more");
}
}
Opérateur ternaire
Parfois, vous devez vérifier une condition et définir la valeur d'une variable.
Pour ex.
String name;
if (A > B) {
name = "Billy";
} else {
name = "Jimmy";
}
Cela peut être facilement écrit dans une ligne comme
String name = A > B ? "Billy" : "Jimmy";
La valeur de la variable est définie sur la valeur immédiatement après la condition, si la condition est vraie. Si la condition est fausse, la deuxième valeur sera donnée à la variable.
Pause
L'instruction break
termine une boucle (comme for
, while
) ou l'évaluation d'une instruction switch .
Boucle:
while(true) {
if(someCondition == 5) {
break;
}
}
La boucle dans l'exemple fonctionnerait pour toujours. Mais quand une someCondition
est égale à 5
à un moment donné, la boucle se termine.
Si plusieurs boucles sont en cascade, seule la boucle la plus interne se termine par un break
.
Essayez ... Catch ... Enfin
La structure de contrôle try { ... } catch ( ... ) { ... }
est utilisée pour gérer les exceptions .
String age_input = "abc";
try {
int age = Integer.parseInt(age_input);
if (age >= 18) {
System.out.println("You can vote!");
} else {
System.out.println("Sorry, you can't vote yet.");
}
} catch (NumberFormatException ex) {
System.err.println("Invalid input. '" + age_input + "' is not a valid integer.");
}
Cela imprimerait:
Entrée invalide. 'abc' n'est pas un entier valide.
Une clause finally
peut être ajoutée après le catch
. La clause finally
serait toujours exécutée, qu'une exception ait été levée ou non.
try { ... } catch ( ... ) { ... } finally { ... }
String age_input = "abc";
try {
int age = Integer.parseInt(age_input);
if (age >= 18) {
System.out.println("You can vote!");
} else {
System.out.println("Sorry, you can't vote yet.");
}
} catch (NumberFormatException ex) {
System.err.println("Invalid input. '" + age_input + "' is not a valid integer.");
} finally {
System.out.println("This code will always be run, even if an exception is thrown");
}
Cela imprimerait:
Entrée invalide. 'abc' n'est pas un entier valide.
Ce code sera toujours exécuté, même si une exception est levée
Nested break / continue
Il est possible de break
/ continue
vers une boucle externe en utilisant des instructions d'étiquette:
outerloop:
for(...) {
innerloop:
for(...) {
if(condition1)
break outerloop;
if(condition2)
continue innerloop; // equivalent to: continue;
}
}
Il n'y a pas d'autre utilisation pour les étiquettes en Java.
Continuer la déclaration en Java
L'instruction continue permet d'ignorer les étapes restantes de l'itération en cours et de commencer avec l'itération de boucle suivante. Le contrôle passe de l'instruction continue
à la valeur d'étape (incrémentation ou décrémentation), le cas échéant.
String[] programmers = {"Adrian", "Paul", "John", "Harry"};
//john is not printed out
for (String name : programmers) {
if (name.equals("John"))
continue;
System.out.println(name);
}
L'instruction continue
peut également faire passer le contrôle du programme à la valeur d'étape (le cas échéant) d'une boucle nommée:
Outer: // The name of the outermost loop is kept here as 'Outer'
for(int i = 0; i < 5; )
{
for(int j = 0; j < 5; j++)
{
continue Outer;
}
}