Come lanciare un'eccezione in Java

Un'eccezione è un potenziale errore, di cui il sistema Java segnala il programma Java. Se l'eccezione (errore) non viene gestita, il thread in questione smetterà di funzionare. Se il programma fosse singolo, il programma smetterebbe di operare. Considera il seguente programma: Classe pubblica THECLASS
public static void main (string [] args)
Sistema.fuori.println ("visto 1");
int numeratore = 6;
int denominatore = 0;
int quoziente = numeratore / denominatore;
Sistema.fuori.println ("visto 2");
Sistema.fuori.println (quoziente);

Questo programma cerca di dividere per 0 alla quarta dichiarazione nel metodo principale (). In matematica, nessun numero dovrebbe essere diviso per 0. Anche i computer non lo consentono. Questo programma dovrebbe stampare "visto 1", quindi se la divisione per zero è possibile dal computer, il programma deve stampare "visto 2" e quindi stampare il quoziente di 6 diviso per zero.

Questo programma è compilato con successo dal compilatore Javac. Tuttavia, quando il programma è gestito dalla macchina virtuale Java (sistema operativo), viene stampato "visto 1" e il programma si interrompe alla quarta dichiarazione, in cui è prevista la divisione per zero, da cui (dove e poi) è un messaggio di errore emesso (visualizzato). Il programma interrompe l'esecuzione nella dichiarazione di divisione di zero, stampa un messaggio di errore e interrompe il funzionamento. Successivamente, le ultime due dichiarazioni non vengono eseguite (non operare).

Tuttavia, se questo fosse moltiplicazione per zero, che è consentito, allora le ultime due dichiarazioni sarebbero state eseguite. Questo articolo fornisce le basi del lancio e della gestione di un'eccezione in Java.

Gestione degli errori

Con Java, è possibile gestire un errore, come la divisione per zero, con un codice semplice; in modo che le dichiarazioni (codifica) dopo l'errore siano operate (eseguite). Qual è l'errore qui? - L'errore qui è divisione per zero. Il codice (soluzione) da parte del programmatore non dovrebbe consentire l'errore. Il programmatore deve codificare ciò che è noto come lancio dell'errore, che è un nuovo oggetto di eccezione. L'oggetto di eccezione deve essere catturato. Quando viene catturato l'oggetto eccezionale, il programma deve riprendersi da esso. Ripristina da un errore significa gestire l'eccezione.

La classe della libreria di eccezioni gestisce l'errore più del programmatore. La classe di eccezione non deve essere importata all'inizio del programma. Questa importazione viene eseguita automaticamente, senza l'aiuto del programmatore.

La classe di eccezione

Ci sono due principali classi di gestione degli errori in Java: la classe di eccezione e la classe di errore. Questo articolo tratta solo con la classe di eccezione. Come personaggio, la classe di eccezione conosce errori ordinari, come valori null di divisione per zero e indesiderati in una stringa letterale.

Quando viene lanciato un nuovo oggetto di eccezione, subito dopo l'istruzione che si tradurrebbe in un errore, la libreria delle classi di eccezione saprebbe l'errore; Se si tratta di un errore normale. La classe di eccezione non deve essere importata all'inizio del programma. Questa importazione viene eseguita automaticamente, senza l'aiuto del programmatore.

La dichiarazione di prova Java

La dichiarazione di prova è una dichiarazione composta, costituita dal blocco del tentativo e un blocco di cattura. In forma semplificata, la sintassi è:

Tentativo
//dichiarazione problema;
lanciare una nuova eccezione ();
* Dichiarazioni se non si verifica alcun errore *

catch (eccezione e)
Sistema.fuori.println ("Messaggio di eccezione:" + E.getMessage ());

provare è una parola riservata; Catch è una parola riservata. Il blocco del tentativo ha la dichiarazione del problema. Una dichiarazione come,

int quoziente = numeratore / denominatore;

è un'affermazione del problema. Se il denominatore non è zero, non si verifica alcun errore. Se il denominatore è zero, questo è un errore. La dichiarazione di lancio sarebbe in genere,

lanciare una nuova eccezione ();

