Buenas tardes, en esta entrada vamos a ver en gran parte los Operadores en Java. Los operadores en Java producen nuevos valores desde uno o mas operandos. El resultado de la mayoría de las operaciones será un tipo de dato boolean o numérico. Como ya sabemos esto es Java y no C++, así que no nos sorprendamos si los operadores en Java no son sobrecargados. Hay, sin embargo, unos operadores que son sobrecargados como excepción:
- El operador + puede ser usado para sumar 2 primitivos numéricos entre sí, o para realizar operaciones de concatenación si alguno de los operandos es un String.
- Los operadores &, | y ^ pueden ser todos usados de dos maneras diferentes.
Con esta pequeña introducción, podemos ponernos manos a la obra.
-
Operadores de Asignación
Hemos cubierto en anteriores entradas la funcionalidad del operador de asignación “=”. Para resumir:
- Cuando asignamos un valor a un primitivo, el tamaño importa. Tenemos que estar seguro de saber cuando va a ocurrir un casting implícito, cuando un casting explícito es necesario, y cuando puede truncarse el valor.
- Recordemos que una variable de referencia no es el objeto, es una manera de acceder al objeto.
- Cuando asignamos un valor a una variable de referencia, el tipo importa. Recordemos las reglas de los supertipos, subtipos y arrays.
Lo siguiente que cubriremos serán algunos detalles mas sobre los operadores de asignación.
-
Operadores de Asignación Compuestos
Hay actualmente 11 operadores de asignación compuestos, pero solo son 4 los que mas se suelen usar comúnmente ( +=, -=, *=, y /=). Vamos a ver unos cuantos ejemplos de asignaciones, primero sin el uso de los operadores compuestos.
x = y - 6; x = x + 2 * 5;
Ahora con operadores compuestos:
y -= 6; x += 2 * 5;
Las primeras 2 asignaciones dan el mismo resultado que las dos últimas.
-
Operadores Relacionales
Vamos a ver los operadores relacionales mas usados (<, =, == y !=). Los operadores relacionales siempre resultan en un boolean (true o false). Este valor boolean es la mayoría de veces usado en un test if, como el siguiente caso:
int x = 5; if (x < 9){ // hacer algo }Igualmente, el valor resultante puede ser también directamente asignado a un primitivo boolean:
class CompareTest{ public static void main (String[] args){ boolean b = 100 > 99; System.out.println("El valor de b es " + b); } }Java tiene 4 operadores relacionales que pueden ser usados para comparar cualquier combinacion de enteros, puntos flotantes, o caracteres:
- > Mayor que
- >= Mayor o igual que
- < Menor que
- <= Menor o igual que
Vamos a ver algunas comparaciones legales:
class GuessAnimal{ public static void main(String[] args){ String animal = "unknown"; int weight = 700; char sex = 'm'; double colorWaveLength = 1.630; if (weight >= 500){ animal = "elephant"; } if (colorWaveLength > 1.621){ animal = "gray " + animal; } if (sex <= 'f'){ animal = "female " + animal; } System.out.println("El animal es un " + animal); } }En el ejemplo anterior, estamos usando comparación entre caracteres. Es legal hacer este tipo de comparaciones de primitivos caracter con un número (aunque no sea un estilo de programación muy bueno).
Hemos mencionado que los caracteres pueden ser usados con operadores de comparación. Cuando comparamos un caracter con otro caracter, o un caracter con un número, Java usará el valor Unicode del caracter como valor numérico, para la comparación.
-
Operadores de Igualdad
Java tambien tiene 2 operadores relacionales que comparan dos “cosas” similares y retornan un valor boolean que representa si es verdad o no que las dos “cosas” son iguales. Estos operadores son:
- == Igual (Tambien conocido como “Igual a”)
- != No igual (Tambien conocido como “No igual a”)
Cada comparación individual puede invocar 2 numeros (incluyendo un caracter), 2 valores booleanos, o 2 variables de referencia a un objeto. No podemos comparar, sin embargo, tipos incompatibles. Es decir, no podríamos comparar un tipo de valor booleano con un char. Hay 4 tipos diferentes de datos que pueden ser probados:
- Números
- Caracteres
- Primitivos booleanos
- Variables de referencia a objetos
¿Que es lo que == busca? El valor en la variable, o en otras palabras, el patrón de bits.
-
Igualdad para primitivos
La mayoría de los programadores son familiares con la comparación de valores primitivos. El siguiente código nos muestra algunos test de igualdad en variables primitivas.
class ComparePrimitives{ public static void main (String[] args){ System.out.println("char 'a' == 'a'? " + ('a' == 'a')); System.out.println("char 'a' == 'b'? " + ('a' == 'b')); System.out.println("5 != 6? " + (5 != 6)); System.out.println("5.0 == 5L? " + (5.0 == 5L)); System.out.println("true == false? " + (true == false)); } } -
Igualdad para Variables de Referencia
Como hemos visto anteriormente, 2 variables de referencia pueden referirse a un mismo objeto, como el siguiente snippet de código nos demuestra:
JButton a = new JButton("Exit"); JButton b = a;
Después de ejecutar este código, ambas variables, tanto a como b se referirán al mismo objeto (Un objeto JButton con la etiqueta Exit). Las variables de referencia pueden ser testeadas para ver si se refieren al mismo objeto usando el operador ==. recordemos, el operador == busca los bits en al variable, por lo que para la variable de referencia significa que si los bits en ambas referencias son identicos, entonces ambos se refieren al mismo objeto. Vamos a ver sl siguiente código:
import javax.swing.JButton; class CompareReference{ public static void main(String[] args){ JButton a = new JButton("Exit"); JButton b = new JButton("EXIT"); JButton c = a; System.out.println("Es referencia a == b? " + (a == b)); System.out.println("Es referencia a == c? " + (a == c)); ] ]Este código crea 3 variables de referencia. Las 2 primeras, a y b, son 2 objetos JButton separados que parece que tienen la misma etiqueta. La tercera variable de referencia, c, es inicializada para que se refiera al mismo objeto al que a se refiere. Si ejecutamos este programa, la siguiente salida será lo que veremos:
Es referencia a == b? false Es referencia a == c? true
Esto nos muestra que a y c se refieren a la misma instancia de JButton. El operador == no comprobará si los 2 objetos son “Significativamente equivalentes”.
-
Igualdad para Enumeraciones
Una vez que hemos declarado una enumeración, no se puede expandir. En tiempo de ejecución, no hay manera de añadir mas enumeraciones constantes adicionales. Por supuesto, podemos tener tantas variables como queramos que se refieran a una constante de la enumeración, por lo que es importante ser capaces de comparar 2 variables de reefrencia a enumeraciones para ver si son “iguales”, por ejemplo si se refieren a la misma constante de la enumeración. Podemos usar el operador == o el método equals() para determinar si 2 variables se están refiriendo a la misma constante de la enumeración:
class enumEqual{ enum Color{RED, BLUE} // ; es opcional public static void main(String[] args){ if (c1 == c2){ System.out.println("==");} if (c1.equals(c2)){ System.out.println(". equals");} } }Esto producirá la salida en pantalla:
== . equals
-
Comparación instanceof
El operador instanceof es usado para variables de referencia a objetos únicamente, y podemos usarlo para comprobar cuando un objeto es de un tipo particular. Por tipo, queremos decir clase o tipo de interface. Veamos el siguiente ejemplo:
public static void main (String[] args){ String s = new String("foo"); if (s instance of String){ System.out.println("s es un String"); } }Esto imprimirá lo siguiente: s es un String.
Incluso cuando el objeto que está siendo comprobado no es una instanciación actual del tipo de la clase al lado derecho del operador, instanceof retornará true si el objeto siendo comparado es uan asignación compatible con el tipo de la derecha.
El siguiente ejemplo demuestra un uso común para instanceof: comprobar si un objeto es una instancia d euno de sus subtipos, antes de intentar un “downcast”:
class A{} class B extends A{ public static void main (String[] args){ a myA = new B(); m2(myA); } public static void m2(A a){ if (a instanceof B){ ((B)a).doBstuff(); } } public static void doBstuff(){ System.out.println("'a' se refiere a un B"); } }El código anterior compila y produe al salida:
'a' se refiere a un B
En ejemplos como este, el uso del operador instanceof protege al programa de intentar downcast ilegales.
Podemos comprobar si al referencia a un objeto contra su tipo de clase, o cualquiera de sus superclases. Esto significa que cualquier referencia aun objeto evaluará a true si usamos el operador instanceof contra cualquier tipo Object, como lo siguiente:
B b = new B(); if (b instanceof Object){ System.out.println("b es definitivamente un Object"); }Esto haría que por pantalla saliera: b es definitivamente un Object
En adición, es legal no comprobar cuando hay una referencia a null en una clase. Esto siempre resultará falso, por supuesto. Un ejemplo:
class InstanceTest{ publci static void main (String[] args){ String a = null; boolean b = null instanceof String; boolean c = a instanceof String; System.out.println("b + " " + c); } }Esto imprimiría: false false.
-
Error de compilación con instanceof
No podemos usar el operador instanceof para comprobar entre 2 jerarquías de clases diferentes, por ejemplo, lo siguiente NO compilará:
class Cat{} class Dog{ public static void main (String[] args){ Dog d = new Dog(); System.out.println(d instanceof Cat); } }La compilación fallaría, no hay manera de que d pudiera ser nunca o referirse a Cat o un subtipo de Cat.
En la siguiente tabla podemos ver un buen ejemplo del operador instanceof dado lo siguiente:
interface Face{} class Bar implements Face{} class Foo extends Bar{}Primer Operando Operando instanceof Resultado null Cualquier clase o tipo de interface false Instancia de Foo Foo, Bar, Face, Object true Instancia de bar Bar, Face, Object true Instancia de Bar Foo false Foo[] Foo, Bar, Face false Foo[] Object true Foo[1] Foo, bar, Face, Object true -
-
Operadores Aritméticos
Tenemos que estar seguros de estar familiarizados con estos operadores aritméticos básicos:
- + Adición
- – Substracción
- + Multiplicación
- / División
Estos pueden usarse de manera estándar:
int x = 5 + 3; int y = x - 4; System.out.println("x - 4 es " + y);
-
El operador Resto (%)
Un operador con el cual puede que no estemos muy familiarizados es el operador de resto, el %. El operador de resto divide el operando de la izquierda pro el operando de la derecha, y el resultado es el resto, como el siguiente código muestra:
class MathTest{ public static void main (String[] args){ int x = 15; int y = x % 4; System.out.println("El resultado de 15 % 4 es el " + " resto de dividir 15 entre 4. El resto es " + y); } }Si ejecutamos la clase MathTest imprimirá lo siguiente:
El resultado de 15 % 4 es el resto de dividir 15 entre 4. El resto es 3
-
Operador de Concatenación de String
El signo + puede tambien ser usado para concatenar 2 cadenas de caracteres entre sí, como vimos anteriormente, y volveremos a ver de nuevo:
String animal = "Grey " + "elephant";
La concatenación de cadenas se vuelve interesante cuando intentamos combinar numeros con String. Obserevmos lo siguiente:
String a = "String"; int b = 3; int c = 7; System.out.println(a + b + c);
Con el operador +, ¿Actuará de forma que sume las variables b y c? ¿O tratará al 3 y al 7 como caracteres, y los concatenará individualmente? ¿Será el resultado String10 o String37?. Los valores int son simplemente tratados como caracteres ya que están posicionados al lado derecho del String, dando el siguiente resultado:
String37
Podríamos leer el anterior código como lo siguiente:
Empezamos con un String a, String, y le añadimos el caracter 3 (el valor de b) a el, para producir una nueva cadena String3, y entonces añadimos el caracter 7 (el valor de c) a el, lo que producirá la salida de una nueva cadena String37, y entonces lo imprimimos.
Sin embargo, si ponemos parentesis alrededor de las 2 variables enteras, como lo siguiente:
System.out.println("a + (b + c));
Obtendremos lo siguiente: String10
Usando parentesis causa que (b + c) se evaluen primero, por lo que lo que haya a la derecha del operador + funcionará como un operador de adición, lo que dará a ambos operandos valores enteros. La clave aquí es que dentro de los parentesis, el operador a mano izquierda no es un String. Si lo fuera, entonces el operador + realizaría una concatenación de cadenas. El anterior código podría ser leido como:
Sumamos el valor de b + c entre ellos, entonces cogemos al suma y al convertimos en un String y lo concatenamos con el String de la variable a
Lo que tenemos que recordar de esto es:
Si alguno de los operandos es un String, el operador + se convierte en un operador de concatenación de String. Si ambos operandos son números, el operador + actúa como operador de adición.
Podremos encontrar algún problema decidiendo, si, el operador a mano izquierda será un String o no. Veamos el siguiente código:
System.out.println(x.foo() + 7);
No podemos saber como se usará el operando + en este caso hasta que sepamos que retorna el método foo(). Si foo() retorna un String, entonces 7 se concatenará a lo que se retorne. Pero si foo() retorna un número, entonces el operador + será usado para sumar 7 al valor retornado por foo().
Finalmente, necesitamos saber si es legal si usar el operador de composición de adición con Strings, como lo siguiente:
String s = "123"; s += "45"; s += 67; System.out.println(s);
Desde que ambas veces el oeprador += fué usado y el operador de la izquierda era un String, ambas operaciones eran concatenaciones, resultando:
1234567
-
Operadores de Incremento y Decremento
Java tiene 2 operadores que incrementarán o decrementarán una variable en 1 exactamente. Estos operadores son comparados por tener 2 signos de + (++) o 2 signos de – (–):
- ++ Incremento (Pre y Post)
- — Decremento (Pro y Post)
El operador se coloca antes (en el caso de que sea prefijo) o despues (en el caso de que sea sufijo) de una variable para cambiar su valor. Donde se coloque el operador antes o despues del operando puede cambiar la salida de la expresión. Examinemos lo siguienet:
class MathTest{ static int players = 0; public static void main (String[] args){ System.out.println("Jugadores online: " + players++); System.out.println("El valor de jugadores es " + players); System.out.println("El valor de jugadores ahora " + ++players); } }Vemos que en la cuarta línea del programa el operador que incrementa está después de la variable players. Esto significa que estamos usando el operador de postincremento, lo cual causa que players sea incrementado en 1 pero solo DESPUES de que el valor de players sea usado en al expresión. Cuando ejecutamos el programa, la salida es la siguiente:
Jugadores online: 0 El valor de jugadores es 1 El valor de jugadores ahora es 2
Vemos que la variable es escrita en la pantalla, al principio dice que el valor es 0. Como usamos el operador de postincremento, el incremento no ocurre hasta que la variable players ha sido usada en la sentencia de print. El post significa despues. En la linea 5 no ocurre incremento en players, es solo una salida del valor por pantalla, por lo que el valor que ha sido incrementado y mostrado es 1. En la linea 6 se aplica el preincremento a players, lo que significa que el incremento ocurre antes de que el valor de la variable sea usado, por lo que la salida es 2.
int x = 2; int y = 3; if ((y == x++) | (x < ++y)){ System.out.println("x = " + x + " y = " + y); }El código anterior imprime: x = 3 y = 4
Podemos leer el código como lo siguiente: Si 3 es igual a 2 o 3 < 4"
La primera expresión compara x e y, y el resultado es falso, ya que el incremento no ocurre hasta después de que el test de igualdad se realice. Despues, incrementamos x, por lo que ahora x es 3. Entonces comprobamos si x es menor que y, pero el incremento de y ocurre antes de la comparación con x, por lo que el segundo test lógico es 3 < 4. El resultado es true, por lo que la sentencia de print ocurre.
-
Operadores Condicionales
El operador condicional es un operador ternario (tiene 3 operandos) y es usado para evaluar expresiones booleanas, al igual que una sentencia if con la diferencia de que en vez de ejecutar un bloque de código si el test es true, un operador condicional asignará el valor a al variable. En otras palabras, la finalidad de un operador condicional es decidir cual de los 2 valores asignar a la variable. Este operador es construido usando ? y :. El parentesis es opcional. Su estructura es:
x = (expresion booleana) ? valor que asignar si es true : valor que asignar si es falso
Vamos a echar un vistazo al operador condicional:
class Salary{ public static void main (String[] args){ int numOfPets = 3; String status = (numOfPets<4) ? "Pet limit not exceeded" : "too many pets"; System.out.println("This pet status is " + status); } }Podemos leerlo de la siguiente forma:
Establecemos numOfPets a 3. Despues vamos a asignar una String a la variable status. Si el numOfPets es menor que 4, asignamos “Pet limit not exceeded” a la variable status, en caso contrario, asignamos “too many pets” a la variable status.
Un operador condicional empieza con una operacion boolean, seguida de 2 valores posibles para la variable que se encuentra a la izquierda del operador =. El primer valor, el que se encuentra a la izqueirda de los 2 puntos : es asignado si la comprobación es true, y el segundo valor es el asignado en caso de que sea false. Podemos tambien enlazar operadores condicionales en una sentencia:
class AssignmentOps{ public static void main (String[] args){ int sizeOfYard = 10; int numOfPets = 3; String status = (numOfPets<4) ? "Pet count Ok" : (sizeOfYard > 8) ? "Pet limit on the edge" : "too many pets"; System.out.println("Pet status is " + status); } } -
Operadores Lógicos
-
Operadores Bit a Bit
Estos operadores son algo confusos. Los 3 operadores &, | y ^ pueden ser usados como operadores “bit a bit”. Aquí tenemos unas sentencias legales de estos operadores bit a bit:
byte b1 = 6 & 8;
byte b2 = 7 | 9;
byte b3 = 5 ^ 4;
System.out.println(b1 + " " + b2 + " " + b3); -
Operadores Lógicos Corto-Circuito
Hay 5 operadores lógicos que son usados para evaluar sentencias que contienen mas de una expresión booleana. Lo mas usado comúnmente de los 5 son los 2 operadores lógicos corto-circuitos. Ellos son:
- && corto-circuito AND
- || corto-circuito OR
Son usadas para enlazar pequeñas epresiones booleanas entre ellas para formar una expresión booleana mas grande. los operadores && y || evalúan solo valores voleanos. Para que una expresión AND (&&) sea true, ambos operandos deben ser true. Por ejemplo:
if ((2 < ·) && (3 < 4)){}La expresión anterior evalúa a true cuandoa mbos operandos sean true.
La caracteristica corto-circuito del operador && es así nombrado porque no pierde tiempo en evaluaciones sin sentido. Evalúa el lado izquierdo de la operación primero (el oeprando uno), y si este es false, el operador && no pasa al segundo operador que está ubicado a la derecha en la expresión, ya que el operador && ya sabe que no hay manera de que la expresión completa pueda ser true.
class Logical{ public static void main (String[] args){ boolean b = true && false; System.out.println("boolean b = " + b); } }Cuando ejecutemos el código anterior, obtenemos: boolean b = false.
El operador || es similar al operador &&, excepto porque éste evalúa a true si uno de ambos operadores es true. Si el primer operando en una operación OR es true, el resultado será true, por lo que el || no perderá tiempo en mirar el lado derecho de la ecuación. Si el primer operando es falso, sin embargo, el || tendrá que evaluar el segundo operando para ver si el resultado de la operación OR será true o false. Pongamos atención al siguiente ejemplo:
class TestOR{ public static void main (String[] args){ if ((isItSmall(3)) || (isItSmall(7))){ System.out.println("Result is true"); } if ((isItSmall(6)) || (isItSmall(9))){ System.out.println("Result is true"); } } public static boolean isItSmall(int i){ if (i < 5){ System.out.println("i < 5"); return true; }else{ System.out.println("i >= 5"); return false; } } }¿Cuál será el resultado?
i < 5 Result is true i >= 5 i >= 5
Aquí vemos lo que ha pasado cuando se ha ejecutado el método main():
- Cuando llega a la línea 3, el primer operando en la expresión || se evalúa.
- El método isItSmall(3) es invocado, y imprime “i < 5", y retorna true.
- Ya que el primer operando en al expresión || de la linea 3 es true, el operador || no evalua el segundo operando. Por lo que nunca veremos “i >= 5” que sería printado si el segundo operando fuera evaluado (El que habría invocado isItSmall(7)).
- La linea 6 es evaluada, empezando con el primer operando en al expresion ||.
- El método isItSmall(6) es llamado, e imprime “i >= 5”, y retorna false.
- Ya que el primer operando en la expresion || en la linea 6 es falsa, el operador || no puede saltarse el segundo operando, por lo que aún hay posibilidades de que la expresión sea true, si el segundo operando evaluara a true.
- El método isItSmall(9) es invocado y imprime “i >= 5”.
- El método isItSmall(9) retorna false, por lo que la expresion de la linea 6 es falsa, y la linea 7 nunca se ejecuta.
-
Operadores Lógicos (No corto-circuito)
Hay 2 operadores lógicos que no son corto-circuito.
- & AND no corto-circuito.
- | OR no corto-circuito.
Hay operadores que son usados en expresiones lógicas como && y ||, pero ya que estos no son operadores corto-circuito, se evalúan ambos lados de la expresión, siemre. Son algo ineficientes. Por ejemplo, si el primer operando (en el lado izquierdo) en una expresión con & es false, el segundo operando seguirá siendo evaluado, aunque sea imposible que el resultado sea true. Y el operador | es igual de ineficiente, si el primer operando es true, la JVM sigue llendo al segundo operando incluso cuando sabe que la expresión va a ser true.
-
Operadores Lógicos ^ y !
Los últimos operadores lógicos son:
- ^ OR exclusivo (XOR)
- ! boolean invertido
El operador ^ evalua solo valores booleanos. El operador ^ se relaciona con los operadores que no son conrto-circuito que acabamos de ver, en que siempre evalúa ambos lados, derecha e izquierda en una expresión. Para que una expresión OR-exclusiva (^) sea true, uno de los 2 operandos debe ser true EXACTAMENET, por ejemplo:
System.out.println("xor " + ((2<3) ^ (4>3)));
Produce la salida: xor false
La expresión anterior se evalúa a false porque AMBOS operandos son evaluados a true.
El operador de boolean invertido (!) retorna el opuesto del valor boolean actual:
if (!(7 == %)){ System.out.println("not equal");}Podría leerse: “Si no es verdad que 7 == 5”, y la sentencia produce lo siguiente: “not equal”. Aquí otro ejemplo usando booleanos:
boolean t = true; boolean f = false; System.out.println("! " + (t & !f) + " " + f);
Produce al salida: ! true false
Como vemos en el anterior ejemplo, se ve que el test & pasa, imprimiendo true, y el valor de la variable f no cambia, por lo que imprime false.
-
Con este tema hemos visto mas en profundidad como funcionan muchos de los operadores en Java, y como actúan algunos de ellos en las diferentes situaciones.
Cualquier aporte o corrección es bienvenido.
Saludos!!!