En Java, ¿cuál es el “orden de operaciones” booleano?

Tomemos un ejemplo simple de un objeto Cat . Quiero asegurarme de que el cat “no nulo” sea naranja o gris.

 if(cat != null && cat.getColor() == "orange" || cat.getColor() == "grey") { //do stuff } 

Creo que Y viene primero, luego el quirófano. Aunque estoy un poco confuso, así que aquí están mis preguntas:

  1. ¿Puede alguien guiarme a través de esta statement, así que estoy seguro de obtener lo que sucede?

  2. Además, ¿qué sucede si agrego paréntesis? ¿eso cambia el orden de las operaciones?

  3. ¿Cambiará mi orden de operaciones de un idioma a otro?

    Los Tutoriales de Java tienen una lista que ilustra la precedencia del operador . Los operadores de igualdad se evaluarán primero, luego && , luego || . Los paréntesis se evaluarán antes que cualquier otra cosa, por lo que agregarlos puede cambiar el orden. Por lo general, es más o menos lo mismo de un idioma a otro, pero siempre es una buena idea verificarlo dos veces.

    Son las pequeñas variaciones en el comportamiento lo que no se espera que puedan ocasionar que pases un día entero depurándose, por lo que es una buena idea poner los paréntesis en su lugar para estar seguro de cuál será el orden de evaluación.

    Orden booleano de operaciones (en todos los idiomas, creo):

    1. Parens
    2. NO
    3. Y
    4. O

    Entonces su lógica anterior es equivalente a:

     (cat != null && cat.getColor() == "orange") || cat.getColor() == "grey" 

    La expresión es básicamente idéntica a:

     if ( (cat != null && cat.getColor() == "orange") || cat.getColor() == "grey") { ... } 

    El orden de precedencia aquí es que AND ( && ) tiene una precedencia mayor que OR ( || ).

    También debe saber que usar == para probar la igualdad de cadenas a veces funcionará en Java, pero no es así como debería hacerlo. Deberías hacer:

     if (cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) { ... } 

    es decir, utilice los métodos equals() para String comparación de String , no == que simplemente hace referencia a la igualdad. La igualdad de referencia para cadenas puede ser engañosa. Por ejemplo:

     String a = new String("hello"); String b = new String("hello"); System.out.println(a == b); // false 

    Primero, su instrucción if contiene tres expresiones principales:

    1. cat! = null
    2. cat.getColor () == “naranja”
    3. cat.getColor () == “gris”

    La primera expresión simplemente verifica si cat no es nulo. Es necesario, de lo contrario, la segunda expresión se ejecutará y dará como resultado un NPE(null pointer excpetion) . Es por eso que el uso de && entre la primera y la segunda expresión. Cuando usa && , si la primera expresión se evalúa como falsa, la segunda expresión nunca se ejecuta. Finalmente, verifica si el color del gato es gris.

    Finalmente, tenga en cuenta que su sentencia if todavía está mal porque si cat es nula, la tercera expresión se sigue ejecutando y, por lo tanto, se obtiene una excepción de puntero nulo .

    La forma correcta de hacerlo es:

     if(cat != null && (cat.getColor() == "orange" || cat.getColor() == "grey")) { //do stuff } 

    Verifica el orden de paréntesis.

    && definitivamente se evalúa antes || . Pero veo que estás haciendo cat.getColor() == "orange" que podría darte un resultado inesperado. Es posible que desee esto en su lugar:

     if(cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) { //do stuff } 

    El orden de operación no es lo que necesita, necesita álgebra booleana, esto incluye funciones booleanas. Maxterms / minterms, código Gray, tablas de Karnaugh, diodos, transistores, compuertas lógicas, multiplexores, bitadders, flip flops … Lo que desea es implementar una “lógica” booleana en computadoras o máquinas virtuales. Con el “orden de las operaciones”, puede referir algo acerca de la física, como la gestión de retrasos en las compuertas lógicas (O, si) intervalos de nanosegundos.