De Unntak Håndtering er en av de kraftigste mekanismene for å håndtere kjøretidsfeil slik at normal flyt av applikasjonen kan opprettholdes. I Java er unntak en unormal tilstand. Java programmeringsspråk definerer ulike unntak. I denne delen vil vi diskutere det ene av de fremtredende unntakene som er Aritmetisk unntak i Java.

Det aritmetiske unntaket er en type uvanlig utfall eller ukontrollert feil i koden, som blir kastet eller hevet når en feil matematisk eller aritmetisk operasjon vises i koden under kjøretiden. Et kjøretidsproblem, også kalt et unntak, vises når nevneren til en brøk er 0, og JVM ikke er i stand til å finne ut resultatet; derfor avsluttes programkjøringen, og et unntak oppstår. Vær oppmerksom på at programmet avsluttes når unntaket er opphevet. Imidlertid kjøres koden tidligere enn det, og det riktige resultatet vises.

Aritmetisk unntaksstruktur

Basisklassen for aritmetisk unntak er java.lang.ArithmeticException, som er barneklassen til java.lang.RuntimeException, som igjen er barneklassen til java.lang.Exception.

Aritmetisk unntakskonstruktør

ArithmeticException():Den brukes til å definere et aritmetisk unntak med null parametere bestått.ArithmeticException(String s):Den brukes til å definere et aritmetisk unntak med en parameter bestått.

Hvordan forekommer aritmetiske unntak?

Følgende er to situasjoner der det aritmetiske unntaket kan forekomme.

1. Når vi utfører en divisjon der 0 brukes som divisor, det vil si at 0 kommer som nevner.
2. Et langt desimaltall som ikke avsluttes med stor desimal.

Del 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); } } 

Produksjon:

 Exception in thread 'main' java.lang.ArithmeticException: / by zero at ArithmeticException.divide(ArithmeticException.java:6) at ArithmeticException.main(ArithmeticException.java:16) 

Ikke-avsluttende stor desimal

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()); } } 

Produksjon:

 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 programmet ovenfor vet ikke Big Desimal-klassen den nøyaktige utgangen, som kommer etter divisjon, som skal vises. Det er fordi utgangen er ikke-avsluttende desimalutvidelse. En måte å løse det på er å gi grensen. For eksempel kan vi fortelle eksplisitt i programmet at utgangen skal begrenses til 6 desimaler. Følg 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()); } } 

Produksjon:

 0.647058 

Håndtering av aritmetisk unntak

Vi kan håndtere det aritmetiske unntaket på egen hånd ved å bruke try-catch-blokken. Vær oppmerksom på 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); } } 

Produksjon:

 Should avoid dividing by 0 java.lang.ArithmeticException: / by zero 

For ikke-avsluttende desimalutvidelse, er alt vi trenger å gjøre å vikle linjen der divisjonen skjer inne 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); } } } 

Produksjon:

 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.