É possível ignorar uma exceção?

Em Java, é possível fazer um método que tenha uma instrução throws para não ser verificada.

Por exemplo:

 public class TestClass { public static void throwAnException() throws Exception { throw new Exception(); } public static void makeNullPointer() { Object o = null; o.equals(0);//NullPointerException } public static void exceptionTest() { makeNullPointer(); //The compiler allows me not to check this throwAnException(); //I'm forced to handle the exception, but I don't want to } } 

Você pode tentar e não fazer nada sobre isso:

 public static void exceptionTest() { makeNullPointer(); //The compiler allows me not to check this try { throwAnException(); //I'm forced to handle the exception, but I don't want to } catch (Exception e) { /* do nothing */ } } 

Tenha em mente, na vida real isso é extremamente imprudente . Isso pode esconder um erro e mantê-lo procurando por cães uma semana inteira, enquanto o problema era realmente um gato (ch). (Vamos lá, coloque pelo menos um System.err.println() lá – Logging é a melhor prática aqui, como sugerido por @BaileyS.)

Exceções não verificadas em Java estendem a class RuntimeException . Jogá-los não exigirá uma catch de seus clientes:

 // notice there's no "throws RuntimeException" at the signature of this method public static void someMethodThatThrowsRuntimeException() /* no need for throws here */ { throw new RuntimeException(); } 

As classs que estendem o RuntimeException também não exigem uma declaração de throws .

E uma palavra da Oracle sobre isso:

Aqui está a linha de base: Se um cliente puder se recuperar de uma exceção, faça uma exceção verificada. Se um cliente não puder fazer nada para recuperar-se da exceção, torne-a uma exceção não verificada.

Existem 3 coisas que você pode fazer:

  • Lançar um RuntimeException (ou algo que estenda um RuntimeException , como NullPointerException , IllegalArgumentException , …), você não tem que pegá-los como são exceções não verificadas.

  • Pegue a exceção e não faça nada (não recomendado):

     public static void exceptionTest() { makeNullPointer(); //The compiler allows me not to check this try { throwAnException(); //I'm forced to handle the exception, but I don't want to } catch (Exception e) { // Do nothing } } 
  • Altere a declaração exceptionTest () para dizer que ela lança uma Exception e deixe o método chamá-la capturar a Exception e fazer o que for apropriado:

     public static void exceptionTest() throws Exception { makeNullPointer(); //The compiler allows me not to check this throwAnException(); //I'm no more forced to handle the exception } 

Em Java, há dois tipos de exceções , exceções verificadas e exceções não verificadas.

  • Exceção é uma exceção verificada, deve ser capturada ou lançada.
  • NullPointerException é um RuntimeException , (o compilador não obriga a ser declarado no throws claus) você pode ignorá-lo, mas ainda pode ocorrer no Runtime , e seu aplicativo irá travar.

Da documentação de exceção :

A class Exception e quaisquer subclasss que não sejam também subclasss de RuntimeException são exceções verificadas. Exceções verificadas precisam ser declaradas em um método ou na cláusula throws do construtor se elas puderem ser lançadas pela execução do método ou construtor e propagadas fora do limite do método ou do construtor.

Da documentação do RuntimeException :

RuntimeException é a superclass dessas exceções que podem ser lançadas durante a operação normal da Java Virtual Machine.

RuntimeException e suas subclasss são exceções não verificadas. Exceções não verificadas não precisam ser declaradas em um método ou na cláusula throws do construtor se elas puderem ser lançadas pela execução do método ou construtor e propagadas fora do limite do método ou do construtor.

Você pode usar uma brecha no Java Compiler. Adicione o seguinte código:

 public RuntimeException hideThrow(Throwable e) { if (e == null) throw new NullPointerException("e"); this.hideThrow0(e); return null; } @SuppressWarnings("unchecked") private  void hideThrow0(Throwable e) throws GenericThrowable { throw (GenericThrowable) e; } 

Você pode pegar a exceção e invocar o hideThrow com a exceção de lançá-lo sem que o compilador perceba. Isso funciona devido ao tipo de apagamento. Em tempo de compilation, GenericThrowable representa RuntimeException porque é isso que estamos passando. Em tempo de execução, o GenericThrowable representa Throwable porque esse é o tipo básico na especificação de parâmetro de tipo.

Não, isso gera um erro no compilador. Sendo uma exceção verificada, você deve pegá-lo ou propagá-lo, declarando o seu método como potencialmente jogando-o. Verifique isso e isso .

Lance uma RuntimeException ou uma exceção derivada de RuntimeException . Então o compilador não vai forçá-lo a pegá-lo.

As outras respostas estão corretas, pois dizem corretamente o que você deve fazer, mas na verdade é possível lançar uma exceção verificada não declarada. Existem algumas maneiras pelas quais isso pode ser feito; o mais simples é:

 public void methodThatSecretlyThrowsAnException() { Thread.currentThread().stop(new Exception()); } 

ou se seu objective é envolver um método existente que declara sua exceção

 public void methodThatSecretlyThrowsAnException() { try { methodThatAdmitsItThrowsAnException(); } catch(final Exception e) { Thread.currentThread().stop(e); } } 

(Escusado será dizer que você nunca deve fazer isso.)

Apenas pegue uma exceção e não faça nada com ela, deixe-a como está e capture a exceção genérica no caso de você não estar ciente da exceção específica

 try{ //Your logic goes here } catch(Exception e)//Exception is generic { //do nothing } 

Como eu sei, é impossível no caso. Única exceção não verificada, o compilador pode pular para verificar. como RuntimeException.

Não é aconselhável evitar uma exceção com um bloco catch vazio, mesmo que você tenha certeza absoluta de que não irá falhar sob nenhuma circunstância. Às vezes, não estamos cientes do fator humano.

Se você tiver certeza de que é muito improvável que uma exceção ocorra (se não impossível), crie sua própria Exceção e coloque a exceção inesperada nela.

Por exemplo:

 private class UnlikelyException extends RuntimeException { public UnlikelyException (Exception e){ super (e); } } 

Em seguida, envolva seu código com um bloco try-catch e lance sua exceção, que você não precisa capturar

 try { // Your code } catch (Exception e) { throw new UnlikelyException(e); }