异常处理;试着赶上

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

在您的示例中，case 4抛出了一个异常，而在catch中您只是捕获了RuntimeException。因为没有Exception的catch，所以你的方法需要声明它会抛出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)，因此你必须声明你的方法为抛出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的子类被称为未检查异常，编译不需要任何机制来管理它。

现在，如果你在一个方法上使用修饰符抛出异常(或子类)，编译器将要求你用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也是Exception类层次结构的一部分。因此，如果我正确理解了你的问题，程序将执行，然后从catch块捕获异常，如果失败，它将从方法声明中捕获异常。