异常处理;试着抓

Question

这是我的代码：

class FinallyDemo {
    static void myMethod(int n) throws Exception{
        try {
            switch(n) {
                case 1: 
                    System.out.println("1st case");
                    return;
                case 3: 
                    System.out.println("3rd case");
                    throw new RuntimeException("3!");
                case 4: 
                    System.out.println("4th case");
                    throw new Exception("4!");
                case 2: 
                    System.out.println("2nd case");
            }
        catch (RuntimeException e) {
            System.out.print("RuntimeException: ");
            System.out.println(e.getMessage());
        } finally {
            System.out.println("try-block entered.");
        }
    }

    public static void main(String args[]){
        for (int i=1; i<=4; i++) {
            try {
                FinallyDemo.myMethod(i);
            } catch (Exception e){
                System.out.print("Exception caught: ");
                System.out.println(e.getMessage());
            }
            System.out.println();
        }
    }
}

现在，它不是这样工作的吗：

如果我在方法本身中有一个 try 和 catch 块，那么我不需要写

method_name(int n) throws Exception?

抛出异常的方法中的try-catch块是否阻止在抛出异常的方法中写入“抛出异常”？

Answer 1

在您的示例中，案例 4 引发了异常，而在 catch 中您只是在捕获 RuntimeException。由于没有异常捕获，因此您的方法需要声明它抛出异常。 如果要为异常添加捕获，则不需要抛出异常。这将起作用。

static void myMethod(int n) {
    try {
        switch (n) {
            case 1:
                System.out.println("1st case");
                return;
            case 3:
                System.out.println("3rd case");
                throw new RuntimeException("3!");
            case 4:
                System.out.println("4th case");
                throw new Exception("4!");
            case 2:
                System.out.println("2nd case");
        }
    } catch (RuntimeException e) {
        System.out.print("RuntimeException: ");
        System.out.println(e.getMessage());
    } catch (Exception e) {
        System.out.print("Exception: ");
        System.out.println(e.getMessage());
    } 
    finally {
        System.out.println("try-block entered.");
    }
}

Answer 2

当且仅当抛出的异常类型被捕获（或者如果它扩展 RuntimeException 时，您才需要 throws 子句。在您的情况下，您使用语句 throw new Exception("4!"); 抛出 Exception ，但你只能捕捉到 RuntimeException 类型。

如果您为Exception 添加一个catch 块，那么您将不再需要throws 子句。例如：

static void myMethod(int n) throws Exception{
    try {
        switch(n) {
        case 1: 
            System.out.println("1st case");
            return;
        case 3: 
            System.out.println("3rd case");
            throw new RuntimeException("3!");
        case 4: 
            System.out.println("4th case");
            throw new Exception("4!");
        case 2: 
            System.out.println("2nd case");
        }
    } catch (RuntimeException e) {
        System.out.print("RuntimeException: ");
        System.out.println(e.getMessage());
    } catch(Exception e) {
        System.out.print("Exception: ");
        System.out.println(e.getMessage());
    } finally {
        System.out.println("try-block entered.");
    }
}

Answer 3

是的，前提是您要捕获该方法可能引发的所有异常类型。

在您的代码中，您抛出了一个 Exception，但没有为其提供 catch 块（您只是在捕获 RuntimeException），因此您必须将您的方法声明为 throwing Exception

你需要：

 ...
 catch (RuntimeException e) {
     System.out.print("RuntimeException: ");
     System.out.println(e.getMessage());
 } catch (Exception e) {
     System.out.print("Exception: ");
     System.out.println(e.getMessage());
 } finally {
 ...

Answer 4

抛出异常的方法中的try-catch块是否阻止在抛出异常的方法中写入“抛出异常”？

不，你总是可以声明抛出异常，即使你不这样做。

除其他外，这对于允许子类抛出它们很有用（因为不允许它们添加额外的抛出子句）。它还允许您稍后更改实现而不更改异常接口。

Answer 5

目前有两种例外情况

1. 异常的子类。
2. RuntimeException 的子类

Exception 的子类称为已检查异常，编译器确保这些子类在 try/catch 块中或通过方法上的修饰符 throws Exception（或子类）进行管理。

RuntimeException 的子类被称为未经检查的异常，编译不需要任何机制来管理它。

现在，如果您在方法上使用修饰符 throws Exception（或子类），编译器将要求您使用 try/catch 对其进行管理。

Answer 6

由于您在 switch 中同时抛出 RuntimeException 和 Exception，因此您要么需要同时捕获两者，要么方法需要抛出 Exception 以便可以在调用 myMethod 的方法中处理它

同时使用：

catch (RuntimeException e) {
        System.out.print("RuntimeException: ");
        System.out.println(e.getMessage());
}catch (Exception e) {
        System.out.print("Exception: ");
        System.out.println(e.getMessage());
}

确保Exception 的捕获始终是最后一个，否则它也会捕获RuntimeException，因为它扩展了Exception

Answer 7

您正在以两种方式处理异常。首先，如果您在声明方法时直接调用 Exception 类

method_name(int n) throws Exception

这意味着无论方法中发生什么类型的异常，它总是能够捕获它，例如，如果在方法内发生算术异常或 NullPointerException 或 ArrayIndexOutOfBoundsException，您的上述声明将能够抓住每一个。因此，将 try catch 块放置在该方法中并没有实际目的，因为即使 RunTimeException 也是异常类层次结构的一部分。 因此，如果我正确理解了您的问题，程序将执行然后从 catch 块中捕获异常，如果失败，它将从方法声明中捕获它。 希望它能回答您的问题。