Qu'est-ce que le court-circuit et comment est-il utilisé lors de la programmation en Java?
Duplicata possible:
Est-ce que Java évalue les conditions restantes après que le résultat booléen soit conn
Pourquoi utilisons-nous habituellement||ne pas|, quelle est la différence?
L'autre jour, j'ai manqué mon cours et je me demandais si quelqu'un pouvait expliquer ce qu'est le court-circuit et peut-être un exemple de son utilisation dans un simple programme Java Java. Merci pour votre aide!
Le court-circuitage est l'endroit où une expression cesse d'être évaluée dès que son résultat est déterminé. Ainsi, par exemple:
if (a == b || c == d || e == f) {
// Do something
}
Si a == b Est vrai, alors c == d Et e == f Sont jamais évalué du tout, car le résultat de l'expression a déjà été déterminé. si a == b est faux, alors c == d est évalué; si c'est vrai, alors e == f n'est jamais évalué. Cela ne semble pas faire de différence, mais considérez:
if (foo() || bar() || baz()) {
// Do something
}
Si foo() renvoie true, alors bar et baz sont jamais appelés, car le résultat de l'expression a déjà été déterminé. Donc, si bar ou baz a un autre effet que de simplement renvoyer quelque chose (un effet secondaire ), ces effets ne se produire.
Un excellent exemple de court-circuit concerne les références d'objets:
if (a != null && a.getFoo() != 42) {
// Do something
}
a.getFoo() lancerait normalement un NullPointerException si a était null, mais parce que l'expression court-circuite, si a != null est false, la partie a.getFoo() ne se produit jamais, donc nous n'avons pas d'exception.
Notez que toutes les expressions ne sont pas court-circuitées. Les opérateurs || Et && Sont court-circuités, mais | Et & Ne le sont pas, pas plus que * Ou /; en fait, la plupart des opérateurs ne le sont pas.
Évaluation de court-circuit signifie que lors de l'évaluation d'expressions booléennes (logique AND et OR), vous pouvez vous arrêter dès que vous trouvez la première condition qui satisfait ou annule l'expression .
Par exemple, supposons que vous évaluiez un OR logique avec plusieurs sous-expressions, dont chacune est très coûteuse à évaluer:
if (costlyTest1() || costlyTest2() || costlyTest3()) { // ...
La machine virtuelle Java peut arrêter d'évaluer les fonctions "costlyTest" dès qu'elle en trouve une qui renvoie true, car cela satisfera l'expression booléenne. Donc, si costlyTest1() renvoie true, les autres tests seront ignorés. De même:
if (costlyTest1() && costlyTest2() && costlyTest3()) { // ...
La machine virtuelle Java peut cesser d'évaluer les fonctions dès qu'elle en trouve une qui renvoie false, car cela satisfait également l'expression; donc si costlyTest1() retourne false alors les autres fonctions ne seront pas appelées.
Ces règles s'appliquent à tout niveau d'imbrication d'expressions booléennes et peuvent être utilisées pour éviter un travail inutile, comme le montrent les exemples ci-dessus.
Short Circuit: Si la première partie est true ne vous embêtez pas à évaluer le reste de l'expression. La même logique s'applique pour false dans le cas de && qui est aussi un court-circuit
Court-circuiter l'évaluation d'une expression signifie que seule une partie de l'expression doit être évaluée avant de trouver sa valeur. Par exemple:
a == null || a.size() == 0
Si a est null, la sous-expression a.size() == 0 ne sera pas évaluée, car l'opérateur booléen || Est évalué à true s'il y en a un de ses opérandes est true.
De même, pour cette expression:
a != null && a.size() > 0
Si a est null, alors la a.size() > 0 ne sera pas évaluée, car l'opérateur booléen && Est évalué à false s'il y en a un de ses opérandes est false.
Dans les exemples ci-dessus, les opérateurs booléens && Et || Sont censés être en court-circuit, étant donné que le deuxième opérande peut ne pas être évalué si la valeur du premier opérande est suffisante pour déterminer la valeur de l'expression entière. A titre de comparaison, les opérandes & Et | Sont les opérateurs booléens non-court-circuit équivalents.
Le court-circuit est une autre façon d'utiliser les opérateurs logiques ET ou OR (& ou |)
par exemple. un non court-circuit OU
if(false | true) {
}
La première condition et la deuxième condition sont toutes deux évaluées même si false n'est pas vrai (ce qui est toujours le cas).
Cependant, il a été écrit comme un court-circuit OU:
if(false || true) {
}
La première condition n'est évaluée que parce qu'elle est fausse, true n'est pas évaluée car elle n'est pas requise.