Operadores

double hipotenusa(double a, double b) {
   return Math.sqrt((a * a) + (b * b));
}

> hipotenusa(3.0, 4.0)
> hipotenusa(1.0, 1.0)

5.0
1.4142135623730951

¿Recuerdas la fórmula para calcular el lado mayor de un triángulo rectángulo, su hipotenusa?

El Código 1 tiene una función que lo calcula.

Hasta ahora nos hemos ocupado principalmente de cadenas de Strings, pero para la hipotenusa presentamos nuestro primer tipo de dato numérico: double. Un double representa un número real (con algunas limitaciones) Para casos simples de números reales puedes usar un double. La función hipotenusa usa dos números reales que representan los lados del triángulo rectángulo y calcula la longitud del otro lado.

Para la implementación usamos algunos operadores y otra función de la librería estándar: Math.sqrt(). Esta función calcula la raíz cuadrada de un número. Recibe un double y retorna un double.

Como argumento utilizamos dos operadores: «*» para multiplicar números y«+» para sumar números. Estos operadores también están disponibles con otros tipos numéricos.

Para escribir valores necesitas usar literales: 3.0, 4.0 y 1.4142. Estos son literales para tipo doubles, dado que tienen un punto.

Tipos Primitivos

Java viene con algunos tipos definidos que se denominan primitivos para representar tipos básicos: caracteres, números y predicados. Estos son los más importantes:

Ya conocíamos los String que no son datos primitivos, pero que también tienen literales como "Hola Mundo!"

Operadores

Así como ya tenemos algunos tipos primitivos, Java tiene algunos operadores que podemos usar. Los operadores más comunes son:

Operadores Numéricos

Estos operadores se pueden utilizar con tipos numéricos como int y double. Toman dos valores del mismo tipo y devuelven un valor de ese mismo tipo, p.j. si sumas dos números enteros devuelven un número entero, si multiplicas dos double devuelve un double.

El operador de módulo devuelve el residuo después de la división de los dos números.

int siguiente(int número) {
  return número  +  1;
}

> siguiente(9)
> siguiente(33)

10
34

int agregar0(int número) {
  return número * 10;
}

> agregar0(55)
> agregar0(123)

550
1230

int rangoInclusivo(int inicio, int fin) {
  // retorna la cantidad de números entre fin e inicio
  // incluyendo los extremos
  return fin - inicio + 1;
}

> rangoInclusivo(3, 10)
> rangoInclusivo(100, 102)

8
3

Operadores de Relación

Estos operadores se pueden utilizar con tipos numéricos como int y double. Toman dos números del mismo tipo y devuelven un valor booleano.

boolean esMayorDeEdad(int edad) {
  // la mayoría de edad es a partir de los 18
  return edad >= 18;
}

> esMayorDeEdad(17)
> esMayorDeEdad(18)
> esMayorDeEdad(31)

false
true
true

boolean exentoDeImpuesto(double precio) {
  // si el precio es menos de $1.000.000 no paga impuesto
  return precio < 1_000_000.0;
}

> exentoDeImpuesto(150_000)
> exentoDeImpuesto(2_300_000)

true
false

boolean esMúltiplo(int a, int b) {
   return (a % b) == 0;
}

> esMúltiplo(30, 2)
> esMúltiplo(100, 3)

true
false

esMúltiplo() es una función que toma dos números enteros y devuelve un valor booleano: «true» si a es múltiplo de b o «false» en caso contrario. Utiliza el operador del módulo para verificar si el residuo de dividir «a» y «b» es «0», que es la definición de ser múltiplo. Podemos usar varios operadores en una misma expresión, así sea de tipos distintos.

El uso más común del operador % es para revisar si un número es múltiplo de otro.

Operadores Lógicos

La mayoría de estos operadores toman dos predicados y devuelven otro predicado. Sólo el operador negación toma un solo predicado. Se utilizan para obtener predicados más complejos a partir de otros predicados. El resultado de estos operadores se muestra después de ellos:

Tabla lógica del operador Y

El resultado del Y lógico sólo puede resultar en verdadero cuando ambos operandos son verdaderos.

Tabla Lógica del operador O

El resultado del O lógico sólo puede resultar en falso cuando ambos operandos son falsos.

Tabla lógica del operador negación

boolean esMayorDeEdad(int edad) {
   return edad >= 18;
}

boolean esAdultoMayor(int edad) {
   return edad >= 60;
}

boolean esAdulto(int edad) {
   return esMayorDeEdad(edad) && !esAdultoMayor(edad);
}

> esAdulto(24)
> esAdulto(81)

true
false

boolean esMúltiplo(int a, int b) {
   return (a % b) == 0;
}

boolean esAñoBisiesto(int year) {
  return esMúltiplo(year, 4) &&
   (esMúltiplo(year, 400) || !esMúltiplo(year, 100));
}

> esAñoBisiesto(1900)
> esAñoBisiesto(2000)
> esAñoBisiesto(2024) 

false
true
true

