Programación 1º – UD2 – Operadores aritméticos

¿Qué son los operadores y las expresiones?

1. Operadores: Son símbolos que realizan operaciones sobre datos (llamados operandos). Por ejemplo, si quieres sumar dos números, el operador sería el signo +. Los operadores pueden ser:
   • Unarios: Trabajan con un solo operando. Ejemplo: el operador – (negativo), como en -5, que convierte 5 en negativo.
   • Binarios: Trabajan con dos operandos. Ejemplo: +, como en 3 + 5, donde 3 y 5 son los operandos.
   • Ternarios: Usan tres operandos. En Java, un ejemplo es el operador ternario (?:), que se usa en condiciones.
2. Expresiones: Son combinaciones de operadores y operandos que producen un resultado. Por ejemplo:

int resultado = 5 + 3;

Operadores Aritméticos

Son los operadores que usamos para realizar cálculos matemáticos básicos.

1. Suma (+): Suma dos números. 1.2 + 9.3 // El resultado es 10.5
2. Resta (-): Resta dos números. 312.5 - 12.3 // El resultado es 300.2
3. Multiplicación (*): Multiplica dos números. 1.7 * 1.2 // El resultado es 2.04
4. División (/): Divide dos números. 0.5 / 0.2 // El resultado es 2.5
5. Resto de la división (%): Da el residuo de la división entre dos números. 25 % 3 // El resultado es 1 (porque 25 dividido entre 3 deja un residuo de 1)

Cuando divides dos enteros (int), aunque el resultado “real” debería tener decimales, Java lo trunca (elimina los decimales). ¿Por qué? Porque ambos son int, así que el resultado también es int.

int a = 7;
int b = 2;
System.out.println(a / b);  // Resultado: 3 (¡no 3.5!)

¿Cómo obtener decimales? ➜ Conversión de tipo

Si quieres que la división tenga decimales, uno de los operandos debe ser float o double. Por ejemplo:

int a = 7;
int b = 2;
System.out.println((double) a / b);  // Resultado: 3.5

Aquí estás usando una conversión explícita (casting): estás diciendo a Java: “Trata a como si fuera un double”.

Tipos de conversión

• Conversión automática (implícita): Cuando pasas un tipo pequeño a uno más grande, Java lo hace automáticamente:

int x = 100;
long y = x;  // int se convierte automáticamente a long

• Conversión explícita (cast): Cuando pasas de un tipo grande a uno más pequeño, debes indicarlo tú mismo:

int a = 100;
byte b = (byte) a;  // Correcto, pero ¡ten cuidado! Puede haber pérdida de datos

Si no haces el cast, da error:

byte b = a; // ERROR

Si en vez de truncar el decimal (como sucedió antes), deseas redondear el número, puedes usar diferentes métodos:

Redondeo normal con Math.round(num)

El método Math.round(num) redondea el número decimal a su valor entero más cercano.

• Si el decimal es 0.5 o mayor, se redondea hacia arriba.
• Si el decimal es menor que 0.5, se redondea hacia abajo.

Ejemplo:

double num = 3.7;
long redondeado = Math.round(num);  // Resultado: 4

• 3.7 se redondea a 4.
• Nota: El resultado de Math.round() es de tipo long, por lo que si necesitas almacenarlo en un int, debes hacer una conversión explícita (cast).

Redondeo hacia arriba con Math.ceil(num)

Si quieres asegurarte de que el número siempre se redondee hacia arriba (aunque sea un decimal muy pequeño), puedes usar Math.ceil().

double num = 3.2;
double redondeoHaciaArriba = Math.ceil(num); // Resultado: 4.0

Redondeo hacia abajo con Math.floor(num)

Si quieres asegurarte de que el número siempre se redondee hacia abajo, incluso si el decimal es mayor que 0.5, puedes usar Math.floor().

double num = 3.8;
double redondeoHaciaAbajo = Math.floor(num);  // Resultado: 3.0

Operadores Incrementales y Decrementales

Operador Incremental (++): Aumenta el valor de la variable en 1.

• Postfijo: Si escribimos x++ después de la variable, primero usa el valor y luego incrementa.

x = 3; 
y = x++; // y vale 3 (se usa el valor actual de x); x vale 4 (se incrementa después)  

• Prefijo: Si escribimos ++x antes de la variable, primero incrementa y luego usa el valor.

x = 3; y = ++x; // x se convierte en 4; y también toma el valor 4

Operador Decremental (--): Disminuye el valor de la variable en 1.

• Postfijo: Si escribimos x-- después de la variable, primero usa el valor y luego decrece.

x = 3; 
y = x--; // y vale 3 (se usa el valor actual de x); x vale 2 (decrece después)  

• Prefijo: Si escribimos --x antes de la variable, primero decrece y luego usa el valor.

x = 3; y = --x; // x se convierte en 2; y también toma el valor 2