In Java la gestione delle eccezioni è uno dei mezzi efficaci per gestire gli errori di runtime in modo da poter preservare il flusso regolare dell'applicazione. Gestisce errori di runtime come NullPointerException ArrayIndexOutOfBoundsException ecc. Per gestire questi errori in modo efficace Java fornisce due parole chiave Throw e Throws.

Lancio di Java

La parola chiave Throw in Java viene utilizzata per generare esplicitamente un'eccezione da un metodo o da qualsiasi blocco di codice. Possiamo lanciare eccezioni controllate o non controllate. La parola chiave Throw viene utilizzata principalmente per generare eccezioni personalizzate. 

Sintassi:

gettare Esempio

Dove istanza è un oggetto di tipo Throwable (o le sue sottoclassi come Exception).

Esempio:

lancia una nuova ArithmeticException('/ by zero');

Ma questa eccezione, ovvero l'istanza, deve essere di tipo Lanciabile o una sottoclasse di Lanciabile . 

Il flusso di esecuzione del programma si interrompe immediatamente dopo l'esecuzione dell'istruzione Throw e dell'inclusione più vicina Tentativo il blocco viene controllato per vedere se ha un file presa istruzione che corrisponde al tipo di eccezione. Se trova una corrispondenza controllata viene trasferita a tale istruzione altrimenti la allegherà successivamente Tentativo il blocco viene controllato e così via. Se non c'è corrispondenza presa viene trovato, il gestore eccezioni predefinito interromperà il programma. 

carattere in lattice

Esempio: Questo esempio dimostra dove viene generata un'eccezione, catturata e lanciata nuovamente all'interno di un metodo.

class Geeks {  static void fun()  {  try {  throw new NullPointerException('demo');  }  catch (NullPointerException e) {  System.out.println('Caught inside fun().');  throw e; // rethrowing the exception  }  }  public static void main(String args[])  {  try {  fun();  }  catch (NullPointerException e) {  System.out.println('Caught in main.');  }  } } 

Caught inside fun(). Caught in main. 

Spiegazione: L'esempio precedente dimostra l'uso della parola chiave Throw per lanciare esplicitamente una NullPointerException. L'eccezione è catturata all'interno del file divertimento() metodo e rilanciato dove viene quindi catturato nel metodo main().

Esempio: Questo esempio dimostra un'eccezione aritmetica.

// Throwing an arithmetic exception class Geeks {  public static void main(String[] args){  int numerator = 1;  int denominator = 0;  if (denominator == 0) {  // Manually throw an ArithmeticException  throw new ArithmeticException('Cannot divide by zero');  } else {  System.out.println(numerator / denominator);  }  } } 

Produzione:

Hangup (SIGHUP)  
Exception in thread 'main' java.lang.ArithmeticException: Cannot divide by zero  
 at Geeks.main(Geeks.java:9)

Spiegazione: L'esempio precedente mostra un'eccezione che utilizza Throw in cui viene lanciata esplicitamente un'ArithmeticException a causa della divisione per zero.

Java lancia

lancia è una parola chiave in Java utilizzata nella firma di un metodo per indicare che questo metodo potrebbe generare una delle eccezioni di tipo elencate. Il chiamante di questi metodi deve gestire l'eccezione utilizzando un blocco try-catch. 

Sintassi:

tipo nome_metodo(parametri) genera lista_eccezioni

dove lista_eccezione è un elenco separato da virgole di tutte le eccezioni che un metodo potrebbe generare.

In un programma se c'è la possibilità di sollevare un'eccezione, il compilatore ci avvisa sempre e dobbiamo gestire l'eccezione controllata. Altrimenti riceveremo un errore in fase di compilazione che dice che l'eccezione non segnalata XXX deve essere catturata o dichiarata per essere lanciata. Per evitare questo errore in fase di compilazione possiamo gestire l'eccezione in due modi: 

1. Utilizzando try catch
2. Utilizzando il lancia parola chiave

Possiamo utilizzare la parola chiave Throws per delegare la responsabilità della gestione delle eccezioni al chiamante (potrebbe essere un metodo o una JVM), quindi il metodo chiamante è responsabile della gestione di tale eccezione.  

Esempio 1: eccezione non gestita

class Geeks {  public static void main(String[] args)  {  Thread.sleep(10000);  System.out.println('Hello Geeks');  } } 

Produzione:

error: unreported exception InterruptedException; must be caught or declared to be thrown

Spiegazione: Nel programma precedente riceviamo un errore in fase di compilazione perché esiste una possibilità di eccezione se il thread principale va in modalità di sospensione, altri thread hanno la possibilità di eseguire il metodo main() che causerà InterruptedException. 

Esempio 2: utilizzo throws per gestire l'eccezione

class Geeks {  public static void main(String[] args)  throws InterruptedException  {  Thread.sleep(10000);  System.out.println('Hello Geeks');  } } 

Produzione:

Hello Geeks

Spiegazione: Nel programma precedente utilizzando la parola chiave Throws abbiamo gestito the InterruptedException e otterremo l'output come Ciao geek.

Esempio 3: Lanciare un'eccezione conthrows

class Geeks {  static void fun() throws IllegalAccessException  {  System.out.println('Inside fun(). ');  throw new IllegalAccessException('demo');  }  public static void main(String args[])  {  try {  fun();  }  catch (IllegalAccessException e) {  System.out.println('Caught in main.');  }  } } 

Inside fun(). Caught in main. 

Spiegazione: L'esempio precedente lancia un'eccezione IllegalAccessException da un metodo e la gestisce nel metodo main utilizzando un blocco try-catch.

linux esegui cmd

Differenza tra lancio e lancio

Le principali differenze tra lancio e lancio in Java sono le seguenti: