Gestione delle eccezioni Java

Quando il flusso normale dell'esecuzione del programma si interrompe per qualsiasi errore, viene chiamato eccezione. Questo tipo di evento può essere gestito utilizzando un try-catch-finalmente bloccare. Un'eccezione è un oggetto che viene utilizzato per catturare l'errore ed eseguire l'istruzione in base alla condizione di errore che si chiama gestione delle eccezioni. Principalmente due tipi di errore vengono gestiti dalla gestione delle eccezioni. Questi sono tempo compilato errori e Runtime errori. IL Runtime Gli errori sono gestiti dalla gestione delle eccezioni. Come puoi gestire le eccezioni in Java è spiegato in questo tutorial.

Sintassi:

La sintassi di Il try-catch-finalmente Il blocco è riportato di seguito.

Tentativo
Dichiarazione 1 ... N

catch (eccezionettype var)
Dichiarazione 1 ... N

Finalmente
Dichiarazione 1 ... N

Qui, se si verifica un'eccezione all'interno del blocco di prova, l'eccezione verrà lanciata nel blocco catch e il blocco finalmente è opzionale qui. Il codice del blocco finalmente esegue se si verifica o meno un'eccezione.

Esempio-1: gestione delle eccezioni con un singolo blocco di cattura

L'esempio seguente mostra l'uso della gestione delle eccezioni utilizzando un singolo blocco di cattura. Un nome file verrà preso come input e creerà un oggetto di bufferedReader per aprire un file per la lettura. Se esiste il nome file, il contenuto del file verrà letta riga per riga e stampato. Se il file non esiste, verrà generata un'eccezione e verrà stampato un messaggio di errore.

Importa Java.io.BufferedReader;
Importa Java.io.Filereader;
Importa Java.io.Ioexception;
Importa Java.util.Scanner;
classe pubblica tranne1
public static void main (string [] args)
// Crea un oggetto scanner
Scanner in = nuovo scanner (sistema.In);
Sistema.fuori.print ("Immettere il nome file:");
// prendi i dati di stringa dall'utente
String FileName = in.Prossimo();
Tentativo
// Crea un oggetto Reader
BufferedReader Reader = new BufferedReader (New FileReader (FileName));
// Leggi la prima riga se il file esiste
Riga stringa = lettore.linea di lettura();
mentre (linea != null)
// Stampa la linea
Sistema.fuori.println (linea);
// Leggi la riga successiva
riga = lettore.linea di lettura();

// Chiudi l'oggetto lettore
lettore.vicino();
// Chiudi l'oggetto scanner
In.vicino();
catch (ioException e)
// Stampa il messaggio di errore
Sistema.fuori.println ("Il file non esiste");

Produzione:

Nel seguente output, 'Ciao.TXT' è dato come file file che non esiste. Quindi viene stampato il seguente messaggio.

La prossima volta, File1.TXT è dato come nome file esistente e l'output mostra il contenuto del file.

Esempio 2: gestione delle eccezioni con più blocco di cattura

Come è possibile utilizzare più blocchi di cattura per gestire più eccezioni è mostrato nel seguente esempio. Qui, sono dichiarati tre blocchi di cattura. Il primo blocco di cattura catturerà l'errore aritmetico quando viene eseguita qualsiasi operazione aritmetica illogica. La seconda cattura Bock catturerà l'errore fuori porta dell'array quando verrà provato a leggere un valore dell'indice di array che non esiste. Il terzo blocco di cattura catturerà l'errore del valore numerico quando viene indicato un valore di carattere o stringa. Nel codice, un array con quattro indici viene dichiarato e inizializzato con i valori interi che verranno prelevati dall'utente. I valori dell'array sono stampati utilizzando un loop. Un'operazione di divisione viene eseguita alla fine del blocco di prova.

Importa Java.util.Scanner;
classe pubblica tranne2
public static void main (string [] args)

Tentativo

// Dichiara un array numerico
int num_arr [] = new int [4];
// Crea un oggetto scanner
Scanner in = nuovo scanner (sistema.In);
Sistema.fuori.println ("Immettere quattro numeri:");
// itera il ciclo quattro volte
per (int i = 0; i < 4; i++)
// Numero di input
int n = in.NextInt ();
// Assegna il valore all'array
num_arr [i] = n;

Sistema.fuori.println ("I valori dell'array sono:");
// itera il ciclo cinque volte
per (int i = 0; i < 4; i++)
// Stampa i valori dell'array
Sistema.fuori.println (num_arr [i]);

// Dividi e stampa il valore
int num = 50/0;
Sistema.fuori.stampa (num);
// Chiudi l'oggetto scanner
In.vicino();

catch (aritmeticexception e)

Sistema.fuori.println ("Nessun numero è divisibile per 0");

catch (ArrayIndexoutoFboundSexception E)

Sistema.fuori.println ("Valore dell'indice dell'array si è verificato");

cattura (eccezione E)

Sistema.fuori.println ("Il valore del numero non è indicato");

Produzione:

Il seguente output mostra che i valori dell'array vengono inseriti e stampati correttamente, ma il terzo blocco di cattura viene eseguito perché 50 è diviso per 0, il che è un errore.

Il programma viene eseguito per la seconda volta. Quando viene fornito un valore di stringa come valore di array, viene generata la seconda eccezione e viene eseguita l'istruzione del secondo blocco di cattura.

Esempio-3: gestione delle eccezioni con blocco try-catch-finalmente

L'uso del blocco finalmente con il blocco try-catch è mostrato nel seguente esempio. Il codice del blocco finalmente esegue se si verifica un'eccezione o meno. Nel codice, un valore intero verrà preso dall'utente. Se l'utente fornisce un valore di stringa, quindi InputMismatchException

Genererà e stampa il messaggio dal blocco catch. L'oggetto scanner verrà chiuso in Finalmente bloccare se l'eccezione genera o no.

Importa Java.util.Scanner;
Importa Java.util.InputMismatchException;
classe pubblica tranne3
public static void main (string [] args)
// Crea un oggetto scanner
Scanner in = nuovo scanner (sistema.In);
Sistema.fuori.print ("Immettere un numero:");
Tentativo
// prendi i dati di stringa dall'utente
int numero = in.NextInt ();
// Stampa il numero
Sistema.fuori.println ("il valore di numero =" + numero);
catch (inputMismatchException e)
// Stampa Messaggio di errore
Sistema.fuori.println ("Il valore della stringa non è accettato.");

Finalmente
// Chiudi l'oggetto scanner
In.vicino();
Sistema.fuori.println ("terminato dal programma");

Produzione:

78 è indicato come valore di input nel seguente output dopo l'esecuzione del codice. Quindi, nessuna eccezione viene generata qui. Il messaggio dal blocco finalmente viene stampato in seguito.

Prossimo, Ciao viene dato come input dopo aver eseguito il codice che è una stringa. Quindi, l'eccezione viene generata e il messaggio di errore dal blocco catch viene stampato. Il messaggio dal blocco finalmente viene stampato in seguito.

Conclusione:

La gestione delle eccezioni è una caratteristica molto importante e utile di qualsiasi linguaggio di programmazione che può essere utilizzato per nascondere il messaggio di errore reale dall'utente e fornire il messaggio di errore leggibile dall'uomo per l'utente per comprendere correttamente l'errore. Questo tutorial aiuta l'utente ad apprendere diversi modi per applicare la gestione delle eccezioni in Java e rendere il loro codice più appropriato.