OPERADORES EN JAVA

Los operadores aritméticos

Todos los lenguajes de programación permiten realizar operaciones entre los tipos de
datos básicos: suma, resta, producto, cociente, etc., de dos números

Java tiene cinco operadores aritméticos cuyo significado se muestra en la tabla adjunta:

Operador Nombre Ejemplo

+ Suma 3+4
- Diferencia 3-4
* Producto 3*4
/ Cociente 20/7
% Módulo 20%7

El cociente entre dos enteros da como resultado un entero. Por ejemplo, al dividir 20
entre 7 nos da como resultado 2.

El operador módulo da como resultado el resto de la división entera. Por ejemplo 20%7
da como resultado 6 que es el resto de la división entre 20 y 7.

El operador módulo también se puede emplear con números reales. Por ejemplo, el
cociente entre 7.5 y 3.0 es 2.5 y el resto es cero, es decir, 7.5=3.0 x 2.5+ 0. El operador
módulo, funciona de la siguiente forma 7.5=3.0 x 2+1.5, calcula la diferencia entre el
dividendo (7.5) y el producto del divisor (3.0) por la parte entera (2) del cociente,
devolviendo 1.5. Así pues, la operación 7.5%3.0 da como resultado 1.5.

El operador asignación =

Nos habremos dado cuenta que el operador más importante y más frecuentemente
usado es el operador asignación =, que hemos empleado para la inicialización de las
variables. Así,

int numero;
numero=20;

La primera sentencia declara una variable entera de tipo int y le da un nombre (numero).
La segunda sentencia usa el operador asignación para inicializar la variable con el
número 20.

Consideremos ahora, la siguiente sentencia.

a=b;
que asigna a a el valor de b. A la izquierda siempre tendremos una variable tal como a,
que recibe valores, a la derecha otra variable b, o expresión que tiene un valor. Por
tanto, tienen sentido las expresiones

a=1234;
double area=calculaArea(radio);
superficie=ancho*alto;

Sin embargo, no tienen sentido las expresiones

1234=a;
calculaArea(radio)=area;

El operador asignación se puede combinar con los operadores aritméticos

Expresión Significado
x+=y x=x+y
x-=y x=x-y
x*=y x=x*y
x/=y x=x/y

Así, la sentencia

x=x+23;

evalúa la expresión x+23, que es asignada de nuevo a x. El compilador lee primero el

contenido de la porción de memoria nombrada x, realiza la suma, y guarda el resultado
en la misma porción de memoria. Se puede escribir la sentencia anterior de una forma
equivalente más simple

x+=23;

En el ejemplo vemos la variable par toma el valor de 2 y perímetro el resultado de una

expresión.
Veamos un ejemplo de una instrucción tonta, que en realidad no hace nada.

algo = algo;

La variable algo toma el valor de algo; todo queda como antes. Ahora aumentemos el
valor de la variable en 3 unidades.

algo = algo + 3;
Aquí la variable toma el valor que tenía más 3 unidades. Existe una forma de simplificar
la notación anterior. Es la siguiente:

algo += 3; // equivalente a algo = algo + 3

Se juntaron el operador de suma con el de asignación. Este atajo se puede realizar para
otras operaciones además de la suma. Es útil cuando la operación contiene como primer
operando al valor de la misma variable en la que se almacena el resultado.

Operadores de asignación
Operación Operador Utilización Operación equivalente
Suma += A += B A=A+B
Resta -= A -= B A=A-B
Multiplicación *= A *= B A=A*B
División /= A /= B A=A/B
Resto de división %= A %= B A=A%B
Desplazamiento a la izquierda <<= A <<= B A = A << B
Desplazamiento a la derecha >>= A >>= B A = A >> B
Desplazamiento a la derecha sin signo >>>= A >>>= B A = A >>> B
AND de bits &= A &= B A=A&B
OR de bits |= A |= B A=A|B
XOR de bits ^= A ^= B A=A^B

