Operadores compuestos de Java

1. Información general

En este tutorial, veremos los operadores compuestos de Java, sus tipos y cómo Java los evalúa.

También explicaremos cómo funciona el casting implícito.

2. Operadores de asignación compuesta

Un operador de asignación es un operador binario que asigna el resultado del lado derecho a la variable del lado izquierdo. El más simple es el operador de asignación "=" :

int x = 5;

Esta declaración declara una nueva variable x , asigna a x el valor de 5 y devuelve 5 .

Los operadores de asignación compuesta son una forma más corta de aplicar una operación aritmética o bit a bit y de asignar el valor de la operación a la variable en el lado izquierdo.

Por ejemplo, las siguientes dos declaraciones de multiplicación son equivalentes, lo que significa un y b tendrá el mismo valor:

int a = 3, b = 3, c = -2; a = a * c; // Simple assignment operator b *= c; // Compound assignment operator

Es importante tener en cuenta que la variable a la izquierda de un operador de asignación compuesta ya debe estar declarada. En otras palabras, los operadores compuestos no se pueden usar para declarar una nueva variable.

Al igual que el operador de asignación "=", los operadores compuestos devuelven el resultado asignado de la expresión:

long x = 1; long y = (x+=2);

Tanto x como y tendrán el valor 3 .

La asignación (x + = 2) hace dos cosas: primero, agrega 2 al valor de la variable x , que se convierte en 3; segundo, devuelve el valor de la asignación, que también es 3 .

3. Tipos de operadores de asignación compuesta

Java admite 11 operadores de asignación compuesta. Podemos agruparlos en operadores aritméticos y bit a bit.

Repasemos los operadores aritméticos y las operaciones que realizan:

Incremento: + =
Decrementación: - =
Multiplicación: * =
División: / =
Módulo: % =

Luego, también tenemos los operadores bit a bit:

Y, binario: & =
OR exclusivo, binario: ^ =
OR inclusivo, binario: | =
Desplazamiento a la izquierda, binario: << =
Desplazamiento a la derecha, binario: >> =
Desplazar relleno de cero a la derecha: >>> =

Echemos un vistazo a algunos ejemplos de estas operaciones:

// Simple assignment int x = 5; // x is 5 // Incrementation x += 5; // x is 10 // Decrementation x -= 2; // x is 8 // Multiplication x *= 2; // x is 16 // Modulus x %= 3; // x is 1 // Binary AND x &= 4; // x is 0 // Binary exclusive OR x ^= 4; // x is 4 // Binary inclusive OR x |= 8; // x is 12

Como podemos ver aquí, la sintaxis para usar estos operadores es consistente.

4. Evaluación de las operaciones de asignación compuesta

Hay dos formas en que Java evalúa las operaciones compuestas.

Primero, cuando el operando de la izquierda no es una matriz, Java lo hará, en orden:

Verifique que el operando sea una variable declarada
Guardar el valor del operando de la izquierda
Evaluar el operando de la derecha
Realice la operación binaria como lo indica el operador compuesto
Convierta el resultado de la operación binaria al tipo de la variable de la izquierda (conversión implícita)
Asignar el resultado convertido a la variable de la izquierda

A continuación, cuando el operando de la izquierda es una matriz, los pasos a seguir son un poco diferentes:

Verifique la expresión de matriz en el lado izquierdo y arroje una NullPointerException o ArrayIndexOutOfBoundsException si es incorrecta
Guarde el elemento de la matriz en el índice
Evaluar el operando de la derecha
Compruebe si el componente de matriz seleccionado es un tipo primitivo o de referencia y luego continúe con los mismos pasos que en la primera lista, como si el operando de la izquierda fuera una variable.

Si falla algún paso de la evaluación, Java no continúa realizando los siguientes pasos.

Demos algunos ejemplos relacionados con la evaluación de estas operaciones a un elemento de matriz:

int[] numbers = null; // Trying Incrementation numbers[2] += 5;

Como era de esperar, esto arrojará una NullPointerException .

Sin embargo, si asignamos un valor inicial a la matriz:

int[] numbers = {0, 1}; // Trying Incrementation numbers[2] += 5;

Nos desharíamos de la NullPointerException, pero aún obtendríamos una ArrayIndexOutOfBoundsException , ya que el índice utilizado no es correcto.

Si lo arreglamos, la operación se completará con éxito:

int[] numbers = {0, 1}; // Incrementation numbers[1] += 5; // x is now 6

Finalmente, la variable x será 6 al final de la tarea.

5. Casting implícito

Una de las razones por las que los operadores compuestos son útiles es que no solo proporcionan una forma más corta de operaciones, sino también implícitamente emitir variables.

Formalmente, una expresión de asignación compuesta de la forma:

E1 op = E2

es equivalente a:

E1 - (T) (E1 op E2)

donde T es el tipo de E1 .

Let’s consider the following example:

long number = 10; int i = number; i = i * number; // Does not compile

Let’s review why the last line won’t compile.

Java automatically promotes smaller data types to larger data ones, when they are together in an operation, but will throw an error when trying to convert from larger to smaller types.

So, first, i will be promoted to long and then the multiplication will give the result 10L. The long result would be assigned to i, which is an int, and this will throw an error.

This could be fixed with an explicit cast:

i = (int) i * number;

Java compound assignment operators are perfect in this case because they do an implicit casting:

i *= number;

Esta declaración funciona bien, lanzando el resultado de la multiplicación a int y asignando el valor a la variable del lado izquierdo, i .

6. Conclusión

En este artículo, analizamos los operadores compuestos en Java, dando algunos ejemplos y diferentes tipos de ellos. Explicamos cómo Java evalúa estas operaciones.

Finalmente, también revisamos la conversión implícita, una de las razones por las que estos operadores de taquigrafía son útiles.

Como siempre, todos los fragmentos de código mencionados en este artículo se pueden encontrar en nuestro repositorio de GitHub.