Questa dichiarazione di lancio dovrebbe arrivare immediatamente dopo la dichiarazione del problema. Se si verifica un errore, l'istruzione di lancio lancia un nuovo oggetto di eccezione. Nota le parentesi. Se il denominatore è 0, viene lanciato un nuovo oggetto di eccezione. Sotto l'istruzione di lancio sono altre dichiarazioni che verrebbero eseguite se non si verificava alcun errore.

Il blocco di cattura sopra ha una dichiarazione. Può avere di più. La dichiarazione di lancio nel blocco di prova lancia un oggetto di eccezione, che viene catturato tra le parentesi della firma del blocco di cattura, per ulteriori elaborazioni all'interno del suo blocco. Questa attività è simile a una chiamata del metodo, con un argomento che deve essere ricevuto dalle parentesi dell'implementazione del metodo per ulteriori elaborazioni nel blocco del metodo.

Ricorda che l'oggetto eccezione può riconoscere diversi tipi di errori ordinari e far fronte a loro. L'oggetto di eccezione ha il metodo, getMessage (). Questo metodo restituisce un messaggio che l'utente può comprendere come causa dell'errore. Questa chiamata di metodo viene impiegata all'interno del blocco di cattura.

Il seguente programma mette in pratica la dichiarazione di prova, con il problema di divisione per zero sopra:

Classe pubblica TheClass
public static void main (string [] args)
Sistema.fuori.println ("visto 1");
int numeratore = 6; int denominatore = 0; int quoziente;
Tentativo
if (denominatore == 0)
quoziente = numeratore / denominatore;
lanciare una nuova eccezione ();

altro
quoziente = numeratore / denominatore;
Sistema.fuori.println ("visto 2");
Sistema.fuori.println (quoziente);

catch (eccezione e)
Sistema.fuori.println ("Messaggio di eccezione:" + E.getMessage ());

Sistema.fuori.println ("continua");

Il blocco del tentativo ha un'istruzione IF-COMPOUND. L'If-Part eseguirà l'istruzione del problema quando il denominatore è zero. La parte elne eseguirebbe l'istruzione del problema quando non si verificherebbe alcun errore quando il denominatore non è zero. Ciò significa che il programmatore deve guidare l'impiego dello schema di gestione delle eccezioni. E così, in questo caso, l'affermazione del problema è stata digitata due volte: una volta nella parte if e una volta nella parte else. La dichiarazione del problema non è preceduta da int perché il quoziente è stato dichiarato prima dell'istruzione composti prova.

Nel blocco del tentativo, l'istruzione Throw è appena al di sotto dell'istruzione problema. Non è nella parte altro dell'istruzione IF-COMPOUND. Non deve essere lì perché l'Else-Part è per la situazione in cui il denominatore (operando) non è zero (non ha problemi).

Leggi il programma sopra. Il numeratore è 6. Se il denominatore fosse 2, l'output sarebbe stato:

visto 1
visto 2
3
Continua

Ciò significa che è stata eseguita l'altra parte dell'istruzione IF-COMPOUND, non la parte IF dell'istruzione IF-COMPOUND. In effetti, l'IF-Part (codice) dell'istruzione IF-COMPOUND non è stata eseguita perché il denominatore non era zero. Il resto del codice nel blocco del tentativo è stato eseguito. Il resto del codice nel blocco del tentativo dovrebbe essere eseguito.

Quando il denominatore è 0, il programma produrrà l'output:

visto 1
Messaggio di eccezione: / per zero
Continua

Solo il codice nella parte if del blocco del tentativo è stato eseguito in questa situazione. Questo significa che l'affermazione di lancio è stata eseguita. L'Else-Part e il codice sotto l'istruzione IF-COMPOUND non sono stati eseguiti. Normalmente non sono eseguiti in questa situazione.

