Operaciones entre variables en Java

Hola a todos los lectores del blog, en esta oportunidad vamos a hablar de las operaciones entre variables en Java.

Según la cantidad de elementos o miembros en una expresión, podemos decir que existen dos clases de operadores, binarios y unarios; y según el tipo de expresión que tratamos los podemos clasificar en operadores aritméticos, relacionales, lógicos y de concatenación.

Operadores aritméticos

Dentro de esta clase de operadores, tenemos a la suma (+), resta (-), multiplicación (*), división (/), y tenemos también al operador "módulo" (%), que obtiene el residuo de la división. Todos los mencionados anteriormente son operadores binarios, puesto que para utilizarlos es necesario tener 2 operandos.

Como operador unario tenemos a la negación aritmética (-), sólo necesita un operador. Por ejemplo: -3, -5, etc;

 

Operadores relacionales

Todos los operadores relacionales son binarios, y estos son: Menor que (<), Mayor que (>), Menor o igual que (<=), Mayor o igual que (>=), Igual que (==) y el operador Diferente que (!=)

El resultado de cualquiera de estas expresiones, es un resultado lógico (verdadero o falso), es decir un boolean.

 

Operadores lógicos

Los operadores lógicos son: Y (binario) (&&), O (binario) (||), y negación (unario) (!)
Existen también unas variantes de los operadores Y/O que son simplemente &/| respectivamente, las diferencias las veremos cuando ocupemos el tema de condicionales. Por el momento hay que saber que las más usadas con las mencionadas en la primera línea (&&, ||, !)

Los resultados de estas operaciones son de tipo boolean.

Hasta el momento nada es nuevo, lo interesante es observar el resultado de las expresiones. Voy a poner un ejemplo, y quisiera que primero prueben y observen el resultado y luego continúen leyendo el post. Aquí va:

int c;

c = 5 / 2;

System.out.println(c);

¿Cuál es el resultado? ¿Por qué?
La respuesta es simple. En el caso de la división, cuando los dos operandos son enteros, el resultado también es entero. Por lo tanto, al dividir 5 entre 2, el cociente es 2, y el residuo es 1. Por ello, si cambiamos la operación por:

c = 5 % 2;

El resultado ahora es 1. Por lo tanto, y siguiendo esta lógica, si queremos obtener la división exacta de una división, no basta con que la variable sea un float, podemos probar lo siguiente para darnos cuenta:

float c;

c = 5 / 2;

System.out.println(c);

¿Y ahora por qué el resultado es 2.0, si la variable c ahora es float? La respuesta es la misma. Porque los elementos de la operación (5 / 2) son enteros, y el resultado de la expresión es entero (2), al almacenarlo en la variable c lo único que hace es convertir el 2 a float, añadiendo el .0, pero ahora surge la pregunta ¿Cómo obtengo el resultado de la división exacta? Pues en Java, es necesario que por lo menos uno de los operandos sea float, para que el resultado sea también de tipo float. Probemos ahora con la siguiente operación:

float c;

c = 5.0f / 2;

System.out.println(c);

¡Ahora sí! El resultado es el esperado. En Java hay que terminar el número decimal con una f para indicarle que es un float. Como habíamos dicho, por lo menos un operando debe ser float para obtener la división exacta, es decir, la operación pudo ser esta:

c = 5 / 2.0f;

O también así:

c = 5.0f / 2.0f;

En Java existe también lo que se conoce como conversión de tipos, por ejemplo, la operación anterior pudo ser escrita así:

c = (float) 5 / 2;

Y el resultado sería el mismo. OJO, hay que tener mucho cuidado, lo que está pasando acá, es que estamos convirtiendo el número 5 a float. Si nosotros convertimos toda la expresión a float, de la siguiente manera:

c = (float) (5 / 2);

Estamos cometiendo un error. Porque lo primero que ocurre es la división (5 / 2 = 2), y luego sucede la conversión ( 2 -> 2.0). Por lo tanto hay que tener mucho cuidado.

Existe también un concepto para tener en cuenta. El truncamiento de datos, esto sucede cuando convertimos un tipo de dato mayor a uno menor, a costa de perder parte de la información. De manera más simple, veamos el caso:

Anteriormente convertimos el número 5 a float (5 -> 5.0) y no perdimos información, a simple vista sólo se le agregó una parte decimal sin valor. Sin embargo, si nosotros tenemos lo siguiente:

float c;
int d;

c = 5.4;
d = (int) c;

System.out.println(d);

¿Cuál es el resultado?
A esto se llama truncamiento de datos. Se perdió la información de la variable c, puesto que la parte decimal no encaja dentro de una variable entera. Esto Java lo permite porque hay momentos en los que es necesario. Pero no hay que abusar de ello, puesto que si necesitamos sacar cuentas, y obviamos la parte decimal muchas veces, los resultados podrían ser catastróficos, sobretodo en las empresas. así que mucho cuidado.

Por último, mencioné la concatenación, he decidido hacer una entrada para el tema de cadenas, pero será luego de ver métodos y funciones.

Esto fue todo por hoy, espero que alguien pueda sacar provecho de este post. Hasta la próxima.