异常处理; 试着抓

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 and catch块，那么我不需要写

method_name(int n) throws Exception ？

引发异常的方法中的try-catch块是否可以防止在引发异常的方法中写入“引发异常”？

Answer 1

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

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块是否可以防止在引发异常的方法中写入“引发异常”？

不，您始终可以声明引发异常，即使您不这样做也是如此。

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

Answer 5

现在是两种例外

1. Exception的子类。
2. RuntimeException子句

Exception的子类被称为检查异常，编译器确保通过try / catch块或通过修饰符在方法上抛出Exception （或子类）来对它们进行管理。

RuntimeException的子类被称为未经检查的异常，并且编译不需要任何机制来对其进行管理。

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

Answer 6

由于在开关中同时抛出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也是Exception Class层次结构的一部分。 因此，如果我正确理解了您的问题，程序将执行，然后从catch块中捕获异常，否则，它将从方法声明中捕获该异常。 希望它能回答您的查询。