Concatenación de strings

En Java se usa el operador + para concatenar cadenas de caracteres o strings

El operador + cuando se utiliza con strings y otros objetos, crea un solo string que
contiene la concatenación de todos sus operandos. Si alguno de los operandos no es
una cadena, se convierte automáticamente en una cadena. Por ejemplo, en la
sentencia anterior el número del tipo double que guarda la variable tC se convierte en
un string que se añade al string "la temperatura centígrada es ".

Como vemos en el listado, para mostrar un resultado de una operación, por ejemplo, la
suma de dos números enteros, escribimos

iSuma=ia+ib;
System.out.println("El resultado de la suma es "+iSuma);
Concatena una cadena de caracteres con un tipo básico de dato, que convierte
automáticamente en un string.

El operador += también funciona con cadenas.

String nombre="Juan ";

nombre+="García";
System.out.println(nombre);

public class OperadorAp {

public static void main(String[] args) {
System.out.println("Operaciones con enteros");
int ia=7, ib=3;
int iSuma, iResto;
iSuma=ia+ib;
System.out.println("El resultado de la suma es "+iSuma);
int iProducto=ia*ib;
System.out.println("El resultado del producto es "+iProducto);
System.out.println("El resultado del cociente es "+(ia/ib));
iResto=ia%ib;
System.out.println("El resto de la división entera es "+iResto);

System.out.println("**********************************");
System.out.println("Operaciones con números decimales");
double da=7.5, db=3.0;
double dSuma=da+db;
System.out.println("El resultado de la suma es "+dSuma);
double dProducto=da*db;
System.out.println("El resultado del producto es "+dProducto);
double dCociente=da/db;
System.out.println("El resultado del cociente es "+dCociente);
double dResto=da%db;
System.out.println("El resto de la división es "+dResto);
}
}

La precedencia de operadores

El lector conocerá que los operadores aritméticos tienen distinta precedencia, así la
expresión
 a+b*c

es equivalente a

a+(b*c)

ya que el producto y el cociente tienen mayor precedencia que la suma o la resta. Por
tanto, en la segunda expresión el paréntesis no es necesario. Sin embargo, si queremos
que se efectúe antes la suma que la multiplicación tenemos de emplear los paréntesis

(a+b)*c

Para realizar la operación escribiremos

a/(b*c);

o bien,

a/b/c;

En la mayoría de los casos, la precedencia de las operaciones es evidente, sin embargo,

en otros que no lo son tanto, se aconseja emplear paréntesis. Como ejemplo,
estudiemos un programa que nos permite convertir una temperatura en grados
Fahrenheit en su equivalente en la escala Celsius. La fórmula de conversión es

cuya codificación es

tC=(tF-32)*5/9;

Las operaciones se realizan como suponemos, ya que si primero se realizase el cociente

5/9, el resultado de la división entera sería cero, y el producto por el resultado de evaluar
el paréntesis sería también cero. Si tenemos dudas sobre la precedencia de operadores
podemos escribir

tC=((tF-32)*5)/9;
public class PrecedeApp {
public static void main(String[] args) {
int tF=80;
System.out.println("la temperatura Fahrenheit es "+tF);
int tC=(tF-32)*5/9;
System.out.println("la temperatura centígrada es "+tC);
}
}
La conversión automática y promoción (casting)

Cuando se realiza una operación, si un operando es entero (int) y el otro es de coma

flotante (double) el resultado es en coma flotante (double).

int a=5;
double b=3.2;
double suma=a+b;

Cuando se declaran dos variables una de tipo int y otra de tipo double.

int entero;
double real=3.20567;

¿qué ocurrirá cuando asignamos a la variable entero el número guardado en la

variable real? Como hemos visto se trata de dos tipos de variables distintos cuyo tamaño
en memoria es de 32 y 64 bits respectivamente. Por tanto, la sentencia

entero=real;

convierte el número real en un número entero eliminando los decimales. La

