更新

Question

所以我在设计方面遇到了一些情况，并且想知道我是否可以得到一些反馈。

public class Class1 {
    public void eatFish(){}
}

public class Class2 {
    public void eatBacon(){
        // some nasty code here to cause an exception
    }
}

public class Class3 {
    public void eatFruit(){}
}

public InvokeAllClasses() {
    public static void main(String[] args) {
        Class1 c1 = new Class1();
        Class2 c2 = new Class2();
        Class3 c3 = new Class3();

        c1.eatFish();
        c2.eatBacon();
        c3.eatFruit();
    }
}

请参阅InvokeAllClasses中的问题，因为c2.eatBacon(); 炸毁，c3.eatFish()不会被执行。有没有办法继续执行 c3虽然c2爆炸了？

更新

在考虑了更多之后，我想我可以在try...catch块中包装每个调用，但这只是一个混乱。

Answer 1

将try ... catch放入方法定义：

public void eatBacon(){
    try{
        // some nasty code here to cause an exception
    } catch(Exception e){
        //do something
    }
}

当你调用这个方法时，这看起来和看起来一样糟糕。如果您知道代码中的确切位置可能会发生异常，那么只能包围这些语句。

Answer 2

你可以在方法本身中处理异常，这样它们就不会被抛回到调用方法中，但除了try / catch / finally块之外，没有很好的做法可以忽略异常。

Answer 3

为什么不抓住异常并继续前进？老实说，我不认为它会很混乱。

Answer 4

让你的方法抛出异常。

public InvokeAllClasses() throws Exception {
public static void main(String[] args) {
    Class1 c1 = new Class1();
    Class2 c2 = new Class2();
    Class3 c3 = new Class3();

    try{
        c1.eatFish();
    }catch(Exception e){System.out.println("Oh noes! There was something wrong!!!")}
    finally{
        c2.eatBacon();
        c3.eatFruit();  
    }

}

如你所见。＆＃34;终于＆＃34;无论try中的语句是失败还是抛出异常，语句都会强制执行代码。

Answer 5

您可以采取两种方法。第一种选择是完全忽略异常。

try {
  c1.eatFish();
} catch(Exception e) {//Ignore}
try {
  c2.eatBacon();
} catch(Exception e) {//Ignore}
try {
  c3.eatFruit();
} catch(Exception e) {//Ignore}

如果您希望最后抛出异常，可以将结果放入变量中，然后将throw放在最后或使用finally子句。

try {
  c1.eatFish();
finally {
  try {
     c2.eatBacon();
  } finally {
     c3.eatFruit();
  }
}

如果您正在寻找更具可读性的内容，可以包装方法调用。

   public static void main(String[] args) {
        Class1 c1 = new Class1();
        Class2 c2 = new Class2();
        Class3 c3 = new Class3();

        callEatFishIgnoringException(c1);
        callEatBaconIgnoringException(c2);
        callEatFruitIgnoringException(c3);
    }

    private static void callEatFishIgnoringException(Class1 c1) {
      try {c1.eatFish()} catch (Exception e) {//Ignore}
    } 

    private static void callEatBaconIgnoringException(Class2 c2) {
      try {c2.eatBacon()} catch (Exception e) {//Ignore}
    } 

    private static void callEatFruitIgnoringException(Class3 c3) {
      try {c3.eatFruit()} catch (Exception e) {//Ignore}
    }

Answer 6

除非您确定永远不必处理这些方法引发的任何异常，否则最好避免在源头吞下所有这些异常。

我编写Java代码已经有一段时间了，我无法尝试编译它，但我们的想法是创建一个负责执行任务并吞下任何异常的对象。

看起来像：

public class SilentExecutor {
    List<Runnable> tasks;

    public SilentExecutor(List<Runnable) tasks) {
        this.tasks = tasks == null? new List<Runnable>() : tasks;
    }

    public void execute() {
        for (Runnable task : this.tasks) silentlyExecute(task);
    }

    private void silentlyExecute(Runnable task) {
        try { task.run(); }
        catch (Exception e) {}
    }
}

然后你的代码可能是这样的：

new SilentExecutor(Arrays.asList(
    () -> { c1.eatFish(); },
    () -> { c2.eatBacon(); },
    () - > { c3.eatFruit(); }
)).execute();

抛出异常后执行代码

更新

6 个答案: