Quando usare getta in una dichiarazione di metodo Java?

Question

Così ho pensato che avrei avuto una buona conoscenza di base di gestione delle eccezioni in Java, ma mi è stato di recente lettura di un codice che mi ha dato un po 'di confusione e dubbi. Il mio dubbio principale che voglio indirizzo qui è quando dovrebbe un uso persona getta in una dichiarazione di metodo Java come il seguente:

    public void method() throws SomeException
    {
         // method body here
    }

Da leggere alcuni post simili mi sembra di capire che getta viene utilizzato come una sorta di dichiarazione di SomeException potrebbe essere gettato durante l'esecuzione del metodo.

La mia confusione deriva da un codice che si presentava così:

     public void method() throws IOException
     {
          try
          {
               BufferedReader br = new BufferedReader(new FileReader("file.txt"));
          }
          catch(IOException e)
          {
               System.out.println(e.getMessage());
          }
     }

C'è un motivo che si vorrebbe utilizzare un getta in questo esempio? Sembra che se si sta solo facendo base di gestione delle eccezioni di qualcosa come un IOException che si sarebbe semplicemente bisogno del blocco try / catch e il gioco è fatto.

Answer 1

Se si sta recuperando un tipo di eccezione, non c'è bisogno di buttarla, a meno che non si sta per rigenerare esso. Nell'esempio si registra, lo sviluppatore avrebbe dovuto fare uno o l'altro, non entrambi.

In genere, se non si ha intenzione di fare qualcosa con l'eccezione, non si deve prenderlo.

La cosa più pericolosa che si può fare è prendere un'eccezione e non fare nulla con esso.

Una buona discussione di quando è opportuno lanciare eccezioni È qui

Quando un'eccezione?

Answer 2

Hai solo bisogno di includere una clausola throws su un metodo se il metodo genera un'eccezione verificata. Se il metodo genera un'eccezione di runtime, allora non c'è bisogno di farlo.

Vedi qui per un po 'di fondo su controllato vs eccezioni unchecked: http: / /download.oracle.com/javase/tutorial/essential/exceptions/runtime.html

Se il metodo di cattura l'eccezione e si occupa di internamente (come nel tuo secondo esempio), allora non c'è bisogno di includere una clausola throws.

Answer 3

Il codice che avete guardato non è l'ideale. Si debbono:

1. intercettare l'eccezione e gestirlo; nel qual caso il throws è unnecesary.

2. Rimuovere la try/catch; in quale caso l'eccezione viene gestita da un Metodo chiamando.

3. intercettare l'eccezione, forse eseguire alcune azioni e quindi rigenerare l'eccezione (non solo il messaggio)

Answer 4

siete sulla strada giusta, nel senso che ad esempio il throws è superfluo. E 'possibile che sia stato lasciato lì da qualche precedente implementazione -. Forse l'eccezione è stata originariamente lanciata invece catturato nel blocco catch

Answer 5

Nel esempio che ha dato, il metodo non potrà mai lanciare un'IOException, quindi, la dichiarazione è sbagliato (ma valido). La mia ipotesi è che il metodo originale ha gettato l'IOException, ma è stato poi aggiornato per gestire l'eccezione all'interno ma la dichiarazione non è stato modificato.

Answer 6

Il codice che hai postato è sbagliato, dovrebbe generare un'eccezione se si cattura un'eccezione specifica al fine di gestore IOException, ma gettando eccezioni non catched.

Qualcosa di simile:

public void method() throws Exception{
   try{
           BufferedReader br = new BufferedReader(new FileReader("file.txt"));
   }catch(IOException e){
           System.out.println(e.getMessage());
   }
}

o

public void method(){
   try{
           BufferedReader br = new BufferedReader(new FileReader("file.txt"));
   }catch(IOException e){
           System.out.println("Catching IOException");
           System.out.println(e.getMessage());
   }catch(Exception e){
           System.out.println("Catching any other Exceptions like NullPontException, FileNotFoundExceptioon, etc.");
           System.out.println(e.getMessage());
   }

}

Answer 7

Questa non è una risposta, ma un commento, ma non ho potuto scrivere un commento con un codice formattato, ecco il commento.

Diciamo che c'è

public static void main(String[] args) {
  try {
    // do nothing or throw a RuntimeException
    throw new RuntimeException("test");
  } catch (Exception e) {
    System.out.println(e.getMessage());
    throw e;
  }
}

L'uscita è

test
Exception in thread "main" java.lang.RuntimeException: test
    at MyClass.main(MyClass.java:10)

Questo metodo non dichiara alcuna "getta" Eccezioni, ma li getta! Il trucco è che le eccezioni sollevate sono RuntimeExceptions (non controllate) che non sono necessari per essere dichiarati sul metodo. E 'un po' fuorviante per il lettore del metodo, dal momento che tutto ciò che vede è un "tiro e;" affermazione, ma nessuna dichiarazione della lancia un'eccezione

Ora, se abbiamo

public static void main(String[] args) throws Exception {
  try {
    throw new Exception("test");
  } catch (Exception e) {
    System.out.println(e.getMessage());
    throw e;
  }
}

Si deve dichiarare la "tiri" eccezioni nel metodo altrimenti si ottiene un errore di compilazione.