IL Eccezione La gestione è uno dei meccanismi più potenti per gestire gli errori di runtime in modo da poter mantenere il normale flusso dell'applicazione. In Java, l'eccezione è una condizione anomala. Il linguaggio di programmazione Java definisce varie eccezioni. In questa sezione discuteremo quella delle eccezioni più importanti ArithmeticException a Giava.

L'eccezione aritmetica è un tipo di risultato insolito o errore non controllato del codice, che viene generato o sollevato ogni volta che nel codice viene visualizzata un'operazione matematica o aritmetica errata durante il runtime. Un problema di runtime, chiamato anche eccezione, appare ogni volta che il denominatore di una frazione è 0 e la JVM non è in grado di trovare il risultato; quindi l'esecuzione del programma viene terminata e viene sollevata un'eccezione. Si noti che nel momento in cui viene sollevata l'eccezione, il programma termina. Tuttavia, viene eseguito il codice precedente e viene visualizzato il risultato appropriato.

Struttura delle eccezioni aritmetiche

La classe base dell'eccezione aritmetica è java.lang.ArithmeticException, che è la classe figlia di java.lang.RuntimeException, che a sua volta è la classe figlia di java.lang.Exception.

Costruttore di eccezioni aritmetiche

Eccezione aritmetica():Viene utilizzato per definire un'eccezione aritmetica con zero parametri passati.Eccezione aritmetica(Stringa s):Viene utilizzato per definire un'eccezione aritmetica con un parametro passato.

Come si verificano le eccezioni aritmetiche?

Di seguito sono riportate due situazioni in cui può verificarsi l'eccezione aritmetica.

1. Quando eseguiamo una divisione in cui 0 viene utilizzato come divisore, ovvero 0 viene utilizzato come denominatore.
2. Un numero decimale lungo che non termina con Big Decimal.

Dividi per 0

Nome del file: 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); } } 

Produzione:

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

Grande decimale non terminante

Nome del file: 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()); } } 

Produzione:

 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) 

Spiegazione: Nel programma precedente, la classe Big Decimal non conosce l'output esatto da visualizzare dopo la divisione. È perché l'output è un'espansione decimale non terminante. Un approccio per risolverlo è fornire il limite. Ad esempio, possiamo dire esplicitamente nel programma che l'output dovrebbe essere limitato a 6 cifre decimali. Osservare il seguente programma.

Nome del file: 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()); } } 

Produzione:

 0.647058 

Gestione delle eccezioni aritmetiche

Possiamo gestire l'eccezione aritmetica da soli utilizzando il blocco try-catch. Osservare i seguenti programmi.

Nome del file: 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); } } 

Produzione:

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

Per l'espansione decimale non finale, tutto ciò che dobbiamo fare è avvolgere la riga in cui avviene la divisione all'interno del blocco try.

Nome del file: 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); } } } 

Produzione:

 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.