Java中异常的throws关键字

Question

当你这样做:

public class Blah {

    public void doBlah() throws BlahException {

    }

}

添加throws BlahException真的有什么作用？

它是否基本上将任何异常分组到那个？即如果有异常,无论它是什么,都会被抛出BlahException？

Answer 1

它告诉您的类的客户端DoBlah方法可以抛出BlahException或任何其他扩展它的异常.

如果它是一个已检查的异常,编译器将要求它们在try/catch块中包装对此方法的调用.如果未经检查,他们可以选择不捕获异常,但是他们必须要注意,如果他们不这样做,它将在调用堆栈中进一步冒泡.

它没有说明未经检查的异常,如NullPointException或错误.那些也总是被抛出.throws子句中不需要它们.

此代码显示了它的工作原理:

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

不,该throws BlahException子句告诉编译器你的函数可能抛出一个BlahException,并且这应该被调用者捕获.例如:

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

此程序将无法编译,因为它可以抛出类型Exception的异常,并且异常既没有被捕获也没有声明被抛出.

但是,以下代码将编译正常.

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

    }
}

从本质上讲,您告诉编译器此函数可能会抛出一个未在函数内部处理的异常.这些类型的异常都是子类,java.lang.Exception并称为检查异常.其他异常表明由程序本身的错误引起的灾难性故障,而不是由输入格式错误等条件导致的子类,java.lang.RuntimeException这些异常称为未经检查的异常.简而言之,可以throws在方法签名中没有子句的情况下抛出未经检查的异常,而必须在那里指出任何已检查的异常.

有关已检查与未检查异常的讨论,请参阅http://www.javapractices.com/topic/TopicAction.do?Id=129