¿Qué es un cortocircuito y cómo se usa cuando se progtwig en Java?

Posible duplicado:
¿Java evalúa las condiciones restantes después de conocer el resultado booleano?
¿Por qué usamos habitualmente? || no | , ¿cuál es la diferencia?

Me perdí la conferencia de mi clase el otro día y me preguntaba si alguien podría dar una explicación sobre qué es el cortocircuito y tal vez un ejemplo de que se use en un simple progtwig de Java. ¡Gracias por tu ayuda!

El cortocircuito es cuando una expresión deja de evaluarse tan pronto como se determina su resultado. Entonces, por ejemplo:

 if (a == b || c == d || e == f) { // Do something } 

Si a == b es verdadero, entonces c == d y e == f nunca se evalúan en absoluto , porque el resultado de la expresión ya ha sido determinado. si a == b es falso, entonces c == d se evalúa; si es verdad, entonces e == f nunca se evalúa. Esto puede no parecer hacer ninguna diferencia, pero considere:

 if (foo() || bar() || baz()) { // Do something } 

Si foo() devuelve verdadero, entonces bar y baz nunca son llamados , porque el resultado de la expresión ya ha sido determinado. Entonces, si bar o baz tiene algún otro efecto que simplemente devolver algo (un efecto secundario ), esos efectos nunca ocurren.

Un gran ejemplo de cortocircuito se relaciona con referencias a objetos:

 if (a != null && a.getFoo() != 42) { // Do something } 

a.getFoo() normalmente arrojaría una NullPointerException si a fuera null , pero como la expresión cortocircuitos, si a != null es false , la parte a.getFoo() nunca ocurre, por lo que no obtenemos una excepción.

Tenga en cuenta que no todas las expresiones están en cortocircuito. El || y && operadores están en cortocircuito, pero | y & no son, ni son * o / ; de hecho, la mayoría de los operadores no lo son.

La evaluación de cortocircuito significa que al evaluar expresiones booleanas ( AND lógico y OR ) puede detenerse tan pronto como encuentre la primera condición que satisfaga o anule la expresión.

Por ejemplo, suponga que está evaluando un OR lógico con varias subexpresiones, cada una de las cuales es muy costosa de evaluar:

 if (costlyTest1() || costlyTest2() || costlyTest3()) { // ... 

La JVM puede dejar de evaluar las funciones de “prueba costosa” tan pronto como encuentre una que devuelva true , ya que eso satisfará la expresión booleana. Entonces, si costlyTest1() devuelve verdadero, las otras pruebas se omitirán. Similar:

 if (costlyTest1() && costlyTest2() && costlyTest3()) { // ... 

La JVM puede dejar de evaluar las funciones tan pronto como encuentre una que devuelve false , ya que eso también satisface la expresión; entonces si costlyTest1() devuelve falso, las otras funciones no serán llamadas.

Estas reglas pertenecen a cualquier nivel de anidación de expresiones booleanas y se pueden aprovechar para evitar trabajos innecesarios, como se demuestra en los ejemplos anteriores.

Short Circuit : si la primera parte es true , no se moleste en evaluar el rest de la expresión. La misma lógica aplica para false en el caso de && que también está cortocircuitando

El cortocircuito en la evaluación de una expresión significa que solo una parte de la expresión necesita ser evaluada antes de encontrar su valor. Por ejemplo:

 a == null || a.size() == 0 

Si a es null , la a.size() == 0 no se evaluará, porque el operador booleano || se evalúa como true si uno de sus operandos es true .

Del mismo modo, para esta expresión:

 a != null && a.size() > 0 

Si a es null , entonces a.size() > 0 no se evaluará, porque el operador booleano && evalúa como false si uno de sus operandos es false .

En los ejemplos anteriores, los operadores booleanos && y || se dice que son cortocircuitos, dado que el segundo operando podría no evaluarse si el valor del primer operando es suficiente para determinar el valor de la expresión completa. Para comparación, el & y | operandos son los operadores booleanos equivalentes que no son de cortocircuito.

El cortocircuito es una forma alternativa de usar los operadores lógicos AND u OR (& o |)

por ejemplo, un corto circuito O

 if(false | true) { } 

La primera condición y la segunda condición se evalúan incluso si false no es verdadero (lo que siempre es).

Sin embargo, se escribió como un cortocircuito O:

 if(false || true) { } 

La primera condición solo se evalúa porque es falsa, la verdad no se evalúa porque no es necesaria.