Valor absoluto en Java explicado: Math.abs(), trampas de MIN_VALUE y BigDecimal

1. Qué aprenderás en este artículo (Resumen rápido)

Al trabajar con Java, a menudo necesitarás calcular el valor absoluto de un número.
La buena noticia es que Java ofrece una forma simple y estándar de hacerlo, pero también existen trampas importantes que debes conocer.

En este artículo aprenderás:

• La forma básica y correcta de obtener un valor absoluto en Java usando Math.abs()
• Por qué Math.abs() no siempre devuelve un número positivo
• El caso especial de Integer.MIN_VALUE y Long.MIN_VALUE
• Cómo manejar de forma segura valores decimales y dinero usando BigDecimal
• Patrones prácticos que puedes aplicar en aplicaciones Java del mundo real

Si solo quieres la respuesta corta:

• ✅ Usa Math.abs() en la mayoría de los casos
• ⚠️ Ten cuidado con Integer.MIN_VALUE y Long.MIN_VALUE
• 💰 Usa BigDecimal.abs() para cálculos financieros y de alta precisión

1.1 La forma estándar: Math.abs()

En Java, la manera más común de calcular un valor absoluto es el método Math.abs().

int x = -10;
int result = Math.abs(x);
System.out.println(result); // 10

El significado es directo:

• Si el número es positivo, se devuelve tal cual
• Si el número es negativo, se elimina el signo

Como Math.abs() expresa claramente la intención, se prefiere sobre implementaciones manuales en la mayoría de los casos.

1.2 Advertencia importante: el valor absoluto no siempre es positivo

Muchos principiantes asumen que el valor absoluto siempre significa un número positivo.
En Java, esta suposición no siempre es cierta.

Para ciertos valores, Math.abs() puede devolver un resultado negativo.

int min = Integer.MIN_VALUE;
int absMin = Math.abs(min);

System.out.println(absMin); // still negative

Este comportamiento no es un error.
Es el resultado de cómo se representan internamente los enteros en Java.

Explicaremos por qué ocurre y cómo manejarlo de forma segura en secciones posteriores.

Por ahora, recuerda este punto clave:

Math.abs() es seguro para la mayoría de los valores, pero no para todos los enteros posibles.

1.3 Valor absoluto para dinero y números decimales precisos

Al trabajar con dinero o valores que requieren precisión exacta, no debes usar double.

En su lugar, Java proporciona la clase BigDecimal, que tiene su propio método para valores absolutos.

import java.math.BigDecimal;

BigDecimal amount = new BigDecimal("-1234.56");
BigDecimal absAmount = amount.abs();

System.out.println(absAmount); // 1234.56

Observa que:

• Math.abs() no funciona con BigDecimal
• Debes llamar a abs() directamente sobre el objeto BigDecimal

Esto es especialmente importante para aplicaciones financieras.

1.4 Qué sigue

En las siguientes secciones, avanzaremos paso a paso:

• Qué significa realmente el valor absoluto en programación
• Cómo funciona Math.abs() con diferentes tipos de datos
• El problema MIN_VALUE en detalle
• Buenas prácticas para el desarrollo Java en entornos reales

2. ¿Qué es el valor absoluto? (Distancia desde cero)

Antes de profundizar en el código Java, es útil comprender claramente qué significa realmente el valor absoluto.
Este concepto explica por qué Math.abs() se comporta como lo hace, incluidas sus limitaciones.

2.1 Definición básica del valor absoluto

El valor absoluto de un número representa su distancia desde cero en una recta numérica.

• Números positivos → permanecen iguales
• Números negativos → se elimina el signo
• Cero → sigue siendo cero

Ejemplos:

La idea clave es que la dirección no importa, solo el tamaño del valor.

2.2 Por qué el valor absoluto es útil en programación

En la programación real, a menudo nos interesa cuán grande es la diferencia, sin importar la dirección.

Casos de uso comunes incluyen:

• Medir la diferencia entre dos valores
• Verificar si un valor está dentro de un rango aceptable
• Comparar errores o tolerancias
• Normalizar valores de entrada
• Ordenar por magnitud en lugar de por signo

Por ejemplo, al comparar dos números:

int a = 120;
int b = 95;

int diff = Math.abs(a - b);

Si a - b o b - a es negativo no importa — solo queremos la distancia.

