A palavra-chave throws para exceções em Java

quando você faz isso:

public class Blah { public void doBlah() throws BlahException { } } 

O que adicionar os throws BlahException realmente faz?

Será basicamente agrupar qualquer exceção a essa? isto é, se houver uma exceção, não importa o que seja, sempre será lançada usando BlahException ?

Ele informa aos clientes da sua class que o método DoBlah pode lançar uma BlahException ou qualquer outra exceção que o estenda .

Se for uma exceção verificada, o compilador exigirá que eles encapsulem chamadas para esse método em um bloco try / catch. Se estiver desmarcado, eles podem optar por não capturar a exceção, mas precisam estar cientes de que, se não o fizerem, ele será borbulhado na pilha de chamadas.

Ele não diz nada sobre exceções não verificadas, como NullPointException ou erros. Aqueles podem sempre ser jogados também. Eles não são necessários na cláusula de lançamentos.

Este código mostra como funciona:

ExceptionDemo.java:

 package exceptions; public class ExceptionDemo { public static void main(String[] args) { ExceptionDemo demo = new ExceptionDemo(); try { // Removing the try/catch will result in a compilation error demo.doChecked(); } catch (CheckedException e) { e.printStackTrace(); } // Note: Not inside a try/catch, in spite of the throws clause demo.doUnchecked(); } public void doChecked() throws CheckedException { System.out.println("doing something that may throw a checked exception"); } // Note: "throws" clause is unnecessary for an unchecked exception public void doUnchecked() throws UncheckedException { System.out.println("doing something that may throw an unchecked exception"); } } 

CheckedException.java:

 package exceptions; public class CheckedException extends Exception { public CheckedException() { super(); } public CheckedException(String message) { super(message); } public CheckedException(String message, Throwable cause) { super(message, cause); } public CheckedException(Throwable cause) { super(cause); } } 

UncheckedException.java:

 package exceptions; public class UncheckedException extends RuntimeException { public UncheckedException() { super(); } public UncheckedException(String message) { super(message); } public UncheckedException(String message, Throwable cause) { super(message, cause); } public UncheckedException(Throwable cause) { super(cause); } } 

Não throws BlahException cláusula throws BlahException diz ao compilador que sua function pode lançar uma BlahException e que isso deve ser capturado pelo chamador. Por exemplo:

 class ExceptionThrower { void someFunction() { for(int i =0; i<10;i++) if(i==4) throw new Exception(); } public static void main(String args[]) { new ExceptionThrower().someFunction(); } } 

Este programa não irá compilar, porque pode lançar uma exceção do tipo Exception , e a exceção não foi capturada nem declarada para ser lançada.

No entanto, o código a seguir será compilado bem.

 class ExceptionThrower { void someFunction() throws Exception { for(int i =0; i<10;i++) if(i==4) throw new Exception(); } public static void main(String args[]) { try { new ExceptionThrower().someFunction(); } catch(Exception e) { e.printStackTrace(); } } } 

Essencialmente, você está dizendo ao compilador que esta function pode lançar uma exceção que não é tratada dentro da própria function. Esses tipos de exceções são todas subclasss de java.lang.Exception e são chamadas de exceções verificadas . Outras exceções que indicam uma falha catastrófica causada por erros no próprio programa, em vez de uma condição como input malformada, são subclasss de java.lang.RuntimeException e são chamadas de exceções não verificadas . Em resumo, exceções não verificadas podem ser lançadas sem uma cláusula throws na assinatura do método, enquanto quaisquer exceções verificadas devem ser indicadas lá.

Para uma discussão de exceções verificadas vs. não verificadas, consulte http://www.javapractices.com/topic/TopicAction.do?Id=129

A idéia é que, sem throws palavra-chave, a exceção gerada pelo método não pode ser tratada fora do método.

Não é assim?

Seu método doBlah() precisa ter algo que possa throw BlahException ou qualquer subclass de BlahException . Isso diz ao chamador do doBlah() para ter cuidado, geralmente, para quebrar o código no try-catch .