El Excepció El maneig és un dels mecanismes més potents per gestionar els errors d'execució de manera que es pugui mantenir el flux normal de l'aplicació. A Java, l'excepció és una condició anormal. El llenguatge de programació Java defineix diverses excepcions. En aquesta secció, parlarem d'una de les excepcions més destacades que és Excepció aritmètica en Java.
L'excepció aritmètica és un tipus de resultat inusual o d'error no verificat del codi, que es llança o es planteja cada vegada que apareix una operació matemàtica o aritmètica incorrecta al codi durant el temps d'execució. Un problema d'execució, també anomenat excepció, apareix sempre que el denominador d'una fracció és 0 i la JVM no és capaç d'esbrinar el resultat; per tant, s'acaba l'execució del programa i es planteja una excepció. Tingueu en compte que en el punt on s'ha plantejat l'excepció, el programa finalitza. Tanmateix, el codi s'executa abans d'això i es mostra el resultat adequat.
Estructura d'excepció aritmètica
La classe base de l'excepció aritmètica és java.lang.ArithmeticException, que és la classe secundària de java.lang.RuntimeException, que al seu torn és la classe secundària de java.lang.Exception.
Constructor d'excepcions aritmètiques
Com es produeix l'excepció aritmètica?
Les següents són dues situacions en què es pot produir l'excepció aritmètica.
- Quan fem una divisió on s'utilitza 0 com a divisor, és a dir, 0 ve com a denominador.
- Un nombre decimal llarg que no acaba amb Big Decimal.
Dividir per 0
Nom de l'arxiu: 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); } } Sortida:
Exception in thread 'main' java.lang.ArithmeticException: / by zero at ArithmeticException.divide(ArithmeticException.java:6) at ArithmeticException.main(ArithmeticException.java:16)
Gran decimal sense terminació
Nom de l'arxiu: 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()); } } Sortida:
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ó: Al programa anterior, la classe Big Decimal no sap la sortida exacta, que ve després de la divisió, per mostrar. És perquè la sortida és una expansió decimal no final. Un enfocament per resoldre'l és proporcionar el límit. Per exemple, podem dir explícitament al programa que la sortida s'hauria de limitar a 6 decimals. Observa el programa següent.
Nom de l'arxiu: 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()); } } Sortida:
0.647058
Tractament de l'excepció aritmètica
Podem gestionar l'excepció aritmètica pel nostre compte mitjançant el bloc try-catch. Observa els programes següents.
Nom de l'arxiu: 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); } } Sortida:
Should avoid dividing by 0 java.lang.ArithmeticException: / by zero
Per a l'expansió decimal sense final, tot el que hem de fer és embolicar la línia on es produeix la divisió dins del bloc try.
Nom de l'arxiu: 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); } } } Sortida:
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.