Errors ed Exceptions in Java

La lingua del Java fa le Exceptionsdi uso per fornire le possibilit� di trattamento degli Errorsper tutti i relativi programmi. Qui voi imparerete che cosa fanno una media di eccezione, come gettare ed interferire le eccezioni, che cosa fare con l'eccezione la avete interferita una volta che e come fare l'uso migliore della gerarchia del codice categoria di eccezione fornita dall'ambiente di sviluppo del Java.

Che cosa fa un'eccezione?

Definizione: Un'eccezione � un evento che si presenta durante l'esecuzione del programma che interrompe il flusso normale delle istruzioni. I tipi differenti di Errorspossono causare le eccezioni: i problemi che variano dagli Errorsdi fissaggi serii, quale l'arresto del disco rigido, agli Errorsdi programmazione semplici, come provare ad accedere al fuori-de-limita l'elemento di allineamento. Quando tale errore si presenta all'interno di un metodo del Java, il metodo generer� un oggetto e le mani di eccezione esso al sistema runtime. L'oggetto di eccezione contiene le informazioni su eccezione compreso il relativo tipo e dichiara del programma quando l'errore ha accaduto. Il sistema Runtime � allora responsabile trovare un certo codice per maneggiare l'errore. Nella terminologia del Java, generante l'oggetto di eccezione e passante lo al sistema runtime � chiamato �gettare un'eccezione�.

Il fermo del Hotjava o dichiara il requisito

import java.io.*;
import java.util.Vector;

class ListOfNumbers
{
private Vector victor;
final int size = 10;

public ListOfNumbers ()
{
int i;
victor = new Vector(size);
for (i = 0; i < size; i++)
victor.addElement(new Integer(i));
}
public void writeList()
{
PrintStream pStr = null;

System.err.println("Entering try statement");
int i;
pStr = new PrintStream(
new BufferedOutputStream(
new FileOutputStream("OutFile.txt")));

for (i = 0; i < size; i++)
pStr.println("Value at: " + i + " = " + victor.elementAt(i));

pStr.close();
}
}

L'esempio qui sopra definisce ed effettua il codice categoria chiamato �ListOfNumbers�. Su costruzione, il codice categoria di ListOfNumbers genera un vettore che contiene dieci elementi di numero intero con i valori sequenziali da 0 a 9. Il codice categoria di ListOfNumbers inoltre definisce il metodo �writeList ()� che redige la lista dei numeri nella lima di testo �OutFile.txt�. Il metodo di writeList () denomina su due nuovi metodi che possono gettare le eccezioni.

First,

pStr = new PrintStream(new BufferedOutputStream(new FileOutputStream("OutFile.txt")));

Questa linea invoca il costruttore per FileOutputStream che getta uno IOException quando la lima non pu� essere aperta per c'� ne del motivo.

Second, the Vector class's elementAt() method

pStr.println("Value at: " + i + " = " + victor.elementAt(i));

Questo metodo getter� ArrayIndexOutOfBoundsException se passate un indice di cui il valore � molto piccolo (numero negativo) o molto grande (pi� grande del numero di elementi contenuti attualmente dal vettore).

Se provate a compilare il codice categoria di ListOfNumbers, il compilatore stampa il messaggio di errore circa un'eccezione gettata dal costruttore del FileOutputStream, ma non visualizzer� il messaggio di errore circa un'eccezione gettata da elementAt (). Ci� � perch� l'eccezione gettata dal costruttore di FileOutputStream, IOException, fa eccezione di non-tempo di esecuzione e l'eccezione gettato con il metodo del elementAt (), ArrayIndexOutOfBoundsException, � l'eccezione runtime. Java richiede per interferire o dichiarare soltanto le Exceptionsdi non-tempo di esecuzione.

Interferire e maneggiare un'eccezione

Il primo punto per la costruzione dell'alimentatore di eccezione � accludere le dichiarazione che potrebbero gettare l'eccezione all'interno del blocchetto di prova. Generalmente, sguardi del blocchetto di prova qualcosa di simile:

try
{
Java statements
}

Il segmento �dichiarazione del Java� nel codice qui sopra � costituito una o pi� dichiarazione legali del Java in grado di potenzialmente gettare un'eccezione. Per costruire l'alimentatore di eccezione per il metodo di writeList () dal codice categoria di ListOfNumbers, dobbiamo accludere le dichiarazione eccezione-gettanti del metodo di writeList () all'interno del blocchetto di prova. Ci sono pi� di sensi uno compire questa operazione: possiamo mettere ogni dichiarazione che pu� potenzialmente gettare l'eccezione all'interno della relativa propria dichiarazione di prova e forniamo agli alimentatori separati di eccezione per ciascuna della prova. O potete mettere tutte le dichiarazione di writeList () all'interno di singola dichiarazione di prova ed associare gli alimentatori multipli ad esso. Il seguente esempio usa la singola dichiarazione di prova per l'intero metodo mentre il codice tende ad essere pi� facile da leggere.

PrintStream pstr;
try
{
int i;

System.err.println("Entering try statement");
pStr = new PrintStream(
new BufferedOutputStream(
new FileOutputStream("OutFile.txt")));

for (i = 0; i < size; i++)
pStr.println("Value at: " + i + " = " + victor.elementAt(i));
}

La dichiarazione di prova governa le dichiarazione allegate all'interno di esso e definisce la portata di tutti gli alimentatori di Exceptions(che sono stabiliti dai blocchetti successivi del fermo) connessi con esso. Cio� se un'eccezione si presenta all'interno della dichiarazione di prova, quindi che l'eccezione � maneggiata tramite un certo alimentatore adatto di eccezione che � associato con questa dichiarazione di prova.

I blocchetti del fermo

Come studiato prima, la dichiarazione di prova definisce la portata degli alimentatori collegati di eccezione. Associamo gli alimentatori di eccezione con una dichiarazione di prova fornendo uno o pi� dei blocchetti sequenziali del fermo direttamente dopo che un blocchetto di prova.

try
{
. . .
} catch ( . . . )
{
. . .
} catch ( . . . )
{
. . .
} . . .

Non ci pu� essere codice d'intervento fra la fine della dichiarazione di prova e l'inizio della prima dichiarazione del fermo. La forma generale della dichiarazione del fermo �:

catch (SomeThrowableClassName variableName)
{
Java statements
}

La dichiarazione del fermo governa la serie di dichiarazione legali del Java. Queste dichiarazione sono eseguite quando l'alimentatore di eccezione � invocato. Il sistema runtime invoca l'alimentatore di eccezione quando un'eccezione di cui il tipo abbina con quello della discussione della dichiarazione del fermo � gettata all'interno del blocchetto di prova dell'alimentatore.

Il metodo di writeList () dal codice categoria di ListOfNumbers usa due alimentatori per la dichiarazione di prova, un alimentatore di eccezione per ciascuno dei due tipi di Exceptionsche possono essere gettate all'interno di un blocchetto, di un ArrayIndexOutOfBoundsException e di uno IOException di prova.

try
{
. . .
} catch (ArrayIndexOutOfBoundsException e)
{
System.err.println("Caught ArrayIndexOutOfBoundsException: " + e.getMessage()); } catch (IOException e)
{
System.err.println("Caught IOException: " + e.getMessage());
}