Em Java, o tratamento de exceções é um dos meios eficazes de lidar com erros de tempo de execução para que o fluxo regular do aplicativo possa ser preservado. Ele lida com erros de tempo de execução, como NullPointerException ArrayIndexOutOfBoundsException etc. Para lidar com esses erros de maneira eficaz, o Java fornece duas palavras-chave throw e throws.

Lançamento de Java

A palavra-chave throw em Java é usada para lançar explicitamente uma exceção de um método ou qualquer bloco de código. Podemos lançar exceções verificadas ou não verificadas. A palavra-chave throw é usada principalmente para lançar exceções personalizadas. 

Sintaxe:

lançar Exemplo

Onde instância é um objeto do tipo Throwable (ou suas subclasses, como Exception).

Exemplo:

lançar new ArithmeticException('/ por zero');

Mas esta exceção, ou seja, a instância deve ser do tipo Arremessável ou uma subclasse de Arremessável . 

O fluxo de execução do programa para imediatamente após a instrução throw ser executada e o anexo mais próximo tentar bloco é verificado para ver se ele tem um pegar instrução que corresponde ao tipo de exceção. Se encontrar uma correspondência controlada, será transferido para essa instrução, caso contrário, o próximo anexo tentar bloco é verificado e assim por diante. Se não houver correspondência pegar for encontrado, o manipulador de exceção padrão interromperá o programa. 

Exemplo: Este exemplo demonstra onde uma exceção é lançada, capturada e lançada novamente dentro de um método.

   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.  

Explicação: O exemplo acima demonstra o uso da palavra-chave throw para lançar explicitamente uma NullPointerException. A exceção é capturada dentro do diversão() método e relançado onde é capturado no método main().

Exemplo: Este exemplo demonstra uma exceção aritmética.

   // 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  );      }      }   }   

Saída:

 Hangup (SIGHUP)   
 Exception in thread 'main' java.lang.ArithmeticException: Cannot divide by zero   
  at Geeks.main(Geeks.java:9)  
    Explicação:    O exemplo acima demonstra uma exceção usando throw onde uma ArithmeticException é explicitamente lançada devido à divisão por zero.  
 
    Java lança    
 
    lança    é uma palavra-chave em Java usada na assinatura de um método para indicar que esse método pode lançar uma das exceções de tipo listadas. O chamador desses métodos deve tratar a exceção usando um bloco try-catch.   
 
    Sintaxe:    
 
 
 digite nome_método (parâmetros) lança lista_exceção  
 
 
 onde lista_de_exceções é uma lista separada por vírgulas de todas as exceções que um método pode lançar.  
 
 Em um programa, se houver uma chance de gerar uma exceção, o compilador sempre nos avisa sobre isso e devemos lidar com a exceção verificada. Caso contrário, obteremos um erro em tempo de compilação dizendo que a exceção não relatada XXX deve ser capturada ou declarada para ser lançada. Para evitar esse erro em tempo de compilação, podemos tratar a exceção de duas maneiras:   
 
 
 Usando try catch  
 
 Ao usar o     lança    palavra-chave  
 
 
 Podemos usar a palavra-chave throws para delegar a responsabilidade do tratamento de exceções ao chamador (pode ser um método ou JVM), então o método do chamador é responsável por tratar essa exceção.    
 
    Exemplo 1: Exceção não tratada    
 Java   
   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      Thread  .  sleep  (  10000  );      System  .  out  .  println  (  'Hello Geeks'  );      }   }   
   
    Saída:    
 
 error: unreported exception InterruptedException; must be caught or declared to be thrown  
    Explicação:    No programa acima, estamos recebendo um erro de tempo de compilação porque há uma chance de exceção se o thread principal for dormir, outros threads terão a chance de executar o método main() que causará InterruptedException.   
 
    Exemplo 2: Usando        throws         para lidar com exceção    
 Java   
   class   Geeks     {      public     static     void     main  (  String  []     args  )      throws     InterruptedException      {      Thread  .  sleep  (  10000  );      System  .  out  .  println  (  'Hello Geeks'  );      }   }   
   
    Saída:    
 
 Hello Geeks  
    Explicação:    No programa acima, usando a palavra-chave throws, tratamos do     Exceção Interrompida    e obteremos a saída como     Olá Geeks.    
 
    Exemplo 3:    Lançando uma exceção com   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.'  );      }      }   }   
    
  Saída   
Inside fun(). Caught in main.  
 
    Explicação:    O exemplo acima lançando uma IllegalAccessException de um método e manipulando-a no método principal usando um bloco try-catch.  
 
 Diferença entre arremesso e arremesso  
 
 As principais diferenças entre throw e throws em Java são as seguintes:  
 
 
 
 
 
 lançar  
 
 
 
 lança  
 
 
 
 
 
 
 
 É usado para lançar explicitamente uma exceção.  
 
 
 
 É usado para declarar que um método pode lançar uma ou mais exceções.  
 
 
 
 
 
 É usado dentro de um método ou bloco de código.  
 
 
 
 É usado na assinatura do método.  
 
 
 
 
 
 Ele pode lançar exceções verificadas e não verificadas.  
 
 
 
 É usado apenas para exceções verificadas. Exceções não verificadas não exigem     lança    
 
 
 
 
 
 O método ou bloco lança a exceção.  
 
 
 
 O chamador do método é responsável por tratar a exceção.  
 
 
 
 
 
 Interrompe o fluxo atual de execução imediatamente.  
 
 
 
 Força o chamador a lidar com as exceções declaradas.  
 
 
 
 
 
 lançar new ArithmeticException('Erro');  
 
 
 
 public void myMethod() lança IOException {}