2.3 Valor absoluto en Java: una operación sensible al tipo

En Java, el valor absoluto se maneja como una operación numérica, no como una construcción especial del lenguaje.

Eso significa:

• Los tipos primitivos ( int , long , double , etc.) usan Math.abs()
• Los números de alta precisión ( BigDecimal ) usan su propio método abs()
• El comportamiento depende del tipo de dato

Esto es importante porque no todos los tipos numéricos se comportan de la misma manera.

• Los enteros tienen límites fijos
• Los números de punto flotante tienen valores especiales como NaN e Infinity
• BigDecimal evita errores de redondeo pero funciona de forma diferente

Comprender esta distinción te ayudará a evitar errores sutiles más adelante.

2.4 Por qué “solo quitar el signo menos” no es suficiente

Un modelo mental común es:

Valor absoluto = quitar el signo menos

Aunque esto es mayormente cierto, no siempre es seguro en programación.

¿Por qué?

• Los tipos numéricos tienen rangos limitados
• Los enteros en Java usan la representación de complemento a dos
• Algunos valores negativos no pueden convertirse a positivos

Esto explica exactamente por qué ciertos valores — como Integer.MIN_VALUE — se comportan de manera diferente.

Exploraremos este problema con detalle en las próximas secciones.

Por ahora, recuerda:

El valor absoluto es simple en concepto, pero los detalles de implementación importan.

3. Uso básico de Math.abs() en Java

Ahora que entendemos qué significa el valor absoluto, veamos cómo usarlo en Java.
En la mayoría de los casos, Math.abs() es todo lo que necesitas.

3.1 El ejemplo más sencillo

El método Math.abs() devuelve el valor absoluto de un número.

int value = -15;
int result = Math.abs(value);

System.out.println(result); // 15

La intención es inmediatamente clara:

• Math.abs(x) → “el valor absoluto de x”

Esta legibilidad es una de las principales razones para usar Math.abs() en lugar de escribir tu propia lógica.

3.2 Tipos de datos compatibles

Math.abs() está sobrecargado para admitir varios tipos numéricos primitivos.

Un punto crítico a recordar:

El tipo de retorno siempre es el mismo que el tipo de entrada.

Ejemplo:

long x = -100L;
long y = Math.abs(x); // still long

Java no amplía automáticamente el tipo al calcular el valor absoluto.

3.3 Comportamiento para positivos, negativos y cero

Para la mayoría de los valores, Math.abs() se comporta exactamente como esperas.

System.out.println(Math.abs(10));   // 10
System.out.println(Math.abs(-10));  // 10
System.out.println(Math.abs(0));    // 0

Esto cubre la mayoría de los casos del mundo real, por lo que muchos tutoriales se detienen aquí.

Sin embargo, esta simplicidad puede ser engañosa si no conoces los casos límite.

3.4 Uso de Math.abs() con números de punto flotante

También puedes usar Math.abs() con double y float.

double d = -3.14;
double absD = Math.abs(d);

System.out.println(absD); // 3.14

Aunque funciona, los números de punto flotante introducen consideraciones adicionales:

• Errores de redondeo
• Valores especiales como NaN e Infinity
• La existencia de -0.0

Abordaremos estos detalles en una sección posterior.

3.5 Por qué deberías preferir Math.abs()

Podrías escribir la lógica del valor absoluto manualmente, por ejemplo:

int x = -10;
int abs = x < 0 ? -x : x;

Pero usar Math.abs() suele ser mejor porque:

• La intención es más clara
• El código es más fácil de leer y mantener
• Evita lógica personalizada innecesaria
• Sigue las prácticas estándar de Java

Dicho esto, Math.abs() no es perfecto.

En la siguiente sección exploraremos la limitación más importante de este método.

4. Por qué Math.abs() puede devolver un valor negativo (la trampa del MIN_VALUE)

Esta sección cubre el caso límite más peligroso y malinterpretado al trabajar con valores absolutos en Java.

Sí — Math.abs() puede devolver un número negativo.

4.1 Los valores problemáticos: Integer.MIN_VALUE y Long.MIN_VALUE

Cada tipo entero en Java tiene un rango fijo.

• int : de -2,147,483,648 a 2,147,483,647
• long : de -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

Observe algo importante:

El rango negativo es un valor mayor que el rango positivo.

Ejemplo:

System.out.println(Integer.MAX_VALUE); //  2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648