esAñoBisiesto() toma un número entero y devuelve verdadero si ese año es o será bisiesto. Un año bisiesto debe ser múltiplo de 4 y tener una de dos condiciones más: ser múltiplo de 400 o no ser múltiplo de 100. Nuevamente, usamos la función que escribimos antes esMúltiplo() para mejorar la legibilidad del código.

Operador Ternario

double max(double a, double b) {
  return (a > b) ? a : b;
}

> max(3.0, 5.0) 

5.0

La mayoría de los operadores son binarios, lo que significa que operan sobre dos valores, como la suma. En matemáticas y lógica también existen operadores unarios que utilizan un solo valor. El operador negación en programación es un operador unario. Resulta que en programación existe un operador ternario de esta forma:

<predicado> ? <valor1> : <valor2>

El resultado del operador se basa en el predicado, si la expresión es verdadera se evalúa como el «primer» valor, el que está entre «?» y «:», si es falso, se evalúa como el «segundo» valor, el que está después de «:» Ambos valores deben ser del mismo tipo.

Para la función «max()» en el Código 10, el preciado es «a > b». Si eso se evalúa como verdadero, entonces el valor de toda la expresión es el parámetro «a» ; de lo contrario, el valor es el parámetro «b». El predicado puede ser tan complejo como se necesite, y las otras partes también pueden ser tan complejas como se desee, aunque probablemente sea mejor mantenerlas simples.

Podrías pensar que es extraño tener un operador como el operador ternario, pero resulta que hay muchas oportunidades para usarlo y que tu código sea conciso pero muy legible.

Misión secundaria: consideraciones con números reales

Los números reales son difíciles de representar en las computadoras. A las variables se les asigna una cantidad de bits para ser representadas, pero muchos números reales tienen infinitos dígitos decimales como ⅓. Dado que las computadoras sólo pueden tener una representación limitada de dichos números, debes tener cuidado al usarlos en tu código. Si tienes varias operaciones con números reales, es probable que el número sea ligeramente diferente de lo esperado. En algunos casos, estos podrían no ser importantes, pero en otros, como el dinero, sería inconveniente y se debería utilizar otra alternativa. Dichas alternativas se salen del alcance de este material, pero es bueno que conozcas las limitaciones de los tipos de datos primitivos en un lenguaje.

Normalmente se prefiere evitar el uso de un operador como == para comprobar números reales. Debido a las imprecisiones de las que hemos hablado, solemos comprobarlas con un delta. Por ejemplo para comprobar si una variable tiene un valor equivalente a «1.0» puedes usar:

Math.abs(n - 1.0)< 1e-3

En este caso «1e-3» es otro posible literal para números reales, y expresarlos en algo parecido a una notación científica y en este caso es igual a 10^-3 es decir 0,001.

Aquí hay una tabla de números en notación científica y la manera en que los puedes escribir en programación:

Entonces, en el código anterior estás verificando que «n» sea igual a 1.0 hasta los primeros 2 números digitales. Esto suele aceptarse cuando se trata de longitudes, ya que diferencias más pequeñas son imperceptibles para el ojo humano.

Diferentes dominios requerirán diferentes deltas, así que no asumas que siempre puedes usar el mismo delta. Cuando utilices un dominio, aprende qué es importante en él y elige el delta con esa información. Como se indicó anteriormente, para las medidas 1e-3 probablemente sería suficiente.

Diversión con funciones

¿Dónde puedes usar una función que retorne un valor? En cualquier lugar donde se espere un valor. De hecho, una función pura es en realidad otra forma de representar su valor devuelto.

Escribamos algunas funciones:

double adición(double a, double b) {
  return a + b;
}

double multiplicación(double a, double b) {
  return a * b;
}

double cuadrado(double n) {
  return multiplicación(n, n);
}

Ahora podemos reimplementar la hipotenusa() como por ejemplo:

double hipotenusa(double a, double b) {
  return Math.sqrt(adición(cuadrado(a), cuadrado(b)));
}

Esa implementación tiene muchos paréntesis pero es una expresión válida. Diferentes programadores argumentarán que la última versión de la hipotenusa es más o menos legible que la que vimos inicialmente en este capítulo, pero lo importante es recordar que puedes llamar funciones en cualquier lugar donde puedas usar un valor.

Resumen

Los lenguajes de programación ofrecen diferentes tipos de datos primitivos. En Java los más comunes son:

• boolean: para predicados
• char: para caracteres Unicode
• int : números enteros
• double: números reales
• String: cadenas de caracteres

Si deseas representar valores de estos tipos de datos, puedes utilizar sus literales:

• boolean: «true»,«false»
• char: un solo caracter entre comillas sencillas
• int: digitos sin caracter de punto
• double: dígitos con un punto
• String: cero o más caracteres entre comillas dobles "

Además de funciones, los lenguajes incluyen operadores que puedes utilizar para operaciones que son muy comunes. Los operadores están definidos para algunos tipos y tienen un tipo de devolución específico. Lo más importante que debes recordar es que, si operas con dos valores, el resultado será del mismo tipo, ¡La división de dos enteros también será un entero!