markdown Operadores y su precedencia

Posted 2021-05-06

# Precedencia de operadores en java

Se toman los siguientes criterios:

1. Orden de precedencia del operador
2. Asociatividad del operador

# Asociatividad del operador

Cuando una expresión tiene dos operadores con la misma precedencia: `5*6/6` la expresión se evalúa de acuerdo a su asociativad. `*,/` se evalúan de izquierda a derecha por lo que el resultado de la expresión es: `5`.
Nota: algunos operadores no tienen asociatividad, por ejemplo `++`

No es necesario memorizar la tabla de precedencia de operadores pero es importante saber que los `()` tienen la mayor precedencia para poder agrupar expresiones y `=` tiene la menor precedencia para realizar al último las asignaciones.

# Orden de evaluación de las expresiones en java

La precedencia y la asociatividad indican en qué orden aplica java los operadores de una expresión, pero no indica en qué orden se evalúan las expresiones. En java las expresiones son evaluadas de izquierda a derecha: `(expr1)+(expr2)`


# Corto circuito

El operador `&&` y `||` hace que java no evalúe el segundo operador a menos que sea necesario, a esto se le llama corto circuito y hace confiable la expresión: `if(s!=null && s.length()<4)`

Por otra parte existen los operadores que no son de corto circuito: `&` y `|` los cuales realizan la operación `AND` y `OR` respectivamente pero sin hacer corto circuito, por lo tanto `if(s!=null && s.length()<4)` lanzará NPE si `s==null` 


# Pre-incremento y post-incremento

**pre-incremento**: `++x` evalúa el valor incrementado

**post-incremento**: `x++`: evalúa el valor original


[Tutorial java](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op1.html)
> The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code result++; and ++result; will both end in result being incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.


[JLS](https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.14.2)
> At run time, if evaluation of the operand expression completes abruptly, then the postfix decrement expression completes abruptly for the same reason and no decrementation occurs

```
int i = 5;
int x = i++;
System.out.println("x = " + x); // imprime 0
```

```
int i = 0;
i = i++ + i++ + ++i + ++i + i++;
 // 0   + 1   + 3   + 4   + 4   = 12
System.out.println("i = " + i); // imprime 12
```


# Referecia

[Tabla con precedencia de operadores](https://introcs.cs.princeton.edu/java/11precedence/)