El valor absoluto de -2147483648 sería 2147483648,
pero ese número no puede ser representado por un int.

4.2 Qué ocurre realmente en el código

Veamos el problema en acción.

int min = Integer.MIN_VALUE;
int absMin = Math.abs(min);

System.out.println(absMin); // still negative

En lugar de volverse positivo, el valor permanece negativo.

Este comportamiento a menudo sorprende a los desarrolladores, pero es:

• No es un error
• No es un problema de la JVM
• Totalmente conforme a la especificación de Java

El mismo problema existe para long:

long min = Long.MIN_VALUE;
long absMin = Math.abs(min);

System.out.println(absMin); // still negative

4.3 Por qué ocurre esto (Complemento a dos explicado de forma sencilla)

Java usa complemento a dos para representar enteros con signo.

No es necesario conocer los detalles a nivel de bits, pero los puntos clave son:

• Los enteros tienen un número fijo de bits
• Un bit se usa para el signo
• No hay contraparte positiva para MIN_VALUE

Cuando Java intenta calcular:

-MIN_VALUE

el resultado desborda y se envuelve — terminando como el mismo valor negativo.

4.4 Error común: “Simplemente conviértelo a long”

Una concepción errónea muy común es:

Si int falla, almacenaré el resultado en un long.

Esto no soluciona el problema.

int min = Integer.MIN_VALUE;
long result = Math.abs(min);

¿Por qué?

Porque Math.abs(min) se evalúa como un int primero.
El desbordamiento ya ha ocurrido antes de que el valor se asigne a long.

4.5 Enfoque seguro #1: Manejar explícitamente MIN_VALUE

La solución más segura y clara es manejar este caso explícitamente.

int x = Integer.MIN_VALUE;

if (x == Integer.MIN_VALUE) {
    // handle separately (exception, fallback, or special logic)
} else {
    int abs = Math.abs(x);
}

Este enfoque hace que el caso límite sea visible e intencional.

4.6 Enfoque seguro #2: Repensar el diseño

Si tu lógica asume que los valores absolutos son siempre positivos, considera:

• Usar long o BigDecimal desde el principio
• Prevenir que MIN_VALUE entre al sistema
• Tratar este caso como entrada no válida

En muchos sistemas del mundo real, la aparición de MIN_VALUE es una señal de diseño.

4.7 Por qué este conocimiento es importante en código de producción

Este caso límite es peligroso porque:

• Es raro
• A menudo pasa las pruebas
• Solo aparece con valores extremos
• Puede romper silenciosamente la lógica de negocio

Saber este comportamiento te ayuda a escribir código Java defensivo y listo para producción.

5. Valores absolutos con números de punto flotante (double / float)

Hasta ahora, nos hemos centrado en los enteros.
Ahora veamos los números de punto flotante, como double y float, y cómo se comportan los valores absolutos con ellos.

Aunque Math.abs() funciona aquí también, los números de punto flotante introducen diferentes tipos de trampas.

5.1 Uso básico con double y float

Usar Math.abs() con números de punto flotante se ve exactamente igual que con enteros.

double x = -12.75;
double abs = Math.abs(x);

System.out.println(abs); // 12.75

Para valores normales, el comportamiento es intuitivo y fiable.

5.2 Manejo de NaN (Not a Number)

Los tipos de punto flotante pueden representar NaN, que significa Not a Number (No es un número).

double value = Double.NaN;
System.out.println(Math.abs(value)); // NaN

Propiedades importantes de NaN:

.* Math.abs(NaN) devuelve NaN * NaN == NaN siempre es false * Cualquier comparación que involucre NaN es false

Esto significa que la lógica como la siguiente puede fallar silenciosamente:

if (Math.abs(value) < 1.0) {
    // This will never execute if value is NaN
}

Si sus datos pueden contener valores inválidos o indefinidos, debe comprobar explícitamente si son NaN.

5.3 Infinito y Valor Absoluto

Los números de punto flotante también pueden representar infinito.

double posInf = Double.POSITIVE_INFINITY;
double negInf = Double.NEGATIVE_INFINITY;

System.out.println(Math.abs(posInf)); // Infinity
System.out.println(Math.abs(negInf)); // Infinity

Este comportamiento es consistente y predecible, pero a menudo indica que:

• Un cálculo se salió del rango
• Se produjo una división por cero anteriormente

