Programación en Java/Operadores aritméticos

Realizan las operaciones aritméticas básicas: suma (+), resta (-), multiplicación (*) ,división (/) y módulo (%) para datos de tipo numérico, tanto enteros como reales. Estas son operaciones binarias porque admiten dos operandos.

Ejemplo de utilización de estos operadores:

public class Aritmetica{
	public static void main(String[] args){
		int i      = 12;
		int j      = 10;
		int suma   = i + j;
		int resta  = i - j;
		int mult   = i * j;
		int div    = i / j;
		int modulo = i % j;
		
		System.out.print("Suma :");
		System.out.println(suma );
		System.out.print("Resta :");
		System.out.println(resta);
		System.out.print("Multiplicacion :");
		System.out.println(mult);
		System.out.print("Division :");
		System.out.println(div);
		System.out.print("Modulo :");
		System.out.println(modulo);	
	
	}
		
}

El resultado de estas operaciones no puede quedar almacenado en una variable de tipo short o byte, por más pequeño que sea. Si tramos de compilar esto:

short i = 1;
short j = 1;
short x = i + j;

Tendremos un "possible lost of precision" como respuesta, por más que el pequeñito 2 entre holgadamente en una variable short. El compilador evita que al utilizar estos tipos de datos no nos pasemos de largo. Pero de todas formas me voy a vengar. Analicemos el siguiente código:

public class IntGrande{
	public static void main(String[] args){
		int j = 2147483647;
		int i = j + 1;
		System.out.println("El valor obtenido es " + i);
		
	}
		
}

El valor 2147483647 (es decir 2^31 - 1 ) es el más grande que puede tolerar un int. Pero veamos que pasa al sumarle uno más. El compilador se queda mudo y cae en nuestra trampa. Ejecutamos el programa y obtenemos:

El valor obtenido es -2147483648 

Desastroso, ¿Verdad? Veamos lo que pasó: Teníamos el valor máximo para los int:

01111111111111111111111111111111 : 2147483647 en números binarios.
00000000000000000000000000000001 : le sumamos 1
10000000000000000000000000000000 : Resultado: -2147483648 complemento a 2

Esta anomalía se la conoce como “overflow” (desbordamiento). El procesador puede identificar un resultado con este problema comparando los signos. Es de esperar que si sumamos dos números positivos, no nos dé como resultado un número negativo. Pero el intérprete de Java no nos avisa, por lo tanto tenemos que cuidarnos al trabajar cerca de los extremos.

Sigamos metiéndonos en embrollos. Veamos ahora que ocurre si tratamos de dividir cualquier número por cero. Para la verificación escribimos este programa:

public class DivCero{
	public static void main(String[] args){
		int x = 5;
		int y = 0;
		int z = x/y;
		System.out.println(z);
	}
		
}

No tenemos noticias al compilar. Pero al ejecutar el programa, el intérprete nos manda a pasear con la siguiente nota:

Exception in thread "main" java.lang.ArithmeticException: / by zero

Veremos mas adelante cómo controlar el ánimo del interprete cuando ocurren estos errores, aquí conocidos como excepciones. La moraleja es que no se puede dividir un entero por cero.

Sigamos dando pelea, no nos dejemos intimidar. Probemos que ocurre con los números reales:

public class DivCeroFloat{
	public static void main(String[] args){
		float x = 5.0f;
		float y = 0.0f;
		float z = x/y;
		System.out.println(z);
	}
		
}

Compilamos y no escuchamos nada. Ejecutamos el programa...

Infinity 

Ni error ni cosas raras, el float se aguantó los malos tratos. Esto ocurre porque los números reales en su representación binaria soportan el valor infinito.

Operadores aritméticos unarios

Dentro de los operadores aritméticos tenemos los unarios + y – que simplemente operan con el signo de un valor dado. Por ejemplo:

int h = -1;
int m = +h; // es equivalente a m = h * (+1)
int n = -h; // es equivalente a n = h * (-1)

El operador – se encarga de cambiar el signo, y el + sencillamente deja el signo como está. Nuevamente no podemos almacenar el resultado en enteros cortos, los tipos byte y short los transforma en int. Dentro del catálogo de operadores tenemos algunos unarios más. Se trata del auto incremental ++ y del auto decremental --. Respectivamente, suma y resta una unidad al valor. Ambos operadores pueden ser sufijos, es decir se coloca antes del operando o posfijo que se sitúa detrás. Veamos algunos ejemplos:

int i = 1; 
i++; 
++i; 
i--;
--i;

En este ejemplo estamos incrementado y decrementando el valor de i. A priori parece que los operadores funcionan igual, tanto como posfijo como sufijo, pero su comportamiento es diferente. Observemos lo que ocurre en este ejemplo:

public class Diferentes{
	public static void main(String[] args){
		int i = 2;
		int j = 2;
		System.out.println(i++);
		System.out.println(++j);
		System.out.print("Estado Final (i) :");
		System.out.println(i);
		System.out.print("Estado Final (j) :");
		System.out.println(j);
	}
}

todo es practico. Partiendo del mismo valor, vemos que j se incrementó, mientras que la variable i se mostró sin cambios. Si colocamos el operador como sufijo, primero se evalúa la variable y luego se realiza la operación. En el caso de la variable i, antes de incrementar su valor se mostró por pantalla. Para la variable j el procedimiento fue inverso. Antes de mostrar su valor se incrementó.