try - La palabra clave throws para excepciones en Java

todas las excepciones en java

Question

cuando haces esto:

public class Blah {

    public void doBlah() throws BlahException {

    }

}

¿Qué significa agregar los 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 BlahException utilizando BlahException ?

Answer 1

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

¿No es así?

Answer 2

Le dice a los clientes de su clase que el método DoBlah puede lanzar una excepción BlahException o cualquier otra excepción que la amplíe .

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 3

No. la cláusula throws BlahException dice al compilador que su función podría arrojar una BlahException y que la llamante 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á, ya que puede emitir una excepción de tipo Exception , y la excepción no ha sido capturada ni declarada para ser lanzada.

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

    }
}

Básicamente, le está diciendo al compilador que esta función podría arrojar una excepción que no se maneja dentro de la función misma. Estos tipos de excepciones son todas subclases de java.lang.Exception y se llaman excepciones comprobadas . 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 subclases de java.lang.RuntimeException y estas 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 deben indicarse allí.

Para una discusión de las excepciones controladas frente a las no verificadas, consulte http://www.javapractices.com/topic/TopicAction.do?Id=129

Answer 4

Su método doBlah() necesita tener algo que pueda throw BlahException o cualquier subclase de BlahException . Esto le dice a la persona que llama de doBlah() que tenga cuidado, por lo general, para ajustar el código en try-catch .