variable entero guardará el número 3.

Se ha de tener cuidado, ya que la conversión de un tipo de dato en otro es una fuente

frecuente de error entre los programadores principiantes. Ahora bien, supongamos que
deseamos calcular la división 7/3, como hemos visto, el resultado de la división entera
es 2, aún en el caso de que tratemos de guardar el resultado en una variable del
tipo double, como lo prueba la siguiente porción de código.

int ia=7;
int ib=3;
double dc=ia/ib;

Si queremos obtener una aproximación decimal del número 7/3, hemos de promocionar
el entero ia a un número en coma flotante, mediante un procedimiento denominado
promoción o casting.

int ia=7;
int ib=3;
double dc=(double)ia/ib;

Como aplicación, consideremos el cálculo del valor medio de dos o más números enteros

int edad1=10;
int edad2=15;
double media=(double)(edad1+edad2)/2;
El valor medio de 10 y 15 es 12.5, sin la promoción se obtendría el valor erróneo 12.

Imaginemos ahora, una función que devuelve un entero int y queremos guardarlo en
una variable de tipo float. Escribiremos

float resultado=(float)retornaInt();

Existen también conversiones implícitas realizadas por el compilador, por ejemplo

cuando pasamos un entero int a una función cuyo único parámetro es de tipo long.

Los operadores unarios

Los operadores unarios son:

 ++ Incremento
 -- Decremento

Actúan sobre un único operando. Se trata de uno de los aspecto más confusos para el
programador, ya que el resultado de la operación depende de que el operador esté a la
derecha i++ o a la izquierda ++i.

Conoceremos, primero el significado de estos dos operadores a partir de las sentencias

equivalentes:

i=i+1; //añadir 1 a i
i++;

Del mismo modo, lo son

i=i-1; //restar 1 a i
i--;

Examinemos ahora, la posición del operador respecto del operando. Consideremos en

primer lugar que el operador unario ++ está a la derecha del operando. La sentencia

j=i++;

asigna a j, el valor que tenía i. Por ejemplo, si i valía 3, después de ejecutar la

sentencia, j toma el valor de 3 e i el valor de 4. Lo que es equivalente a las dos sentencias

j=i;
i++;

Un resultado distinto se obtiene si el operador ++ está a la izquierda del operando

j=++i;
asigna a j el valor incrementado de i. Por ejemplo, si i valía 3, después de ejecutar la
sentencia j e i toman el valor de 4. Lo que es equivalente a las dos sentencias

++i;
j=i;
public class UnarioApp {
public static void main(String[] args) {
int i=8;
int a, b, c;
System.out.println("\tantes\tdurante\tdespués");
i=8; a=i; b=i++; c=i;
System.out.println("i++\t"+a+'\t'+b+'\t'+c);
i=8; a=i; b=i--; c=i;
System.out.println("i--\t"+a+'\t'+b+'\t'+c);

i=8; a=i; b=++i; c=i;

System.out.println("++i\t"+a+'\t'+b+'\t'+c);
i=8; a=i; b=--i; c=i;
System.out.println("--i\t"+a+'\t'+b+'\t'+c);

}
}

La salida del programa es, la siguiente

antes durante después

i++ 8 8 9
i-- 8 8 7
++i 8 9 9
--i 8 7 7

La primera columna (antes) muestra el valor inicial de i, la segunda columna (durante)

muestra el valor de la expresión, y la última columna (después) muestra el valor final
de i, después de evaluarse la expresión.

Se deberá de tener siempre el cuidado de inicializar la variable, antes de utilizar los

operadores unarios con dicha variable.

Los operadores relacionales

Revisando algunas definiciones matemáticas, nos enteramos de que los números
conforman un conjunto ordenado. Cada uno tiene una posición relativa. Sabemos que
el 2 "es menor que" el 4 y que el 6 "es más grande que" el 1. Al comparar dos números,
realizamos una función de relación.
En java disponemos de los operadores relacionales para verificar si se cumple una
relación. Por ejemplo el operador de equivalencia ( == ) nos devuelve un valor de
verdadero si los operandos son iguales. Estas operaciones comparan dos valores
numéricos y devuelven un valor booleano.

