Java Prova - Cattura

Possono verificarsi errori durante l'esecuzione del programma. È un problema comune a ogni programmatore, dal principiante al vero professionista. Non tutti gli errori derivano dalla colpa dello sviluppatore. Alcuni di essi sono difficili da prevedere e talvolta non è possibile. Ad esempio, durante il download di un programma, la connessione di rete potrebbe interrompersi improvvisamente o l'alimentazione potrebbe interrompersi. Tali situazioni sono chiamate eccezioni. Prova e cattura sono le parti della costruzione utilizzate per gestire le eccezioni.

Java prova a catturare il blocco

Quando si verifica un errore, Java solitamente si arresta e genera un messaggio di errore. Questo processo è chiamato "Java genera un'eccezione". Java fornisce funzionalità speciali per la gestione delle eccezioni. Uno di questi è provare... catturare... infine costruire. Ecco la sintassi di try block, catch block e infine block.

//try block
try {
  // Block of code to try
}
//try catch
catch(Exception e) {
  // Block of code to handle errors
}
finally {
 // Optional block of code
          }

Quando si verifica un'eccezione nel blocco try, il controllo passa al blocco catch, che può gestire l'eccezione. Se non viene trovato alcun blocco di questo tipo, all'utente viene visualizzato un messaggio di eccezione non gestita e l'ulteriore esecuzione del programma viene interrotta. È per prevenire un arresto di emergenza di questo tipo che è necessario utilizzare il blocco try..catch.

Brevemente su prova, cattura, infine, lancia parole chiave

La gestione delle eccezioni in Java si basa sull'uso delle seguenti parole chiave in un programma:

• try: definisce un blocco di codice in cui può verificarsi un'eccezione;
• catch — definisce il blocco di codice in cui viene gestita l'eccezione;
• infine: definisce un blocco di codice facoltativo ma, se presente, viene comunque eseguito, indipendentemente dai risultati del blocco try.

Queste parole chiave vengono utilizzate per creare speciali costrutti di elaborazione nel codice del programma: try catch e try catch final}.

• Throw: utilizzato per sollevare un'eccezione;
• lanci: utilizzato nelle firme dei metodi per avvisare che un metodo potrebbe generare un'eccezione.

Semplice esempio di costruzione try-catch

Diciamo di avere un programma con qualche array.

public class TryTest {
   public static void main(String[] args) {
       int[] myArray = new int[5];
       myArray[7] = 8;
       System.out.println(myArray[7]);
   }
}

Poiché stiamo tentando di accedere a un elemento dell'array con un indice inesistente, il programma uscirà con un errore: Modifichiamo questo programma e gestiamo questa eccezione con un try-catch. Prima arriva il tentativo di bloccare, poi il blocco di cattura.

//try catch example
public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
           System.out.println("The exception was handled...");
       }

       System.out.println("This is the end of the program...");
   }
}

Ora l'output è cambiato: In questo caso, a programma completato correttamente, sullo schermo verrà visualizzato il nostro messaggio. La corretta conclusione del programma viene segnalata dal codice 0 alla fine del processo, mentre l'errato — 1. Quando si utilizza un blocco try...catch, tutte le istruzioni comprese tra try e catch vengono eseguite per prime. Se si verifica un'eccezione nel blocco try, il normale ordine di esecuzione si interrompe e procede all'istruzione catch. Pertanto, quando l'esecuzione del programma raggiunge i numeri[7]=8; linea, il programma si fermerà e andrà al blocco catch Nel nostro caso, abbiamo dichiarato la variabile myEx con il tipo Exception. Questa è la classe base per tutte le eccezioni e quindi possono essere diverse. Ad esempio, ci sono eccezioni responsabili di stack overflow, che vanno oltre l'indicizzazione dell'array, come nel nostro caso, puntando a Null e così via. Se non avessimo indovinato il tipo di eccezione, anche il programma sarebbe terminato in modo errato. Tuttavia, abbiamo scelto il tipo Exception per semplicità dell'esempio ed è la classe base per tutte le eccezioni. Quindi l'istruzione catch (Exception myEx) gestirà quasi tutte le eccezioni. Gestire l'eccezione in questo caso Una volta completato il blocco catch, il programma continua il suo lavoro, eseguendo tutte le altre istruzioni dopo il blocco catch. Se vuoi vedere le eccezioni che si sono verificate, puoi fare in modo che il programma stampi una traccia dello stack delle chiamate al metodo. Questo è ciò che fa la JVM quando si verifica un'eccezione non rilevata: interrompe l'esecuzione del programma e stampa uno stack trace dopo aver eseguito il codice del blocco finale, se presente.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {

         myEx.printStackTrace();
       }

       System.out.println("This is the end of the program...");
   }
}

La gestione dell'eccezione in questo caso si riduce alla stampa dello stack di traccia degli errori sulla console utilizzando il metodo printStackTrace() definito nella classe Exception . Tuttavia, il programma è terminato correttamente.

Finalmente! Dopo la cattura

Nell'esempio e nelle definizioni delle parole chiave per la gestione delle eccezioni abbiamo menzionato il last block. È facoltativo, ma se presente verrà eseguito indipendentemente dai risultati del blocco try. Cambiamo il tipo di eccezione in NullPointerException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (NullPointerException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Ecco l'output: A proposito, possiamo specificare il tipo di eccezione da correggere. Eccolo IndexOutOfBoundsException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (IndexOutOfBoundsException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

In questo caso l’output sarà il seguente:

Come funzionano le eccezioni?

Il punto è che tutte queste parole —catch, Throw, Throws possono essere usate solo con java.lang.Throwable o con i suoi discendenti. Ad esempio, puoi fare questo:

public class MyClass {
    public static void main(String[] args) {
        try {
        } catch (Throwable thr) {
}
    }
}

Tuttavia, non puoi farlo in questo modo:

public class MyClass {
public static void main(String[] args) {
        try {
        } catch (String thr) {
}
    }
}