L'article précédent couvrait les opérateurs de comparaison, et cet article couvre les opérateurs conditionnels.
aperçu
Les opérateurs conditionnels sont comme si nous prenions des décisions dans la vraie vie, ils contrôlent le déroulement du programme et produisent des résultats basés sur les conditions fournies.
Il existe trois types d'opérateurs conditionnels, à savoir conditionnel et, conditionnel ou et opérateur ternaire, laissez-nous comprendre comment ces opérateurs conditionnels sont utilisés en Java.
Les opérateurs suivants sont fournis sous forme d'opérateurs conditionnels dont les opérandes prennent des valeurs de type booléen :
| opérateur | exemple de saisie | expliquer |
|---|---|---|
| && | x && y | Renvoie vrai si x et y sont vrais. |
| || | x || est | Renvoie vrai si x ou y est vrai. |
| & | x&y | Renvoie vrai si x et y sont booléens et que les deux sont vrais. Si les deux variables sont de type entier, une opération ET au niveau du bit est effectuée. |
| | | x | y | Renvoie vrai si x et y sont tous les deux des valeurs booléennes et que l'un d'eux est vrai. Si les deux variables sont de type entier, une opération OU au niveau du bit est effectuée. |
| ^ | x^y | Renvoie vrai si x et y sont booléens et si x et y sont des valeurs distinctes. Si les deux variables sont de type entier, une opération XOR au niveau du bit est effectuée. |
| ！ | !X | Renvoie vrai si x est faux. |
Exemple de code :
package com.test.javaroads.operator;
/**
* @author: javaroads
* @date: 2022/12/4 17:43
* @description:
*/
public class Seven {
public static void main(String[] args) {
int a = 0;
int b = 0;
if ((!(a > 0)) && (!(b > 0))) {
a = 10;
b = 20;
}
if ((a > 15) ^ (b > 15)) {
System.out.println("运算符 = 成立。");
} else {
System.out.println("运算符 = 不成立。");
}
}
}
Résultats du :
Description du code :
- L'expression à l'intérieur du bloc if est exécutée si (!(a > 0)) et (!(b > 0)) sont vrais. Puisque ni a ni b n'est supérieur à 0 (a > 0), (b > 0) renvoie faux et l'opérateur ! renvoie à la fois (!(a > 0)) et (!(b > 0)) sont considérés comme vrais
- L'expression à l'intérieur du bloc if est exécutée si (a > 15) ou (b > 15) est vrai. (a > 15) renvoie faux et (b > 15) renvoie vrai, donc les deux sont vrais.
La différence entre &&, || et &, |
Les opérateurs dans &&, || et &, | ont la même signification, mais leur comportement est sensiblement différent. & renvoie vrai si les opérandes gauche et droit sont vrais et renvoie faux si l'opérande gauche est faux, que l'opérande droit soit vrai ou faux. && renvoie faux sans exécuter l'opérande droit si l'opérande gauche est faux, et renvoie faux après avoir exécuté l'opérande droit si l'opérande gauche est faux.
|| et | renvoient vrai si l'opérande gauche ou l'opérande droit est vrai, ce qui signifie que si l'opérande gauche est vrai, il renvoie vrai, que l'opérande droit soit vrai ou faux. || Si l'opérande de gauche est vrai, renvoie vrai sans exécuter l'opérande de droite. | Renvoie vrai après l'exécution de l'opérande droit si l'opérande gauche est vrai.
La différence de comportement entre &&, || et &, | est de savoir s'il faut exécuter l'opérande droit lorsque le résultat d'exécution global ne peut être déterminé que par le résultat de l'opérande gauche. En raison de ces propriétés, les opérateurs && et || sont également appelés opérateurs de court-circuit .
Si seul vrai ou faux est jugé, il n'y a pas de différence dans le résultat de l'exécution, quel que soit l'opérateur utilisé, mais lors de l'exécution d'un traitement sur le bon opérande, vous devez faire attention à la différence de comportement.
Jetons un œil au code ci-dessous !
package com.test.javaroads.operator;
/**
* @author: javaroads
* @date: 2022/12/4 17:51
* @description:
*/
public class Eight {
public static void main(String[] args) {
int a = 5;
if (a > 0 || (a *= 10) > 100) {
System.out.println("a是" + a);
}
int b = 5;
if (b > 0 | (b *= 10) > 100) {
System.out.println("b是" + b);
}
}
}
Résultats du :
Explication du code :
- Pour l'opérateur ||, si l'opérande gauche est vrai, l'opérande droit n'est pas exécuté. , l'opérande de droite, qui multiplie la variable a par 10, n'est pas traité lorsque l'instruction println est exécutée car l'opérande de gauche est vrai.
- Pour l'opérateur |, l'opérande de droite est exécuté même si l'opérande de gauche est vrai. Multipliez la variable b de l'opérande de droite par 10 et exécutez l'instruction println.