Operadores relacionales
Operador Utilización Resultado
> A>B verdadero si A es mayor que B
>= A >= B verdadero si A es mayor o igual que B
< A<B verdadero si A es menor que B
<= A <= B verdadero si A es menor o igual que B
== A == B verdadero si A es igual a B
!= A != B verdadero si A es distinto de B

Aquí tenemos un programa para ver el funcionamiento de estos operadores :

public class relaciones {

public static void main(String args[]){
int i = -3;
byte b = 5;
float f = 1e-10f;
double d = 3.14;
boolean b1 = i > i;
boolean b2 = i < b;
boolean b3 = b <= f;
boolean b4 = f >= d;
boolean b5 = d != 0;
boolean b6 = 1 == f;

System.out.println("b1: " + i + " > " + i + " = " + b1);

System.out.println("b2: " + i + " < " + b + " = " + b2);
System.out.println("b3: " + b + " <= " + f + " = " + b3);
System.out.println("b4: " + f + " >= " + d + " = " + b4);
System.out.println("b5: " + d + " != " + 0 + " = " + b5);
System.out.println("b6: " + 1 + " == " + f + " = " + b6);
}

No nos olvidemos de los char, que también participan. Podemos comparar caracteres,
pues internamente están almacenados como números.

char a = 'A';
char b = 'B';
boolean x = a > b;

Entre los booleanos solo se permiten los operadores de equivalencia, es igual (==) o es
distinto (!= )

boolean x = true;
boolean y = x == x;
boolean z = x != y;

Los operadores booleanos

Como deben suponer, trabajan con operandos booleanos. Realizan las operaciones
lógicas de conjunción (AND), disyunción (OR), negación (NOT) y la disyunción exclusiva
(XOR).

Operadores booleanos
Nombre Operador Utilización Resultado
verdadero cuando A y B son verdaderos. Evaluación
AND && A && B
condicional.
verdadero cuando A o B son verdaderos. Evaluación
OR || A || B
condicional.
NOT ! !A verdadero si A es falso.
verdadero cuando A y B son verdaderos. Siempre
AND & A&B
evalúa ambos operandos.
verdadero cuando A o B son verdaderos. Siempre
OR | A|B
evalúa ambos operandos.
XOR ^ A^B verdadero cuando A y B son diferentes

Cada una de estas operaciones tiene asociada una tabla de verdad. Esto nos permite ver
el resultado de un operador aplicado a las distintas combinaciones de valores que
pueden tener los operandos. A continuación mostraremos cómo se comporta el
operador AND mediante su tabla de verdad.

public class TablaAnd {

public static void main(String args[]){
boolean x = true;
boolean y = false;
boolean a1 = x && x;
boolean a2 = x && y;
boolean a3 = y && x;
boolean a4 = y && y;
 System.out.println("Tabla de verdad de la conjunción");
System.out.println( x + " AND " + x + " = " + a1 );
System.out.println( x + " AND " + y + " = " + a2 );
System.out.println( y + " AND " + x + " = " + a3 );
System.out.println( y + " AND " + y + " = " + a4 );
}

Si probamos a quitar un ampersand ( & ) del operador, vemos que obtenemos los
mismos resultados. Existen dos operadores AND, uno con dos símbolos & y el otro con
uno solo. También tenemos dos operadores OR.

boolean x1 = operando1 && operando2;

boolean x2 = operando1 & operando2;

boolean y1 = operando1 || operando2;

boolean y2 = operando1 | operando2;

Parece extraño, sobre todo porque tienen la misma tabla de verdad. Pero internamente
tienen un comportamiento diferente.
Cuando estamos en presencia de un operador con un solo símbolo, siempre se evalúan
ambos operandos. En cambio para el operador con el símbolo repetido, su evaluación
cambia según el valor del primer operando. Por ejemplo tenemos la siguiente operación.

boolean x = true && false;

El resultado es falso, pero el intérprete tiene que mirar el segundo operando para
saberlo.

boolean x = false && true

Aquí ni se molesta en mirar el último operando, porque la operación AND es verdadera

solamente cuando ambos operandos son verdaderos.
En el caso del operador OR, se evalúa el segundo operador si el primero es falso. Cuando
es verdadero, no tiene en cuenta el otro operando. El resultado es verdadero sin
importar el valor del segundo.
Veamos un caso extremo para mostrar cómo funciona la evaluación condicional.
Tenemos el siguiente programa en donde pretendemos hacer saltar al intérprete con un
error.
public class Condicional {
public static void main(String args[]){
int x = 0;
int y = 2;
boolean b = ( x != 0 ) && ( ( y / x ) != 0 );
System.out.println(b);
}
}

Sin ningún tipo de emoción, aburridamente el intérprete nos avisa que el resultado es
"false". Ahora verá. Quitemos un símbolo & y quedémonos con uno solo. El resultado es
otro :

java.lang.ArithmeticException: / by zero

La primera vez verificó que x!=0 era falso, entonces dio por terminada la operación con
el resultado falso. Cuando cambiamos de operador, evaluó los dos operandos y cayó en
nuestra trampa. Tuvo que calcular cuánto es y / x dando luego un error de división por
cero.
Los operadores booleanos son muy amigos de los relacionales. Se llevan bien porque los
últimos dan resultados booleanos. Entre ambos tipos de operadores se pueden construir
instrucciones más complejas.
Por ejemplo, queremos saber si un número está dentro de un rango. Solo tenemos que
compararlo con los extremos:

int y = 4;
boolean x = ( y > 3 ) && ( y < 6 );

Ahora deseamos saber si una variable tiene el valor "a" no importando si es mayúscula
o minúscula.

char c = 'b';
boolean x = ( c == 'a' ) || ( c == 'A' );

No olviden que el operador de equivalencia (==) tiene dos símbolos igual (=), si colocan
uno solo les dará un error de asignación.

Operadores de bits
El método más sencillo de representación son los números naturales. Por ejemplo, si
tengo el número 85 en decimal, solo tengo que llevarlo a binario y obtengo una serie de
unos y ceros:
1010101 = 85 en binario

Cada dígito (un cero o un uno) de este número se llama bit. Java tiene una serie de
operadores capaces de manipular estos dígitos, son los operadores de bits.
Operadores de bits

Operador Utilización Resultado

<< A << B Desplazamiento de A a la izquierda en B posiciones

Desplazamiento de A a la derecha en B posiciones, tiene en

>> A >> B
cuenta el signo.

Desplazamiento de A a la derecha en B posiciones, no tiene en

>>> A >>> B
cuenta el signo.

& A&B Operación AND a nivel de bits

| A|B Operación OR a nivel de bits

^ A^B Operación XOR a nivel de bits

~ ~A Complemento de A a nivel de bits

Para operar a nivel de bit es necesario tomar toda la longitud predefinida para el tipo de
dato. Estamos acostumbrados a desechar los ceros a la izquierda en nuestra
representación de números. Pero aquí es importante. Si trabajamos una variable de tipo
short con un valor de 3, está representada de la siguiente manera:

0000000000000011

Aquí los 16 bits de un short se tienen en cuenta.

Los operadores de desplazamiento, mueven los bits a la izquierda o a la derecha. El
primer operando será la victima a sacudir. El segundo indicará cuantas posiciones.
Desplazamiento a la izquierda
Deseamos correr el número 33 dos posiciones a la izquierda. Entonces realizamos :

int j = 33;
int k = j << 2;
Este es el resultado:

00000000000000000000000000100001 : j = 33
00000000000000000000000010000100 : k = 33 << 2 ; k = 132

Cada "hueco" que queda a la derecha tras correr este número se rellena con ceros. Los
bits a la izquierda se pierden, no es una operación de rotación. Si prestamos atención,
observaremos que esta operación multiplicó a j por 2 tantas veces como posiciones se
ha desplazado. En este caso se multiplicó por 4 ( 2 x 2 ). Hay que notar que el signo del
número puede cambiar tras la operación (por ejemplo 1 << 31 = -2147483648).
Desplazamiento a la derecha con signo
Volvamos a colocar como estaban los bits del caso anterior. Queremos obtener
nuevamente el número 33. Para esto desplazamos el número 132 dos posiciones a la
derecha.

int k = 132;
int m = k >> 2;

Como resultado obtenemos el número original.

00000000000000000000000010000100 : k = 132
00000000000000000000000000100001 : m = 132 >> 2 ; m = 33

Podemos ver que el corrimiento a la derecha realiza una división de enteros. Divide por
2, tantas veces como posiciones desplazadas.
Veamos qué ocurre si pretendemos realizar un desplazamiento a la derecha con un
número negativo. Tengan en cuenta que la representación de números es de
complemento a 2. Si tengo una variable de tipo int con el valor –1, internamente está
almacenada de la siguiente forma :

11111111111111111111111111111111 : -1 complemento a 2

Ahora realicemos un programa para ver qué ocurre con el desplazamiento.

public class CorreNeg {

public static void main(String args[]){
int x = -1;
int y = x >> 2;
System.out.println("El resultado es: " + String.valueOf(y));
}
}
La salida del programa nos indica que:

El resultado es: -1

Quedó exactamente igual. Prueben a desplazar el número tantas posiciones como

tengan ganas y obtendrán el mismo resultado. Esto ocurre porque en el desplazamiento,
los "huecos" que quedan a la izquierda se rellenan con el bit uno (1), quedando
inalterable.
Este operador desplaza el conjunto de bit a la derecha y agrega a la izquierda los bits
que faltan según el bit de signo, o sea el más significativo. Si se encuentra con un número
positivo, el bit de signo vale 0, entonces agrega ceros, en cambio si son negativos el bit
de signo vale 1, entonces agrega unos. Este proceso, denominado extensión de signo
mantiene el signo del número como si se tratara de una división. Por esto se lo conoce
como desplazamiento con signo.
Desplazamiento a la derecha sin signo
Modifiquemos ligeramente el programa anterior agregándole al operador un símbolo >.
Nos queda de esta manera :

int x = -1;
int y = x >>> 2;

Si ejecutamos el programa nos dice lo siguiente :

El resultado es: 1073741823

Veamos de donde salió este número raro. Si lo llevamos a binario tenemos :

00111111111111111111111111111111 : 1073741823 en binario

Ahora nos damos cuenta que se han agregado dos ceros a la izquierda. Este operador
desplaza a la derecha, pero no tiene en cuenta el signo. Siempre agrega bit con el valor
cero, por lo que se llama desplazamiento sin signo. Este operador suele ser más
adecuado que el >> cuando queremos manipular los bits mismos, no su representación
numérica.

Operadores lógicos de bits

Estos operadores extienden las operaciones booleanas a los enteros. Para comprender
como trabajan debemos descomponer los enteros en un conjunto de bits. El operador
aplicará una operación lógica bit por bit, tomando el valor de uno como verdadero y el
valor de cero como falso. De un operando toma un bit y aplica la operación al bit que
tiene la misma posición del segundo operando. Como resultado obtenemos otro entero.
Operador AND de Bits
Si ambos bits comparados son 1, establece el resultado en 1. De lo contrario da como
resultado 0.

int k = 132; // k: 00000000000000000000000010000100

int l = 144; // l: 00000000000000000000000010010000
int m = k & l; // m: 00000000000000000000000010000000

El resultado da 128

Operador OR de Bits
Si por lo menos uno de los dos bits comparados es 1, establece el resultado en 1. De lo
contrario da como resultado 0.

int k = 132; // k: 00000000000000000000000010000100

int l = 144; // l: 00000000000000000000000010010000
int m = k | l; // m: 00000000000000000000000010010100

El resultado da 148

Operador XOR de Bits

Si uno de los bits comparados es 0 y el otro 1, el resultado es 1. Si ambos bits comparados
son iguales, el resultado es 0.

int k = 132; // k: 00000000000000000000000010000100

int l = 144; // l: 00000000000000000000000010010000
int m = k ^ l; // m: 00000000000000000000000000010100

El resultado da 20

Operador NOT de Bits

Sólo invierte los bits, es decir, convierte los ceros en unos y viceversa. Observemos que
es el único de esta familia que tiene un solo operando.

int k = 132; // k: 00000000000000000000000010000100

int m = ~k; // m: 11111111111111111111111101111011

El resultado da -133

Como los enteros negativos en Java se representan con el método del complemento a
dos, podemos realizar un sencillo experimento de cambiarle el signo a un número. Para
realizarlo debemos aplicar a un entero el operador NOT y sumarle uno.

int x = 123;
int y = ~x;
int z = y + 1;

El resultado da -123,

PRECEDENCIA
Civilizadamente se organizan de acuerdo al nivel de precedencia de cada uno.
Primeramente proceden los unarios, luego los aritméticos, después los de bits,
posteriormente los relacionales, detrás vienen los booleanos y por último el operador
de asignación. La regla de precedencia establece que los operadores de mayor nivel se
ejecuten primero.
Precedencia de operadores

Descripción Operadores

operadores posfijos op++ op--

operadores unarios ++op --op +op -op ~ !

multiplicación y división */%

suma y resta +-

desplazamiento << >> >>>

operadores relacionales < > <= =>

equivalencia == !=

operador AND &

operador XOR ^

operador OR |

AND booleano &&

OR booleano ||

condicional ?:
operadores de asignación = += -= *= /= %= &= ^= |= <<= >>= >>>=

En la tabla se muestra el nivel de precedencia de los operadores. Los de mayor nivel se

encuentran arriba. Podemos ver que los últimos son los de asignación. Esto es lógico, ya
que se debe calcular primeramente la expresión antes de asignar un resultado a una
variable.
Veamos unos ejemplos de cómo actúa esta regla.

int j = 1 + 3 * 4; // resultado j = 13

Desde que aprendimos aritmética básica, conocemos la regla que nos obliga a calcular
la multiplicación antes de una suma. Esto también se cumple en Java.

int j = 1 + 3 – 4; resultado j= 0;

Si todos los operadores tienen un nivel idéntico de precedencia se evalua la expresión

de izquierda a derecha.

Utilización de paréntesis
Se utilizan para aislar una porción de la expresión de forma que el cálculo se ejecute de
forma independiente. Puede forzar a una expresión a ignorar las reglas de precedencia.

int j = 1 + 3 * 4; // resultado j = 13
int h = (1 + 3) * 4 // resultado h = 16

Tomando el primer ejemplo, forzamos al compilador a realizar la suma antes que la

multiplicación.
En este ejemplo es imprescindible la utilización de paréntesis:

int k = 1 + (h = 3);

Si quitamos los paréntesis el compilador protestará. Porque al establecer un nivel muy

bajo para la asignación, procede primero la suma. Pero estamos sumando con una
variable sin valor.
Como en matemáticas, podemos anidar los paréntesis. Se comenzara a evaluar los
internos hasta llegar a los externos.
Cabe agregar que los paréntesis no disminuyen el rendimiento de los programas. Por lo
tanto, agregar paréntesis no afecta negativamente al programa.

int k = ((12 - 2) * ( 21 - 11)) / ((1+1)*(15-10)) + 1 ;