De Undantag Hantering är en av de mest kraftfulla mekanismerna för att hantera runtime-felen så att programmets normala flöde kan bibehållas. I Java är undantag ett onormalt tillstånd. Java programmeringsspråk definierar olika undantag. I det här avsnittet kommer vi att diskutera ett av de framträdande undantagen som är ArithmeticException i Java.
Det aritmetiska undantaget är en typ av ovanligt utfall eller okontrollerat fel i koden, som kastas eller höjs när en felaktig matematisk eller aritmetisk operation visas i koden under körning. Ett körtidsproblem, även kallat undantag, dyker upp när nämnaren för ett bråk är 0 och JVM inte kan ta reda på resultatet; därför avslutas programexekveringen och ett undantag tas upp. Observera att vid den punkt där undantaget har tagits upp avslutas programmet. Koden exekveras dock tidigare och lämpligt resultat visas.
Aritmetisk undantagsstruktur
Den aritmetiska undantagsbasklassen är java.lang.ArithmeticException, som är den underordnade klassen för java.lang.RuntimeException, som i sin tur är den underordnade klassen för java.lang.Exception.
Aritmetisk undantagskonstruktör
Hur inträffar aritmetiska undantag?
Följande är två situationer där det aritmetiska undantaget kan förekomma.
- När vi utför en division där 0 används som divisor, dvs 0 kommer som nämnare.
- Ett långt decimaltal som inte avslutas med stor decimal.
Dividera med 0
Filnamn: 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)
Icke-avslutande stor decimal
Filnamn: 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)
Förklaring: I programmet ovan vet inte klassen Big Decimal den exakta utdata, som kommer efter division, att visa. Det beror på att utgången är icke-avslutande decimalexpansion. Ett sätt att lösa det är att ge gränsen. Till exempel kan vi säga uttryckligen i programmet att utdata ska begränsas till 6 decimaler. Observera följande program.
Filnamn: 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
Hantering av aritmetiskt undantag
Vi kan hantera det aritmetiska undantaget på egen hand med hjälp av try-catch-blocket. Observera följande program.
Filnamn: 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
För icke-avslutande decimalexpansion, allt vi behöver göra är att linda linjen där division sker inuti försöksblocket.
Filnamn: 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.