En la mayoría de las aplicaciones, debe tratar el infinito como una señal de advertencia, no como un resultado válido.

5.4 El caso especial de -0.0

A diferencia de los enteros, los números de punto flotante tienen tanto 0.0 como -0.0.

double z = -0.0;
System.out.println(Math.abs(z)); // 0.0

Aunque -0.0 normalmente se comporta como 0.0, existen sutiles diferencias:

System.out.println(1.0 / 0.0);  // Infinity
System.out.println(1.0 / -0.0); // -Infinity

Tomar el valor absoluto normaliza -0.0 a 0.0,
pero la existencia de -0.0 aún puede afectar los cálculos antes de aplicar Math.abs().

5.5 Por qué los valores absolutos de punto flotante no son adecuados para dinero

Aunque Math.abs() funciona correctamente con double y float,
estos tipos no son adecuados para cálculos financieros.

Las razones incluyen:

• La representación binaria provoca errores de redondeo
• Los valores decimales exactos no siempre pueden representarse
• Las comparaciones pueden fallar inesperadamente

Si necesita resultados exactos, especialmente para dinero, debe usar BigDecimal.

5.6 Puntos clave sobre los valores absolutos de punto flotante

Al usar valores absolutos con números de punto flotante, recuerde:

• Math.abs() funciona como se espera para valores normales
• NaN permanece NaN
• El infinito permanece como Infinity
• -0.0 existe y puede ser relevante
• Los números de punto flotante no son adecuados para dinero

6. Valores absolutos para dinero y precisión: BigDecimal.abs()

Cuando la precisión es importante — especialmente en aplicaciones financieras y de negocio — los números de punto flotante no son suficientes.
Aquí es donde BigDecimal se vuelve esencial.

6.1 Por qué BigDecimal es necesario

double y float son rápidos, pero no pueden representar valores decimales exactamente.

double value = 0.1 + 0.2;
System.out.println(value); // 0.30000000000000004

Este tipo de error de redondeo es inaceptable en casos como:

• Precios y pagos
• Impuestos y tarifas
• Saldos de cuentas
• Cualquier cálculo donde se requiera exactitud

BigDecimal almacena los números como valores decimales, evitando estos problemas.

6.2 BigDecimal no funciona con Math.abs()

Un error común es intentar usar Math.abs() con BigDecimal.

BigDecimal x = new BigDecimal("-100");
// Math.abs(x); // Compile-time error

Esto falla porque BigDecimal no es un tipo primitivo.
Su valor absoluto debe calcularse usando un método de instancia.

6.3 La forma correcta: BigDecimal.abs()

Para obtener el valor absoluto de un BigDecimal, llame a abs() directamente sobre el objeto.

import java.math.BigDecimal;

BigDecimal amount = new BigDecimal("-1234.56");
BigDecimal absAmount = amount.abs();

System.out.println(absAmount); // 1234.56

Características importantes:

• BigDecimal es inmutable
• abs() devuelve un nuevo objeto
• El valor original permanece sin cambios

6.4 Uso de MathContext para control de precisión

En algunos sistemas, puede ser necesario controlar la precisión y el redondeo de forma explícita.

import java.math.BigDecimal;
import java.math.MathContext;

BigDecimal value = new BigDecimal("-1234.56789");
BigDecimal abs = value.abs(new MathContext(6));

System.out.println(abs); // valor absoluto con precisión aplicada

This is useful when:

• Internal calculations require fixed precision
• Regulatory or business rules apply
• You want consistent rounding behavior

6.5 Common Real-World Use Cases

Ensuring Positive Differences

BigDecimal before = new BigDecimal("1000");
BigDecimal after  = new BigDecimal("750");

BigDecimal difference = after.subtract(before).abs();
System.out.println(difference); // 250

Normalizing External Input

BigDecimal input = new BigDecimal("-500");
BigDecimal normalized = input.abs();

This pattern is common when processing user input or external data feeds.

6.6 When You Should Choose BigDecimal

Use BigDecimal when:

• You are working with money
• Precision is critical
• Rounding errors are unacceptable
• You want to avoid integer overflow issues like MIN_VALUE

Avoid it when:

• Performance is critical
• Approximation is acceptable
• The values are simple and bounded

6.7 Summary: BigDecimal.abs() Is the Safe Choice

For financial and high-precision calculations:

