Det Undtagelse Håndtering er en af de mest kraftfulde mekanismer til at håndtere runtime-fejlene, så det normale flow af applikationen kan opretholdes. I Java er undtagelse en unormal tilstand. Java programmeringssprog definerer forskellige undtagelser. I dette afsnit vil vi diskutere den ene af de fremtrædende undtagelser, dvs Aritmetisk Undtagelse i Java.
Den aritmetiske undtagelse er en type usædvanligt udfald eller ukontrolleret fejl i koden, som kastes eller hæves, når en forkert matematisk eller aritmetisk operation vises i koden under kørselstiden. Et runtime-problem, også kaldet en undtagelse, dukker op, når nævneren for en brøk er 0, og JVM'en ikke er i stand til at finde ud af resultatet; derfor afsluttes programafviklingen, og der rejses en undtagelse. Bemærk, at på det punkt, hvor undtagelsen er blevet rejst, afsluttes programmet. Imidlertid udføres koden tidligere end det, og det relevante resultat vises.
Aritmetisk undtagelsesstruktur
Den aritmetiske undtagelsesbasisklasse er java.lang.ArithmeticException, som er underklassen af java.lang.RuntimeException, som igen er underklassen af java.lang.Exception.
Aritmetisk undtagelseskonstruktør
Hvordan opstår aritmetiske undtagelser?
Det følgende er to situationer, hvor den aritmetiske undtagelse kan forekomme.
- Når vi udfører en division, hvor 0 bruges som divisor, kommer 0 som nævneren.
- Et langt decimaltal, der ikke afsluttes med Big Decimal.
Divider med 0
Filnavn: 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); } } Produktion:
Exception in thread 'main' java.lang.ArithmeticException: / by zero at ArithmeticException.divide(ArithmeticException.java:6) at ArithmeticException.main(ArithmeticException.java:16)
Ikke-afsluttende stor decimal
Filnavn: 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()); } } Produktion:
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)
Forklaring: I ovenstående program kender Big Decimal-klassen ikke det nøjagtige output, som kommer efter division, der skal vises. Det skyldes, at outputtet er ikke-afsluttende decimaludvidelse. En tilgang til at løse det er at give grænsen. For eksempel kan vi sige eksplicit i programmet, at output skal begrænses til 6 decimaler. Overhold følgende program.
Filnavn: 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()); } } Produktion:
0.647058
Håndtering af aritmetisk undtagelse
Vi kan håndtere den aritmetiske undtagelse på egen hånd ved hjælp af try-catch-blokken. Overhold følgende programmer.
Filnavn: 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); } } Produktion:
Should avoid dividing by 0 java.lang.ArithmeticException: / by zero
For ikke-afsluttende decimaludvidelse er alt, hvad vi skal gøre, at ombryde linjen, hvor divisionen finder sted inde i prøveblokken.
Filnavn: 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); } } } Produktion:
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.