Java 处理可恢复和不可恢复的异常_Java

Java 处理可恢复和不可恢复的异常

java

Java 处理可恢复和不可恢复的异常,java,Java,希望我能解释清楚。如果我有一个main方法，其中有很多步骤可以生成不同的异常，有些是致命的，有些不是，那么我是否必须分别捕获“可恢复”的异常？这似乎会导致潜在的大量try/catch块，如下所示： public static void main (String[] args) { try { //... for (int i=0;someArray.length;i++) { try{ System.

希望我能解释清楚。如果我有一个main方法，其中有很多步骤可以生成不同的异常，有些是致命的，有些不是，那么我是否必须分别捕获“可恢复”的异常？这似乎会导致潜在的大量try/catch块，如下所示：

public static void main (String[] args) {
    try {
        //...
        for (int i=0;someArray.length;i++) {
            try{
                System.out.println("I = " + i);
                doSometing(i);
            } catch (RecoverableException e) {
                //recover, continue, whatever
                //log warning
                                    //keep 
            }
        }//end for loop

        try {
            doSomethingElse();
        } catch (AnotherRecoverableException e) {
            //not fatal, keep on chugging
        }

        //...

        //do more stuff that can throw unrecoverable exceptions
    } catch (UnrecoverableException e) {
        System.out.println("I can't handle this, it's too much!");
        e.printStackTrace();
    }
}

有更好的方法吗？

如果使用Java 7，则可以使用管道作为分隔符在catch块中加入异常。这将减少捕捉块的数量。但是您需要通过在catch块中放入适当的代码来决定如何处理它们

在Java 7中，可以执行以下操作：

try
{
...
}
catch(Exception1 | Exception2 | Exception3 e)
{
  //Handle
}
catch(Exception4 | Exception5 | Exception6 e)
{
   //Handle differently
}

如果您使用的是Java7，那么可以使用管道作为分隔符在catch块中加入异常。这将减少捕捉块的数量。但是您需要通过在catch块中放入适当的代码来决定如何处理它们

在Java 7中，可以执行以下操作：

try
{
...
}
catch(Exception1 | Exception2 | Exception3 e)
{
  //Handle
}
catch(Exception4 | Exception5 | Exception6 e)
{
   //Handle differently
}

你可以用，但它仅在线程没有集合时触发。

您可以使用，但是它只有在线程没有集合时才会触发。

对于7以外的java版本，一种更干净的方法是处理被调用方法中的异常。这使代码可读，如下所示：

doSomething(int i){
 //code
try{
 //code
}catch(Exception1 e1){
 //handle
}
catch(Exception2 e2){
//handle
}
}

doSomethingElse(){
 //code
 try{
  }catch(Exception1 e1){
 //handle
  }
   catch(Exception2 e2){
    //handle
    }
  }

 public static void main (String[] args) {
    for (int i=0;someArray.length;i++) {
     doSometing(i);
    }//end for loop

    doSomethingElse();
    }

我不建议使用generic

Exception

捕获一个块中的所有错误。这使得了解特定异常变得困难，并阻止对它们的特定处理。

对于7以外的java版本，一种更干净的方法是在调用的方法中处理异常。这使代码可读，如下所示：

doSomething(int i){
 //code
try{
 //code
}catch(Exception1 e1){
 //handle
}
catch(Exception2 e2){
//handle
}
}

doSomethingElse(){
 //code
 try{
  }catch(Exception1 e1){
 //handle
  }
   catch(Exception2 e2){
    //handle
    }
  }

 public static void main (String[] args) {
    for (int i=0;someArray.length;i++) {
     doSometing(i);
    }//end for loop

    doSomethingElse();
    }

我不建议使用generic

Exception

捕获一个块中的所有错误。这使得了解特定的异常变得困难，并阻止对它们的特定处理。

我的模式是让异常在代表编程错误时传播，并在您能够处理它们时尽可能接近“问题”来处理它们

问题是，许多潜在的编程错误抛出检查过的异常，这非常糟糕（检查过的异常是一种失败的体验，新的语言已经消除了它们）

因此：

处理可立即处理的已检查和未检查异常。

如果您不知道如何处理选中的异常，请将其作为未选中的异常重新显示。

任何像main或线程中的“顶级”循环都应该被“Exception”的try/catch/log包围，以确保出现的任何异常都不会杀死线程（但要大声记录它，因为它代表未知的编程错误！）

无论异常如何，任何应该继续的关键循环都应该在循环构造中具有“Exception”的try/catch/log，以便继续。

捕获异常，不能在如此高的级别上丢弃。Throwable包括您可能永远不想捕获的不可恢复的异常。

如果您确实必须抛出一个您认为希望调用方捕获的异常（尝试避免这种情况——这意味着您将异常用作代码流！），则抛出一个未经检查的异常，但对其进行记录，并让方法“抛出”未经检查的异常（不必对其进行处理，但这将作为附加文档/提示）

作为我不喜欢检查异常的背景，它使代码如下所示：

try { Thread.sleep(1000); } catch(InterruptedException e) {} 试一试{ 睡眠（1000）； }捕获（中断异常e）{}

这可以隐藏一些令人讨厌的程序流相关bug。在这种情况下，它只是意味着您可能有一些线程控制问题，但在其他情况下，它可能意味着您的代码流“神奇地”在方法中间消失，而没有任何指示（因为一个异常是由更高级别的try/catch拾取的）.