在java中处理异常后执行剩余代码？

我可能很傻。但是我接受了采访，有人问我一个问题，关于在得到异常后如何运行剩余的代码

我给出了一些方法：

我们终于可以把代码写进去了

我们可以在catch块中编写代码。（他们不想处理这两种方法。）

我们可以使用throw关键字。但是我试过了，它不起作用

我也试着用这句话来解释他们

我引用了这么多帖子。但我的疑虑仍未消除

例如,

  public static void main(String[] args)
  {
      a(); // getting exception here...
      b(); // This method should executed after handling exception
  } 

---

如果你能就此提出任何建议，这将是非常有帮助的。所以我可以理解。

您需要在where或FINAL子句中执行方法

try {
  a(); // getting exception here...
} catch(Exception e) {
  b(); // This method should executed after handling exception
}

---

您需要在where或finally子句中执行方法

try {
  a(); // getting exception here...
} catch(Exception e) {
  b(); // This method should executed after handling exception
}

如果要执行b（）；只有在抛出异常时，才应该在catch（）{}块上调用它。如果您想执行它，您可以将它放在finally{}或后面（请参见编辑）

• 如果b（）；是对异常的报复，或者您想使用try{}块内初始化的变量，您应该在finally{}上写它，如下所示：

  try{
        a();
       } catch (Exception e){
        e.printStackTrace();
        //what to do if exception was thrown
       } finnaly {
        b();
       }
       //you can also call b(); here instead of inside finnaly
  

• 如果b（）；用于处理异常，然后：

  try{
   a();
  } catch (Exception e){
   e.printStackTrace();
   b();
  }
  

您还可以使该方法抛出A的异常，并在调用A（）的方法中处理它；但是如果你是主要的,你就不应该那样做

编辑：根据要求，提供面试官要求的正确答案示例：

    try{
      a();
    } catch (Exception e){
      e.printStackTrace(); //optional
    }

    b();

如果要执行b（）；只有在抛出异常时，才应该在catch（）{}块上调用它。如果您想执行它，您可以将它放在finally{}或后面（请参见编辑）

• 如果b（）；是对异常的报复，或者您想使用try{}块内初始化的变量，您应该在finally{}上写它，如下所示：

  try{
        a();
       } catch (Exception e){
        e.printStackTrace();
        //what to do if exception was thrown
       } finnaly {
        b();
       }
       //you can also call b(); here instead of inside finnaly
  

• 如果b（）；用于处理异常，然后：

  try{
   a();
  } catch (Exception e){
   e.printStackTrace();
   b();
  }
  

您还可以使该方法抛出A的异常，并在调用A（）的方法中处理它；但是如果你是主要的,你就不应该那样做

编辑：根据要求，提供面试官要求的正确答案示例：

    try{
      a();
    } catch (Exception e){
      e.printStackTrace(); //optional
    }

    b();

---

对我来说，在没有

try catch finally

的情况下，唯一简洁的方法可能是使用

competable future

功能，并将每个功能的执行作为单独的任务分派。 像这样：

@Test
public void tryCatchFinallyWithCompletableFuture() throws Exception
{
    CompletableFuture
        .runAsync(
            () -> a()
        )
        .exceptionally(
            (e) -> { System.out.print(e.getMessage()); return null; }
        )
        .thenRun(
            () -> b()
        )
        .get();
}

static void a() {
    throw new IllegalStateException("a()");
}

static void b() {
    System.out.println("...but we continue after a()");
}

---

不过，我会认真考虑在任何地方使用这种方法，但在一个游乐场项目。此外，您必须记住

a（）

和

b（）

是在多线程上下文中执行的，如果存在共享状态，可能需要对共享状态进行同步。

对我来说，在不使用

try catch finally

的情况下，唯一简洁的方法可能是使用

CompetableFuture

功能，并将每个功能的执行作为单独的任务分派。 像这样：

@Test
public void tryCatchFinallyWithCompletableFuture() throws Exception
{
    CompletableFuture
        .runAsync(
            () -> a()
        )
        .exceptionally(
            (e) -> { System.out.print(e.getMessage()); return null; }
        )
        .thenRun(
            () -> b()
        )
        .get();
}

static void a() {
    throw new IllegalStateException("a()");
}

static void b() {
    System.out.println("...but we continue after a()");
}

---

不过，我会认真考虑在任何地方使用这种方法，但在一个游乐场项目。此外，您必须记住，

a（）

和

b（）

是在多线程上下文中执行的，如果存在共享状态，则可能需要对其进行同步。

如果您发现并处理了异常，您可以在try catch块之后运行

b（）

方法：

try {
  a();
} catch(Exception e) {
  handleMyError(e);
}
b();

---

通过这种方式执行

a（）

方法，如果抛出异常，它将被抛出并隐藏在方法

handleMyError（异常e）

中，然后执行继续

到b（）

，无论是否抛出异常。

如果抛出异常并处理它，您可以运行

b（）

尝试捕捉块后的方法：

try {
  a();
} catch(Exception e) {
  handleMyError(e);
}
b();

---

通过这种方式执行

a（）

方法，如果抛出异常，则在方法

handleMyError（异常e）

中对其进行检查和隐藏，然后继续执行

到b（）

不管异常是否被抛出。

@Stultuske OP说面试官不希望在try-catch或最终可能的副本中处理它，欢迎您在catch块结束后编写代码。您只需在

try-catch

块后执行

b（）

方法即可。但这取决于需求。如果在

catch

中也可以获得异常，并且无论如何都应该执行

b（）

，那么

最后

块是唯一的选项。另外，在面试中，询问特殊要求通常是非常有用的，因为对于一个非特定的问题，你永远不会有一个完全合适的解决方案/答案。我试图解释以上两种方法，我们可以在catch块中编写方法调用，也可以在finally中编写方法调用。但是他们告诉他们不想要它。@Stultuske OP说面试官不希望它在try-catch或最终可能的副本中处理。欢迎您在catch块结束后编写代码。您可以在try-catch块之后执行

b（）

方法。但这取决于需求。如果在

catch

中也可以获得异常，并且无论如何都应该执行

b（）

，那么

最后

块是唯一的选项。另外，在面试中，询问特殊要求通常是非常有用的，因为对于一个非特定的问题，你永远不会有一个完全合适的解决方案/答案。我试图解释以上两种方法，我们可以在catch块中编写方法调用，也可以在finally中编写方法调用。但是他们告诉他们不想要它。不，他没有，因为他不允许使用try-catch不，他没有，因为他不允许使用try-catch不允许try-catch-allowed显然，使这个答案正确的单词是第二句末尾的“或在一切之后”。遗憾的是没有匹配的代码片段@