• Do not use double
• Do not use Math.abs()
• Use BigDecimal.abs()

This choice prevents subtle bugs and ensures reliable results.

7. Writing Your Own Absolute Value Logic (And Why You Usually Shouldn’t)

Some developers prefer to write absolute value logic manually instead of using Math.abs().
While this may look simple, it often introduces hidden risks and offers no real advantage.

7.1 A Common Manual Implementation

A typical custom implementation looks like this:

int x = -20;
int abs = x < 0 ? -x : x;

System.out.println(abs); // 20

At first glance, this seems perfectly reasonable:

• If the value is negative, flip the sign
• Otherwise, return the value as-is

7.2 The MIN_VALUE Problem Still Exists

Unfortunately, this manual approach does not fix the MIN_VALUE issue.

int x = Integer.MIN_VALUE;
int abs = x < 0 ? -x : x;

System.out.println(abs); // still negative

Why?

Because the problem is not the implementation, but the numeric limits of the data type.

• -Integer.MIN_VALUE cannot be represented as an int
• Overflow occurs before you can “fix” it

So even custom logic behaves exactly like Math.abs() in this case.

7.3 Readability and Intent Matter More Than Cleverness

Compare these two versions:

int a = x < 0 ? -x : x;

int a = Math.abs(x);

The second version is clearer because:

• The intent is explicit
• Anyone reading the code understands it immediately
• There is no need to mentally parse the condition

In professional codebases, clarity is more important than brevity.

7.4 Performance Differences Are Negligible

Some developers worry that Math.abs() might be slower than manual logic.

In modern Java:

• The JIT compiler optimizes both approaches
• The performance difference is effectively zero
• Micro-optimizations here are pointless

Choosing readability and safety is the correct decision.

7.5 When Manual Logic Might Make Sense

There are very limited cases where custom logic is acceptable:

• Teaching or learning basic control flow
• Writing minimal examples or pseudocode
• Implementing defensive checks around MIN_VALUE

Even then, you should clearly document the reason.

7.6 Recommended Best Practices

Follow these guidelines:

• ✅ Use Math.abs() for primitive types
• ✅ Use BigDecimal.abs() for financial values
• ❌ Avoid reinventing standard library behavior
• ⚠️ Always consider edge cases like MIN_VALUE

8. Practical Absolute Value Patterns (Copy & Paste Recipes)

This section shows real-world patterns where absolute values are commonly used in Java applications.
All examples are safe, readable, and ready to copy.

8.1 Getting the Difference Between Two Values

Un caso de uso muy común es encontrar la diferencia sin importar la dirección.

int a = 120;
int b = 95;

int diff = Math.abs(a - b);
System.out.println(diff); // 25

Este patrón se usa para:

• Diferencias de puntuación
• Comparaciones de conteo
• Cálculos de distancia
• Brechas de versión o desplazamiento

8.2 Comparar valores con una tolerancia (margen de error)

La igualdad exacta suele ser poco fiable con números de punto flotante.
En su lugar, compare la diferencia absoluta con una tolerancia.

double expected = 100.0;
double actual   = 99.9998;
double tolerance = 0.01;

if (Math.abs(expected - actual) <= tolerance) {
    // Within acceptable range
}

Esto es especialmente útil en:

• Pruebas unitarias
• Sistemas de medición
• Cálculos científicos o estadísticos

8.3 Ordenar por valor absoluto

A veces se desea ordenar valores por magnitud, no por signo.

List<Integer> numbers = Arrays.asList(-3, 10, -1, 5);

numbers.sort(Comparator.comparingInt(Math::abs));
System.out.println(numbers); // [-1, -3, 5, 10]

Los casos de uso típicos incluyen:

• Clasificación por desviación
• Selección del valor más cercano
• Ordenamiento basado en impacto

8.4 Normalizar valores de entrada

La entrada externa puede contener valores negativos inesperados.
Si la negatividad no tiene sentido, normalice la entrada.

int input = -50;
int normalized = Math.abs(input);

Este patrón es común para:

• Cantidades
• Tamaños
• Valores de configuración

⚠️ Siempre asegúrese de que MIN_VALUE no pueda aparecer, o manéjelo explícitamente.

8.5 Diferencias financieras con BigDecimal

Para cálculos relacionados con dinero, use BigDecimal y abs().

