The throws keyword for exceptions in Java

when you do this:

public class Blah {

    public void doBlah() throws BlahException {

    }

}

What does adding the throws BlahException really do?

Does it basically group any exception to that one? i.e. if there is an exception, no matter what it is, will always be thrown using BlahException?

Solution 1:

It tells the clients of your class that the DoBlah method can throw a BlahException or any other exception that extends it.

If it's a checked exception, the compiler will require that they wrap calls to this method in a try/catch block. If it's unchecked, they can choose to not catch the exception, but they have to be aware that if they don't it'll be bubbled further up the call stack.

It doesn't say anything about unchecked exceptions like NullPointException or errors. Those can always be thrown as well. They aren't required in the throws clause.

This code shows how it works:

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

Solution 2:

No. the throws BlahException clause tells the compiler that your function might throw a BlahException and that this should be caught by the caller. For example:

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

This program will not compile, because it can throw an exception of type Exception, and the exception has neither been caught nor declared to be thrown.

However, the following code will compile fine.

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

    }
}

Essentially, you are telling the compiler that this function might throw an Exception that is not handled inside the function itself. These types of exceptions are all subclasses of java.lang.Exception and are called checked exceptions. Other exceptions that indicate a catastrophic failure caused by bugs in the program itself, rather than by a condition such as malformed input are subclasses of java.lang.RuntimeException and these are called unchecked exceptions. In short, unchecked exceptions can be thrown without a throws clause in the method signature, while any checked exceptions must be indicated there.

For a discussion of checked vs. unchecked exceptions see http://www.javapractices.com/topic/TopicAction.do?Id=129

Solution 3:

The whole idea is that without throws keyword, the exception raised by the method cannot be handled outside the method.

Isn't it so?