1. Operaciones booleanas
Los operadores |y &se pueden aplicar no solo a números, sino también a expresiones booleanas.
Pero, como ya sabes, hay &&y ||operadores. ¿Por qué usaríamos |en lugar de ||, y &en lugar de &&? ¿Hay algún punto para esto? Parece que hay. A veces.
Los operadores lógicos ||y &&se ejecutan de izquierda a derecha siguiendo el llamado principio perezoso .
(expression1) || (expression2) || (expression3)Si expression1 es igual a true, no tiene sentido evaluar expression2 y expression3: el resultado será trueindependientemente.
En consecuencia, al evaluar expresiones (se evalúan de izquierda a derecha), en cuanto obtenemos true, se salta la evaluación del resto de expresiones . Y si expression2 incluye expression3llamadas a métodos, ¡ estos métodos no serán llamados !
Lo mismo ocurre con el &&operador lógico:
(expression1) && (expression2) && (expression3)Si expression1es igual a false, no tiene sentido evaluar expression2y expression3: el resultado será falseindependientemente.
Este es un hecho importante que te permite escribir cosas como:
String s = null;
if (s != null && s.length() > 0) {El ejemplo anterior nunca obtendrá una excepción NullPointerException , porque s.length()solo se ejecutará si la primera parte s! = nulles true.
Si ses igual a null, la parte a la izquierda del &&operador es false, entonces el resultado de toda la expresión booleana es false, por lo que la parte a la derecha ( s.length() > 0) no se evalúa.
Si usa el |operador o el &operador, entonces no hay evaluación perezosa : cada subexpresión siempre se evaluará.
2. Precedencia de operaciones en Java
Como probablemente recordará de su clase de matemáticas de la escuela secundaria, el operador de multiplicación tiene mayor precedencia que el operador de suma. Los paréntesis tienen una precedencia aún mayor: las expresiones entre paréntesis se evalúan primero, luego la multiplicación y la división, y luego la suma y la resta.
Los operadores en Java también tienen un orden de precedencia. La diferencia es que a) hay un poco más de ellos, b) para algunos operadores, los operandos se evalúan de izquierda a derecha, mientras que para otros, de derecha a izquierda.
Aquí hay una tabla con todos los operadores de Java:
| Categoría | Operador | De asociación |
|---|---|---|
| Sufijo | () [] . |
De izquierda a derecha |
| unario | ++ -- ! ~ |
De derecha a izquierda |
| multiplicativo | * / % |
De izquierda a derecha |
| Aditivo | + - |
De izquierda a derecha |
| Cambiando | >> >>> << |
De izquierda a derecha |
| Relacional | > >= < <= |
De izquierda a derecha |
| Igualdad | == != |
De izquierda a derecha |
bit a bitAND |
& |
De izquierda a derecha |
Exclusive OR(XOR) |
^ |
De izquierda a derecha |
bit a bitOR |
| |
De izquierda a derecha |
LógicoAND |
&& |
De izquierda a derecha |
LógicoOR |
|| |
De izquierda a derecha |
| Condicional | ?: |
De derecha a izquierda |
| Asignación | = += -= *= /= %= >>= <<= &= ^= |= |
De derecha a izquierda |
| Coma | , |
De izquierda a derecha |
La línea superior contiene los operadores con mayor precedencia. Los paréntesis ()se utilizan para establecer explícitamente la prioridad. Los corchetes []se utilizan para acceder a un elemento en un índice específico de una variable de matriz. El operador de punto ( .) se usa para acceder a campos y métodos usando una referencia a un objeto o clase.
Cuanto más abajo estén los operadores en la tabla, menor será su precedencia.
Si usa múltiples operadores en una expresión, no sea perezoso: agregue paréntesis.
En Java, puedes escribir algo como if (a & 1<< b > ~c), pero no deberías. Estás escribiendo código no solo para el compilador, sino también para otros programadores. Cuanto más legible sea el código, mejor.
3. Incremento de prefijo y posfijo
Como ya sabes, Java tiene un operador de incremento ( ++) y un operador de decremento ( --). Respectivamente, aumentan y disminuyen el valor de una variable en 1.
Lo que probablemente no sepa es que hay dos tipos de estos operadores: prefijo (el operador se coloca antes de la variable) y sufijo (el operador se coloca después de la variable). Y dos tipos de operadores funcionan un poco diferente.
En Java, puedes escribir una expresión como esta:
int a = 5;
int b = a++;Si el ++operador aparece después de una variable y la variable es parte de alguna expresión (como en el ejemplo anterior), entonces la expresión usará el valor actual de la variable, y solo después la variable aumentará en 1.
En otras palabras, algo como esto sucederá:
int a = 5;
int b = a;
a = a + 1;Es decir, bserá 5, no 6como se podría pensar a primera vista.
Si el ++operador está antes de la variable y la variable es parte de alguna expresión, primero se incrementará en 1y solo después se usará su valor en la expresión.
int a = 5;
int b = ++a;El ejemplo anterior es equivalente al siguiente ejemplo:
int a = 5;
a = a + 1;
int b = a;Aquí, bserá igual a 6.
Incluso hay un ejemplo utilizado por los programadores de Java para determinar si alguien más también es un programador de Java:
int a = 5;
int b = ++a + ++a;Sí, también puedes escribir eso.
Este ejemplo se compilará bien y se convertirá en algo como esto:
int a = 5;
a = a + 1;
int v1 = a;
a = a + 1;
int v2 = a;
int b = v1 + v2;Para el --operador, todo es exactamente igual.