Il blocco di cattura non viene eseguito quando non c'è problema. Ora, il blocco di cattura è stato eseguito. Cioè, è stato eseguito il codice di istruzione singola nel blocco di cattura. Viene lanciato il nuovo oggetto di eccezione, è stato ricevuto come E. Il metodo getMessage () dell'oggetto, e che conosce gli errori ordinari (incluso l'errore di divisione per zero) hanno restituito il messaggio, "/ per zero".

Con questo errore restituito, l'utente saprebbe che si è verificato un errore di divisione per zero ed è stato gestito. La gestione, qui, significa che la divisione per zero non ha causato alcun danno al programma e, sebbene il resto del codice sotto il punto di errore nell'istruzione try-compund L'istruzione composta verrebbe eseguita. Se lo schema di gestione non fosse presente, il programma sarebbe terminato e qualsiasi codice seguente che non sarebbe stato nell'istruzione Try-Compound non sarebbe stato eseguito.

Lanciare un'eccezione, con un metodo

In Java, l'affermazione di Throw-Exception può lanciare un'eccezione nel blocco del tentativo, come illustrato sopra. Un metodo può anche lanciare un'eccezione, ma con una sintassi diversa, ancora correlata al blocco del tentativo. Il nucleo del codice bloccante è ora nel corpo del metodo e non nel blocco del tentativo. Il seguente programma ripete quello sopra, ma con un metodo che lancia l'eccezione. La classe con l'implementazione del metodo è:

classe aclass
int mthd (int nume, int deno) lancia l'eccezione
int quoti = nume / deno;
restituire quote;

Il codice principale nel metodo qui è l'istruzione del problema. L'istruzione del problema non è più nel blocco del tentativo (sotto). La dichiarazione del problema è stata digitata una volta, qui e per l'intero programma (non digitato due volte). L'espressione del lancio è ora diversa. È,

lancia un'eccezione

prolungare la firma del metodo a destra. "Lancia" qui è "lancia", con una s. L'eccezione, qui, non ha le parentesi.

Ora non è necessario per l'istruzione IF-COMPOUND in tutto il programma. Il corpo del metodo e "lancia un'eccezione" servono allo scopo della semantica dell'istruzione composto IF-ELSE. La classe principale diventa:

Classe pubblica TheClass
public static void main (string [] args)
Sistema.fuori.println ("visto 1");
int numeratore = 6; int denominatore = 0; int quoziente;
Tentativo
Aclasseobj = new aclass ();
quoziente = eobj.MTHD (numeratore, denominatore);
Sistema.fuori.println ("visto 2");
Sistema.fuori.println (quoziente);

catch (eccezione e)
Sistema.fuori.println ("Messaggio di eccezione:" + E.getMessage ());

Sistema.fuori.println ("continua");

Ha ancora l'istruzione composta da try-catch. Tuttavia, l'affermazione del problema non è qui e non è digitata due volte. Anche l'istruzione composto If-Else non è qui. Non è più necessario da nessuna parte nel programma. L'output con il suo messaggio di errore è lo stesso di prima, io.e.

visto 1
Messaggio di eccezione: / per zero
Continua

Il comportamento del programma completo è come prima.

La clausola finalmente

La dichiarazione di prova ha tre clausole: la clausola di prova, la clausola catch e la clausola finalmente. Ci può essere più di una clausola di cattura - vedi più tardi. Il blocco infine arriva alla fine dell'istruzione Try-Compone, ed è per il programmatore trasmettere un messaggio all'utente che è stato gestito il possibile errore. La codifica della clausola finalmente è facoltativa. Il seguente codice illustra un uso della clausola finalmente per il programma sopra:

Sistema.fuori.println ("visto 1");
int numeratore = 6; int denominatore = 0; int quoziente;
Tentativo
Aclasseobj = new aclass ();
quoziente = eobj.MTHD (numeratore, denominatore);
Sistema.fuori.println ("visto 2");
Sistema.fuori.println (quoziente);

catch (eccezione e)
Sistema.fuori.println ("Messaggio di eccezione:" + E.getMessage ());

Finalmente
Sistema.fuori.println ("qualsiasi errore è stato gestito.");

Se il denominatore è 2, l'output sarebbe:

visto 1
visto 2
3
Qualsiasi errore è stato gestito.
Continua

Se il denominatore è 0, l'output sarebbe:

visto 1
Messaggio di eccezione: / per zero
Qualsiasi errore è stato gestito.
Continua

Il blocco infine viene eseguito, indipendentemente dal fatto che si sia verificato un errore.

Conclusione

Viene lanciata un'eccezione, con la semplice istruzione nel blocco Try, eventualmente codificata con un'istruzione IF-COMPOUND e l'istruzione problematica. Un'eccezione può ancora essere lanciata con un metodo in relazione all'istruzione Try-Cpound. Questo articolo è stato le basi per lanciare un'eccezione in Java.