Il getta parola chiave per le eccezioni in Java

Question

quando si esegue questa operazione:

public class Blah { 

    public void doBlah() throws BlahException { 

    } 

} 

Cosa aggiungendo il throws BlahException davvero fare?

In pratica raggruppa qualche eccezione a quella? cioè se c'è un'eccezione, non importa quale sia, sarà sempre generata usando BlahException?

Answer 1

Segnala ai client della classe che il metodo DoBlah può lanciare una BlahException o qualsiasi altra eccezione che la estende.

Se è un'eccezione controllata, il compilatore richiederà che eseguano il richiamo di chiamate a questo metodo in un blocco try/catch. Se è deselezionata, possono scegliere di non rilevare l'eccezione, ma devono essere consapevoli del fatto che, se non lo fanno, saranno gorgogliati più in alto nello stack delle chiamate.

Non dice nulla su eccezioni non controllate come NullPointException o errori. Anche quelli possono sempre essere lanciati. Non sono richiesti nella clausola dei lanci.

Questo codice mostra come funziona:

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

Answer 2

No. loLa clausoladice al compilatore che la tua funzione potrebbe lanciare una BlahException e che questo dovrebbe essere catturato dal chiamante. Per esempio:

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

Questo programma non verrà compilato, perché può generare un'eccezione di tipo Exception, e l'eccezione non è stata né catturato né dichiarato di essere gettato.

Tuttavia, il seguente codice verrà compilato correttamente.

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

    } 
} 

In sostanza, si indica al compilatore che questa funzione potrebbe lancerà un'eccezione che non viene gestito all'interno della funzione stessa. Questi tipi di eccezioni sono tutte sottoclassi di java.lang.Exception e sono chiamate eccezioni controllate. Altre eccezioni che indicano un errore catastrofico causato da bug nel programma stesso, piuttosto che da una condizione come input malformato sono sottoclassi di java.lang.RuntimeException e sono chiamate eccezioni non controllate. In breve, le eccezioni non controllate possono essere generate senza una clausola throws nella firma del metodo, mentre le eventuali eccezioni controllate devono essere indicate lì.

Per una discussione controllato vs eccezioni unchecked vedere http://www.javapractices.com/topic/TopicAction.do?Id=129

Answer 3

Il tuo metodo doBlah() necessità di avere qualcosa che possa throwBlahException o qualsiasi sottoclasse di BlahException.Questo dice al chiamante di doBlah() di fare attenzione di solito per avvolgere il codice in try-catch.

Answer 4

L'idea generale è che senza la parola chiave throws, l'eccezione generata dal metodo non può essere gestita al di fuori del metodo.

Non è così?