Esto no es nada

Autor: Ricardo Londoño

Operadores

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 mas que el pequeñito 2 entra holgadamente en una variableshort. 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 puedetolerar 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 110000000000000000000000000000000 : 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 de como resultado un número negativo. Pero el intérprete de Java no nos avisa, por lo tanto tenemos que cuidarnos al trabajar cerca delos extremos.

Sigamos metiéndonos en embrollos. Veamos ahora que ocurre si tratamos de dividir cualquier numero 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 nosmanda a pasear con la siguiente nota:

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

Veremos mas adelante como 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:

publicclass 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.

Operadoresaritmé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...