Parole Chiave throw e throws Java

In questo tutorial, impareremo a gestire le eccezioni utilizzando i modi throw e throws con l'aiuto di esempi.

In Java, le eccezioni possono essere classificate in due tipi:

• Eccezioni non controllate:Non vengono controllate durante la compilazione, ma durante l'esecuzione, ad esempio: ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, eccezioni sotto la classe Error ecc.

• Eccezioni controllate:Controllarli durante la compilazione. Ad esempio IOException, InterruptedException ecc.

Si prega di consultareEccezioni JavaPer una comprensione dettagliata delle eccezioni controllate e non controllate.

Di solito, non è necessario gestire eccezioni non controllate. Questo perché le eccezioni non controllate si verificano a causa di errori di programmazione. E correggerle invece di gestirle è un'abitudine buona.

Ora, questo tutorial si concentrerà su come utilizzare throw e throws per gestire le eccezioni checked.

Java throws chiave

Usiamo la parola chiave throws nel dichiarare il tipo di eccezione che può verificarsi nel metodo.

La sua sintassi è:

accessModifier returnType methodName() throws ExceptionType1, ExceptionType2 … {
　　// code
}

Da sopra la sintassi, possiamo vedere che possiamo utilizzare throws per dichiarare più eccezioni.

Esempio 1: Java throws chiave

import java.io.*;
class Main {
　　public static void findFile() throws IOException {
　　　　// Può generare IOException codice
　　　　File newFile = new File("test.txt");
　　　　FileInputStream stream = new FileInputStream(newFile);
　　}
　　public static void main(String[] args) {
　　　　try{
　　　　　　findFile();
　　　　} catch(IOException e){
　　　　　　System.out.println(e);
　　　　}
　　}
}

Risultato di output

java.io.FileNotFoundException: test.txt (File o directory non trovato)

Se il metodo non gestisce le eccezioni, deve specificare nel costrutto throws il tipo di eccezione che può verificarsi nel metodo, in modo che i metodi più alti nella gerarchia delle chiamate possano gestirle o utilizzarne la parola chiave throws.

Il metodo findFile() specifica che può lanciare IOException. Il metodo main() chiama questo metodo e gestisce le eccezioni lanciate.

Generazione di più eccezioni

Questo è come possiamo utilizzare la parola chiave throws per generare più eccezioni.

import java.io.*;
class Main {
　　public static void findFile() throws NullPointerException, IOException, InvalidClassException {
　　　　
　　　　// Può generare NullPointerException codice
　　　　… … …　
　　　　// Può generare IOException codice
　　　　… … …　
　　　　// Può generare InvalidClassException codice　
　　　　… … …　
　　}
　　public static void main(String[] args) {
　　　　try{
　　　　　　findFile();
　　　　catch(IOException e1){
　　　　　　System.out.println(e1.getMessage());
　　　　} catch(InvalidClassException e2) {
　　　　　　System.out.println(e2.getMessage());
　　　　}
　　}
}

Qui, il metodo findFile() specifica che può lanciare NullPointerException, IOException e InvalidClassException nella sua clausola throws.

Si prega di notare che non abbiamo ancora gestito NullPointerException. Questo perché è un'eccezione non controllata. Non è necessario specificarlo nella clausola throws e gestirlo.

Chiave throws con try...catch...finally

Può esserci più di un metodo che causa un'eccezione. Scrivere try...catch per ciascun metodo sarebbe noioso e il codice diventerebbe lungo e difficile da capire.

Quando hai già verificato un'eccezione che non desideri catturare nel metodo corrente (un'eccezione che deve essere gestita), throws è anche molto utile.

Chiave throw in Java

La chiave throw viene utilizzata per lanciare esplicitamente un'eccezione.

Quando si lancia un'eccezione, il flusso di esecuzione del programma passa dal blocco try al blocco catch. Usiamo la chiave throw nel metodo.

La sua sintassi è:

throw throwableObject;

Un oggetto Throwable è un'istanza della classe Throwable o di una sottoclasse di Throwable.

Esempio 2: Chiave di throw in Java

class Main {
　　public static void divideByZero() {
　　　　throw new ArithmeticException("tentativo di dividere per zero");
　　}
　　public static void main(String[] args) {
　　　　divideByZero();
　　}
}

Risultato di output

Eccezione in thread "main" java.lang.ArithmeticException: tentativo di dividere per zero
　　　　at Main.divideByZero(Main.java:3)
　　　　at Main.main(Main.java:7)
stato di uscita 1

In questo esempio, lanciamo esplicitamente ArithmeticException.

Attenzione: ArithmeticException è un'eccezione non controllata. Di solito non c'è bisogno di gestire un'eccezione non controllata.

Esempio 3: Lanciare un'eccezione controllata

import java.io.*;
class Main {
　　public static void findFile() throws IOException {
　　　　throw new IOException("File non trovato");
　　}
　　public static void main(String[] args) {
　　　　try {
　　　　　　findFile();
　　　　　　System.out.println("Resto del codice nel blocco try");
　　　　} catch (IOException e) {
　　　　　　System.out.println(e.getMessage());
　　　　}
　　}
}

Risultato di output

File non trovato

Il metodo findFile() lancia un IOException passando un messaggio al costruttore.

Attenzione, poiché è un'eccezione di controllo, deve essere specificata nella clausola throws.

Il metodo che chiama findFile() deve gestire questa eccezione o specificarla utilizzando la chiave parole throws.

Abbiamo gestito questo eccezione nel metodo main(). Quando si verifica un'eccezione, il flusso di esecuzione del programma viene trasferito tra i blocchi try e catch. Di conseguenza, il codice restante nel blocco try viene saltato e vengono eseguite le istruzioni nel blocco catch.