Operadores

Operadores

Claro está que un programa no puede estar compuesto únicamente por declaraciones y asignaciones de variables. Debemos procesar los datos de entrada para obtener un resultado, y para ello, debemos utilizar operadores.

Los operadores son empleados para realizar operaciones entre variables y valores. En Java, existen varios tipos de operadores, los cuales se clasifican en operadores aritméticos, operadores de asignación, operadores de comparación y operadores lógicos.

Operadores aritméticos

Los operadores aritméticos que se encuentran disponibles en Java son los siguientes:

Operador	Nombre	Descripción	Ejemplo
+	Suma	Suma dos valores	x + y
-	Resta	Resta dos valores	x - y
*	Multiplicación	Multiplica dos valores	x * y
/	División	Divide dos valores	x / y
%	Módulo	Devuelve el resto de la división entera entre dos valores	x % y

Debemos tener en cuenta que los operadores aritméticos solo pueden ser empleados con valores numéricos, es decir, con valores de tipo byte, short, int, long, float o double. Por lo cual, no podríamos sumar dos valores de tipo char ni de tipo boolean.

char letra = 'a';
char otraLetra = 'b';
char suma = letra + otraLetra; //error: incompatible types: possible lossy conversion from int to char

Estos operadores son ampliamente utilizados en programación, ya que son la base de muchos algoritmos.

Por ejemplo, una operación típica es incrementar el valor de una variable en una unidad. Es decir, emplear la variable en cuestión para contar la cantidad de veces que se realiza una acción.

int contador = 0;
contador = contador + 1; // contador = 1
contador = contador + 1; // contador = 2
contador = contador + 1; // contador = 3

En este caso, la variable contador se inicializa con el valor 0, y luego se incrementa en una unidad. En la segunda línea, la variable contador se evalúa y se le asigna el valor de contador + 1, es decir, 0 + 1, que es 1. Así, en cada línea, la variable contador se incrementa en una unidad.

Esta operación es tan común, que existe un operador especial para realizarla, el operador de incremento (++).

int contador = 0;
contador++;
contador++;
contador++;

De manera complementaria, existe el operador de decremento (--), el cual decrementa en una unidad el valor de una variable.

int contador = 3;
contador--;
contador--;
contador--;

Operadores de asignación

Como vimos anteriormente, el operador de asignación (=) es fundamental para realizar prácticamente cualquier operación en Java.

Sin embargo, existen otros operadores de asignación que nos permiten realizar una operación aritmética y asignar el resultado a una variable en una sola sentencia, simplificando así el código y haciéndolo más legible.

Operador	Descripción	Ejemplo
+=	Suma y asigna	x += y es equivalente a x = x + y
-=	Resta y asigna	x -= y es equivalente a x = x - y
*=	Multiplica y asigna	x *= y es equivalente a x = x * y
/=	Divide y asigna	x /= y es equivalente a x = x / y
%=	Módulo y asigna	x %= y es equivalente a x = x % y

Operadores de comparación o relacionales

Los operadores de comparación o operadores relacionales son aquellos que nos permiten comparar dos valores estableciendo una relación de orden entre ellos.

Resultado

El resultado de una operación de comparación es siempre un valor booleano (true o false).

Los operadores de comparación disponibles en Java son los siguientes:

Operador	Descripción	Ejemplo
==	Igual a	x == y
!=	Distinto de	x != y
>	Mayor que	x > y
<	Menor que	x < y
>=	Mayor o igual que	x >= y
<=	Menor o igual que	x <= y

Por ejemplo, si queremos comparar si dos valores son iguales, podemos utilizar el operador ==.

int num1 = 5;
int num2 = 5;
System.out.println(num1 == num2); // true

En este caso, el operador == evalúa si el valor de num1 es igual al valor de num2. Como ambos valores son iguales, el resultado de la operación es true.

Veremos que estos operadores son fundamentales para controlar el flujo de ejecución de un programa, es decir, para decidir qué instrucciones se ejecutan y cuáles no.

Operadores lógicos

Ahora que conocemos los operadores de comparación, podría surgir la necesidad de combinarlos para realizar operaciones más complejas. Es decir, establecer más de una condición para que se cumpla una operación. Para ello, utilizaremos los operadores lógicos.

Nota

Las operaciones lógicas evalúan dos o más valores booleanos y devuelven un valor booleano como resultado. Dependiendo del operador, la operación lógica puede evaluar todos los valores booleanos o solo algunos de ellos.

Las operaciones lógicas disponibles en Java son las siguientes:

Operador	Nombre	Descripción	Ejemplo
&&	AND	Devuelve true si todos los valores booleanos son true	x && y
||	OR	Devuelve true si al menos uno de los valores booleanos es true	x || y
!	NOT	Devuelve el valor opuesto del valor booleano	!x

Por ejemplo, si queremos evaluar si dos valores son mayores que cero, podemos utilizar el operador && (AND).

int num1 = 5;
int num2 = 5;
System.out.println(num1 > 0 && num2 > 0); // true

Es importante resaltar que al usar este operador, la segunda condición solo se evalúa si la primera condición es true. Esto se conoce como evaluación de cortocircuito.

Por ejemplo, si la primera condición es false, la segunda condición no se evalúa, ya que el resultado de la operación lógica será false de todas maneras.

int num1 = -5;
int num2 = 5;
System.out.println(num1 > 0 && num2 > 0); // false

Por otro lado, si queremos evaluar si al menos uno de los valores es mayor que cero, podemos utilizar el operador ||.

int num1 = -5;
int num2 = 5;
System.out.println(num1 > 0 || num2 > 0); // true

Para una operación lógica OR, la segunda condición solo se evalúa si la primera condición es false. Es decir, si la primera condición es true, carece de sentido evaluar la segunda condición, ya que el resultado de la operación lógica será true de todas maneras.

El siguiente caso es un ejemplo de evaluación de cortocircuito, donde la segunda condición no se evalúa.

int num1 = 5;
int num2 = 5;
System.out.println(num1 > 0 || num2 > 0); // true

Por último, si queremos invertir el valor de un booleano, podemos utilizar el operador de negación !.

boolean encendido = true;
System.out.println(!encendido); // false

Claro está que podemos combinar operadores de comparación y operadores lógicos para realizar operaciones más complejas.

Precedencia de operadores

Cuando combinamos operadores, debemos tener en cuenta que algunos operadores se evalúan antes que otros. Esencialmente, los operadores aritméticos se evalúan antes que los operadores de comparación, y los operadores de comparación se evalúan antes que los operadores lógicos.

Por ejemplo, si queremos evaluar si el resultado de una suma es mayor que cero, debemos utilizar paréntesis para indicar que la suma se evalúa antes que la comparación.

System.out.println((5 + 5) > 0 && (5 - 5) > 0); // false

En este caso, el orden de evaluación es el siguiente:

• Primero, se evalúan la suma (5 + 5), cuyo resultado es 10, y la resta (5 - 5), cuyo resultado es 0.
• Luego, se evalúa la comparación 10 > 0, cuyo resultado es true y 0 > 0, cuyo resultado es false.
• Por último, se evalúa la operación lógica true && false, cuyo resultado es false.