El Excepción El manejo es uno de los mecanismos más poderosos para manejar los errores de tiempo de ejecución de modo que se pueda mantener el flujo normal de la aplicación. En Java, una excepción es una condición anormal. El lenguaje de programación Java define varias excepciones. En esta sección, discutiremos una de las excepciones destacadas que es Excepción aritmética en Java.
La excepción aritmética es un tipo de resultado inusual o error no verificado del código, que se genera o genera cada vez que aparece una operación matemática o aritmética incorrecta en el código durante el tiempo de ejecución. Un problema de tiempo de ejecución, también llamado excepción, aparece siempre que el denominador de una fracción es 0 y la JVM no puede encontrar el resultado; por lo tanto, la ejecución del programa finaliza y se genera una excepción. Tenga en cuenta que en el punto en el que se genera la excepción, el programa finaliza. Sin embargo, el código anterior se ejecuta y se muestra el resultado apropiado.
Estructura de excepción aritmética
La clase base de excepción aritmética es java.lang.ArithmeticException, que es la clase secundaria de java.lang.RuntimeException, que a su vez es la clase secundaria de java.lang.Exception.
Constructor de excepciones aritméticas
¿Cómo ocurre la excepción aritmética?
Las siguientes son dos situaciones en las que puede ocurrir la excepción aritmética.
- Cuando realizamos una división donde se usa 0 como divisor, es decir, 0 viene como denominador.
- Un número decimal largo que no termina en Big Decimal.
Dividir por 0
Nombre del archivo: ArithmeticException.java
public class ArithmeticException { void divide(int a, int b) { // performing divison and storing th result int res = a / b; System.out.println('Division process has been done successfully.'); System.out.println('Result came after division is: ' + res); } // main method public static void main(String argvs[]) { // creating an object of the class ArithmeticException ArithmeticException obj = new ArithmeticException(); obj.divide(1, 0); } } Producción:
Exception in thread 'main' java.lang.ArithmeticException: / by zero at ArithmeticException.divide(ArithmeticException.java:6) at ArithmeticException.main(ArithmeticException.java:16)
Decimal grande sin terminación
Nombre del archivo: ArithmeticException1.java
// import statement import java.math.BigDecimal; public class ArithmeticException1 { // main method public static void main(String[] argvs) { // creating two objects of BigDecimal BigDecimal a1 = new BigDecimal(11); BigDecimal a2 = new BigDecimal(17); // 11 / 17 = 0.6470588235294118... a1 = a1.divide(a2); System.out.println(a1.toString()); } } Producción:
Exception in thread 'main' java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result. at java.base/java.math.BigDecimal.divide(BigDecimal.java:1766) at ArithmeticException1.main(ArithmeticException1.java:9)
Explicación: En el programa anterior, la clase Big Decimal no conoce la salida exacta que se mostrará después de la división. Esto se debe a que la salida es una expansión decimal no terminante. Una forma de resolverlo es proporcionar el límite. Por ejemplo, podemos decir explícitamente en el programa que la salida debe limitarse a 6 decimales. Observe el siguiente programa.
Nombre del archivo: ArithmeticException2.java
// import statement import java.math.BigDecimal; public class ArithmeticException2 { // main method public static void main(String[] argvs) { // creating two objects of BigDecimal BigDecimal a1 = new BigDecimal(11); BigDecimal a2 = new BigDecimal(17); // 11 / 17 = 0.6470588235294118... // rounding up to decimal places a1 = a1.divide(a2, 6, BigDecimal.ROUND_DOWN); System.out.println(a1.toString()); } } Producción:
0.647058
Manejo de excepciones aritméticas
Podemos manejar la excepción aritmética por nuestra cuenta usando el bloque try-catch. Observe los siguientes programas.
Nombre del archivo: HandleArithmeticException.java
public class HandleArithmeticException { void divide(int a, int b) { int res; try { // performing divison and storing th result res = a / b; System.out.println('Division process has been done successfully.'); System.out.println('Result came after division is: ' + res); } // handling the exception in the catch block catch(java.lang.ArithmeticException ex) { System.out.println('Should avoid dividing by 0 ' + ex); } } // main method public static void main(String argvs[]) { // creating an object of the class ArithmeticException ArithmeticException obj = new ArithmeticException(); obj.divide(1, 0); } } Producción:
Should avoid dividing by 0 java.lang.ArithmeticException: / by zero
Para la expansión decimal no terminante, todo lo que tenemos que hacer es ajustar la línea donde se produce la división dentro del bloque try.
Nombre del archivo: HandleArithmeticException1.java
// import statement import java.math.BigDecimal; public class HandleArithmeticException1 { // main method public static void main(String[] argvs) { // creating two objects of BigDecimal BigDecimal a1 = new BigDecimal(11); BigDecimal a2 = new BigDecimal(17); try { // 11 / 17 = 0.6470588235294118... a1 = a1.divide(a2); System.out.println(a1.toString()); } // handling the exception in the catch block catch(ArithmeticException ex) { System.out.println('Should avoid dividing by an integer that leads to non-terminating decimal expansion. ' + ex); } } } Producción:
Should avoid dividing by an integer that leads to non-terminating decimal expansion. java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.