La lanza de palabras clave de excepciones en Java

Question

cuando se hace esto:

public class Blah { 

    public void doBlah() throws BlahException { 

    } 

} 

¿Qué añadiendo el throws BlahException realmente?

¿Básicamente agrupa cualquier excepción a esa? es decir, si hay una excepción, sin importar de qué se trate, siempre se lanzará usando BlahException?

Answer 1

Indica a los clientes de su clase que el método DoBlah puede arrojar BlahException o cualquier otra excepción que lo extienda.

Si se trata de una excepción comprobada, el compilador requerirá que envuelva las llamadas a este método en un bloque try/catch. Si no está marcado, pueden optar por no detectar la excepción, pero tienen que ser conscientes de que si no lo hacen, se disparará más arriba en la pila de llamadas.

No dice nada sobre excepciones no verificadas como NullPointException o errores. Esos siempre pueden ser lanzados también. No son necesarios en la cláusula de lanzamientos.

Este código muestra cómo 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); 
    } 
} 

Answer 2

No. elLa cláusulale dice al compilador que su función podría arrojar una BlahException y que la persona que llama debería capturarla. Por ejemplo:

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 no compilará, porque puede lanzar una excepción de tipo Exception, y la excepción no ha sido capturado ni ha declarado a ser lanzado.

Sin embargo, el siguiente código compilará bien.

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

    } 
} 

En esencia, le está diciendo al compilador que esta función podría lanzar una excepción que no se maneja dentro de la propia función. Estos tipos de excepciones son todas las subclases de java.lang.Exception y se llaman marcó excepciones. Otras excepciones que indican una falla catastrófica causada por errores en el programa en sí, en lugar de una condición como la entrada mal formada son las subclases de java.lang.RuntimeException y se llaman excepciones sin marcar. En resumen, las excepciones sin marcar se pueden lanzar sin una cláusula throws en la firma del método, mientras que las excepciones marcadas se deben indicar allí.

Para una discusión de controladas vs excepciones sin marcar, ver http://www.javapractices.com/topic/TopicAction.do?Id=129

Answer 3

Su método doBlah() necesidad de tener algo que puede throwBlahException o cualquier subclase de BlahException.Esto le dice a la persona que llama de doBlah() que tenga cuidado generalmente para ajustar el código en try-catch.

Answer 4

La idea es que sin la palabra clave throws, la excepción planteada por el método no se puede manejar fuera del método.

¿No es así?