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. 

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:   
 
 
 Utilizzando try catch  
 
 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    
 Java   
   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    
 Java   
   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 con   throws   
 Java   
   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.'  );      }      }   }   
    
  Produzione   
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.  
 
 Differenza tra lancio e lancio  
 
 Le principali differenze tra lancio e lancio in Java sono le seguenti:  
 
 
 
 
 
 gettare  
 
 
 
 lancia  
 
 
 
 
 
 
 
 Viene utilizzato per lanciare esplicitamente un'eccezione.  
 
 
 
 Viene utilizzato per dichiarare che un metodo potrebbe generare una o più eccezioni.  
 
 
 
 
 
 Viene utilizzato all'interno di un metodo o di un blocco di codice.  
 
 
 
 Viene utilizzato nella firma del metodo.  
 
 
 
 
 
 Può generare eccezioni sia controllate che non controllate.  
 
 
 
 Viene utilizzato solo per le eccezioni verificate. Le eccezioni non controllate non richiedono     lancia    
 
 
 
 
 
 Il metodo o il blocco genera l'eccezione.  
 
 
 
 Il chiamante del metodo è responsabile della gestione dell'eccezione.  
 
 
 
 
 
 Interrompe immediatamente il flusso di esecuzione corrente.  
 
 
 
 Forza il chiamante a gestire le eccezioni dichiarate.  
 
 
 
 
 
 lancia una nuova ArithmeticException('Errore');  
 
 
 
 public void myMethod() lancia IOException {}