Java 在所有行完成执行后处理异常

我需要methodC2也被执行，即使methodC1（）存在异常。这里我只添加了两个方法，即methodC1（）和methodC2（）。假设有很多方法。在这种情况下，解决方案也应该能够适用

    abstract class A {
        abstract String methodC1() throws ExceptionE;
        abstract String methodC2() throws ExceptionE;

        protected String methodA() throws ExceptionE2 {
            try {
                methodC1();
                methodC2();
            } catch (ExceptionE e) {
                 throw new ExceptionE2();
            }
        }
    }

    class C extends A {
        String methodC1() throws ExceptionE {
            // do something
        }

        String methodC2() throws ExceptionE {
             // do something
        }
    }

---

通常，您不希望从同一方法的异常中恢复

如果您确实需要这样做，您可以将您的“许多”方法打包到其他方法（如果可以的话），以便它们可以共享业务逻辑和异常处理。 例如，如果上述操作失败，则可能不应运行某个方法

您还可以让每个方法都有自己的try-catch，这样它就可以继续执行

---

或者，您可以创建一个执行列表，以便在for循环中执行它们。

不要使用

抛出ExceptionOne

，而是在methodC1和methodc2上使用try-catch块

abstract class A {
    abstract String methodC1 ();
    abstract String methodC2 ();

    protected String methodA (){
        methodC1();
        methodC2();
    }
}

class C extends A {
    String methodC1 () {
       try{
           //code
       } catch (ExceptionE e) {
           //handle exception
       }
    }

    String methodC2 () {
       try{
           //code
       } catch (ExceptionE e) {
            //handle exception
       }
    }
}

这里有一个方法：

protected String methodA() throws ExceptionE2 {
try {
    methodC1();
} catch (ExceptionE e) {
    throw new ExceptionE2();      // HERE
} finally {
    try {
        methodC2();
    } catch (ExceptionE e) {
        throw new ExceptionE2();  // THERE
    }
}

如果

methodC1

和

methodC2

都抛出异常，则从

methodA

传播的

ExceptionE2

就是在

finally

块中抛出的异常；i、 e.

//那里

第一个（抛出的

//这里

）被“吃掉”

还有其他处理此需求的方法，但此方法最简单，不需要更改

methodC1

和

methodC2

的签名

---

如果您需要传播一个对两个

exceptionne

异常的错误信息进行编码的异常，那么您需要重新设计

ExceptionE2

，以便它可以包装多个异常。（在Java…或我所知道的任何其他编程语言中，不可能同时传播两个异常。）

最终结果可能如下所示：

protected String methodA() throws ExceptionE2 {
    List<ExceptionE> exceptions = new ArrayList<>();
    try {
        methodC1();
    } catch (ExceptionE e) {
        exceptions.add(e);
    }
    try {
        methodC2();
    } catch (ExceptionE e) {
        exceptions.add(e);
    }
    if (!exceptions.isEmpty()) {
        throw new ExceptionE2(exceptions);
    }
}

protectedstringmethoda（）抛出异常2{
列表异常=新建ArrayList（）；
试一试{
方法1（）；
}捕获（e除外）{
例外情况。添加（e）；
}
试一试{
方法2（）；
}捕获（e除外）{
例外情况。添加（e）；
}
如果（！exceptions.isEmpty（））{
抛出新异常2（异常）；
}
}

在try-catch中添加Finally块应该可以解决您的问题。无论catch块中的操作结果如何，都将调用Finally

try{
    methodC1();
}
catch(ExceptionE e){
    throw new ExceptionE2();
}
finally{
    methodC2();
}

---

如果

methodC2

抛出的异常与

methodC1

抛出的异常不同怎么办？将其放入finally块中。在每个方法的实现中使用try-catch，并仅在那里处理它，或者在调用该方法时对每个方法使用try-catch