BigDecimal before = new BigDecimal("1500");
BigDecimal after  = new BigDecimal("1800");

BigDecimal difference = after.subtract(before).abs();
System.out.println(difference); // 300

Esto evita:

• Errores de redondeo de punto flotante
• Problemas de desbordamiento de enteros
• Comparaciones incorrectas

8.6 Verificaciones de rango y límites

Los valores absolutos son útiles para verificar si un valor está dentro de un rango alrededor de un centro.

int center = 100;
int value  = 92;

if (Math.abs(value - center) <= 10) {
    // Within range
}

Aplicaciones comunes:

• Umbrales de sensores
• Lógica de ajuste de UI
• Reglas de validación

8.7 Consejos prácticos clave

Al usar valores absolutos en aplicaciones reales:

• Conozca su tipo de datos
• Considere casos límite
• Elija la precisión de forma intencional
• No asuma que “absoluto” significa “seguro”

9. Resumen y puntos clave

Recapitulemos todo lo que hemos cubierto sobre valores absolutos en Java y destaquemos los puntos más importantes que debe recordar.

9.1 Use Math.abs() como la opción predeterminada

Para la mayoría de situaciones, Math.abs() es la solución correcta y recomendada.

• Funciona con int, long, float y double
• Claro y expresivo
• Parte de la biblioteca estándar de Java
• Fácil de leer y mantener

Si no está seguro, comience con Math.abs().

9.2 MIN_VALUE es la única excepción crítica

Integer.MIN_VALUE y Long.MIN_VALUE son casos especiales.

• Sus valores absolutos no pueden representarse
• Math.abs() puede devolver un número negativo
• Este comportamiento está definido por la especificación de Java

Regla clave:

Nunca asuma que Math.abs() siempre devuelve un valor positivo.

Si este valor puede aparecer en sus datos, manéjelo explícitamente o rediseñe la lógica.

9.3 Los valores absolutos de punto flotante tienen sus propias trampas

Al usar double o float:

• NaN sigue siendo NaN
• Infinity sigue siendo Infinity
• -0.0 existe
• Los errores de redondeo son inevitables

Estos tipos son adecuados para aproximaciones, pero no para dinero.

9.4 Use BigDecimal.abs() para dinero y precisión

Para cálculos financieros y de alta precisión:

• No use double
• No use Math.abs()
• Use BigDecimal.abs()

Esto garantiza:

• Representación decimal exacta
• Sin sorpresas de redondeo
• Sin problemas de desbordamiento de enteros

9.5 No reinventes la lógica del valor absoluto

Escribiendo tu propio código de valor absoluto:

• No corrige casos límite
• Añade complejidad innecesaria
• Reduce la legibilidad

Las API estándar existen por una razón. Úsalas.

9.6 Piensa en la entrada y el diseño, no solo en la fórmula

El valor absoluto es simple en teoría, pero su uso seguro depende de:

• El tipo de dato
• Los rangos de entrada posibles
• Reglas de negocio
• Casos límite

Un buen código Java proviene de entender las restricciones, no solo de aplicar fórmulas.

Preguntas frecuentes: Preguntas comunes sobre valores absolutos en Java

P1. ¿Math.abs() siempre devuelve un número positivo?

No.
Para Integer.MIN_VALUE y Long.MIN_VALUE, el resultado puede seguir siendo negativo.

P2. ¿Este comportamiento es un error de Java?

No.
Es una consecuencia directa de la representación de enteros de tamaño fijo y es un comportamiento totalmente documentado.

P3. ¿Puedo solucionar el problema convirtiendo a long?

No.
El desbordamiento ocurre antes de la conversión si la entrada es int.

P4. ¿Cómo obtener el valor absoluto de un BigDecimal?

Utiliza el método abs() del objeto:

BigDecimal value = new BigDecimal("-100");
BigDecimal abs = value.abs();

P5. ¿Es seguro usar valores absolutos para comparaciones?

Sí, pero solo si:

• Eliges el tipo de dato correcto
• Tienes en cuenta la precisión y los casos límite
• Usas tolerancias para los números de punto flotante

Reflexiones finales

El valor absoluto es uno de los conceptos matemáticos más simples —
sin embargo, en Java, tiene detalles técnicos importantes que importan en aplicaciones reales.

Al entender estos detalles, puedes escribir:

• Código más seguro
• Código más claro
• Programas Java más profesionales