7.5. Contrôle de flux en Java : opérateurs logiques et structures de décision
Le contrôle de flux en Java est l'un des piliers fondamentaux du développement de programmes efficaces. Grâce à l'utilisation intelligente de structures de décision telles que if, else, switch et de boucles de répétition telles que for, < code>while et do-while, il est possible de créer une logique complexe et robuste. Dans ce chapitre, nous explorerons l'utilisation d'opérateurs logiques et de structures de flux de contrôle, qui sont essentiels pour tout développeur Java souhaitant passer du niveau basique au niveau avancé.
Opérateurs logiques
Les opérateurs logiques sont utilisés pour former des expressions booléennes complexes, qui aboutissent à une valeur true ou false. Les principaux opérateurs logiques en Java sont :
- AND (&&) : renvoie
truesi les deux expressions sont vraies. - OR (||) : renvoie
truesi au moins une des expressions est vraie. - NON (!) : inverse la valeur de l'expression, de
trueàfalseet vice versa.
En combinant ces opérateurs, nous pouvons créer des conditions plus complexes pour contrôler le flux de notre programme.
Structure de décision si
La structure if est la forme la plus basique de contrôle de flux. Il permet au programme d'exécuter un bloc de code uniquement si une condition spécifique est vraie. Par exemple :
si (condition) {
// Bloc de code qui sera exécuté si la condition est vraie
}
Structure autre
else est utilisé conjointement avec if pour exécuter un bloc de code alternatif lorsque la condition if n'est pas satisfaite.
si (condition) {
// Exécuté si la condition est vraie
} autre {
// Exécuté si la condition est fausse
}
sinon si structure
Pour tester plusieurs conditions, nous pouvons enchaîner plusieurs structures if avec else if :
si (premièreCondition) {
// Exécuté si la première condition est vraie
} sinon si (secondeCondition) {
// Exécuté si la deuxième condition est vraie
} autre {
// Exécuté si aucune des conditions précédentes n'est vraie
}
Structure du switch
switch est une alternative à if qui peut rendre le code plus lisible lorsque nous avons de nombreuses conditions basées sur la même valeur. Chaque cas est défini par le mot-clé case, suivi d'une valeur et d'un break pour empêcher l'exécution des cas suivants.
commutateur (variable) {
valeur de cas1 :
// Exécuter si variable == valeur1
casser;
valeur de cas2 :
// Exécuter si variable == valeur2
casser;
défaut:
// Exécuté si aucun des cas ci-dessus n'est vrai
}
Répéter des boucles
Les boucles de répétition sont utilisées pour exécuter un bloc de code plusieurs fois. Java fournit plusieurs structures de boucles :
- pour : exécute un bloc de code un nombre de fois spécifié.
- while : exécute un bloc de code lorsqu'une condition est vraie.
- do-while : similaire à
while, mais garantit que le bloc de code est exécuté au moins une fois.
Boucle pour
pour (initialisation ; condition ; incrément) {
// Bloc de code à répéter
}
Boucle while
tandis que (condition) {
// Bloc de code à répéter
}
boucle à faire pendant
de {
// Bloc de code à répéter
} while (condition);
Exemples pratiques
Regardons quelques exemples de la manière dont ces structures peuvent être utilisées dans un programme Java :
// exemple si-sinon
note int = 75 ;
si (note >= 70) {
System.out.println("Approuvé");
} autre {
System.out.println("Échec");
}
// Changer d'exemple
qualité de caractère = « B » ;
interrupteur (grille) {
cas 'A' :
System.out.println("Excellent");
casser;
cas 'B' :
cas 'C' :
System.out.println("Bravo");
casser;
cas 'D' :
System.out.println("Vous avez réussi");
casser;
cas 'F' :
System.out.println("Mieux vaut réessayer");
casser;
défaut:
System.out.println("Note invalide");
}
// Par exemple
pour (int je = 0; je < 5; i++) {
System.out.println("i = " + i);
}
// pendant l'exemple
entier je = 0 ;
tandis que (i < 5) {
System.out.println("i = " + i);
je++;
}
// exemple de travail en cours
entier j = 0 ;
de {
System.out.println("j = " + j);
j++;
} tandis que (j < 5);
Comprendre et appliquer correctement les opérateurs logiques et les structures de contrôle de flux est essentiel pour tout développeur Java. Avec la pratique, ces outils deviennent intuitifs et permettent la construction de programmes complexes et efficaces.
