Java 可选异常捕获

是否可以创建一个可选的异常来捕获

换句话说，例外情况可以是：

• 在试抓块中被抓
• 如果不存在try-catch块，则跳过

为了可视化，我有一个

ReportedException

，它只是

RuntimeException

的一个普通子类，希望能够在需要时捕获它：

try
{
    hideWindow();
}
catch (ReportedException ex)
{
    // Window could not be hidden.
    // Exception has already been caught and logged by parseInput(),
    // and now we're going to do something more.

    printAdditionalErrorMessage();
}

注意：我编辑了上面的示例以更好地适合我的问题

如果结果不相关，则跳过捕捉：

hideWindow(); // We don't care if there was an error or not.
openAnotherWindow();

我知道我可以将catch块保留为空，并具有与上面相同的内容，但我经常使用

ReportedException

，这会使我的代码非常不可读

如果这是不可能的（我想是的），你会推荐什么替代方案/走查

另外，示例中使用的方法名称只是foo和bar

---

编辑：我知道我不需要捕捉运行时异常。如果发生异常，我希望忽略它们。

听起来您希望将异常用于流控制，而不是报告真正的异常情况

---

通常不赞成将异常用于流控制。常用的方法是返回一个成功/失败指示作为函数的返回值。

听起来您希望将异常用于流控制，而不是报告真正的异常情况

---

通常不赞成将异常用于流控制。常用的方法是返回成功/失败指示作为函数的返回值。

异常情况应使用异常

根据您的示例，如果未隐藏的窗口是典型事件，则不应引发异常。如果这是您的函数，那么使用返回值来指示它是否成功，而不是引发异常。然后，当您不关心返回值是否成功时，可以安全地忽略返回值

如果您无法控制该方法，那么可以将其包装到另一个方法中，该方法捕获异常并将其转换为返回值。例如

private boolean tryHideWindow() {
    try {
        hideWindow();
    }
    catch (ReportedException ex) {
        return false;
    }
    return true;
}

如果需要异常的一些参数来确定要执行的操作，那么可以返回异常

private static class MyReturnType {
    private final Throwable thrown;
    private final OrigRtnType returnVal;
    public MyReturnType(Throwable thrown) {
        this.thrown = thrown;
        this.returnVal = null;
    }
    public MyReturnType(OrigRtnType returnVal) {
        this.thrown = null;
        this.returnVal = returnVal
    }
    public boolean wasExceptionThrown() {
        return thrown != null;
    }
}

private MyReturnType tryHideWindow() {
    try {
        OrigRtnType returnVal = hideWindow();
    }
    catch (ReportedException ex) {
        return new MyReturnType(ex);
    }
    return new MyReturnType(returnVal);
}

---

这是对你问题的回答，但不一定是个好主意。由于其他人会加倍注释，在程序流中使用异常并不理想。

异常应用于异常情况

根据您的示例，如果未隐藏的窗口是典型事件，则不应引发异常。如果这是您的函数，那么使用返回值来指示它是否成功，而不是引发异常。然后，当您不关心返回值是否成功时，可以安全地忽略返回值

如果您无法控制该方法，那么可以将其包装到另一个方法中，该方法捕获异常并将其转换为返回值。例如

private boolean tryHideWindow() {
    try {
        hideWindow();
    }
    catch (ReportedException ex) {
        return false;
    }
    return true;
}

如果需要异常的一些参数来确定要执行的操作，那么可以返回异常

private static class MyReturnType {
    private final Throwable thrown;
    private final OrigRtnType returnVal;
    public MyReturnType(Throwable thrown) {
        this.thrown = thrown;
        this.returnVal = null;
    }
    public MyReturnType(OrigRtnType returnVal) {
        this.thrown = null;
        this.returnVal = returnVal
    }
    public boolean wasExceptionThrown() {
        return thrown != null;
    }
}

private MyReturnType tryHideWindow() {
    try {
        OrigRtnType returnVal = hideWindow();
    }
    catch (ReportedException ex) {
        return new MyReturnType(ex);
    }
    return new MyReturnType(returnVal);
}

---

这是对你问题的回答，但不一定是个好主意。正如其他人会加倍注释一样，在程序流中使用异常并不理想。

您可以使用以下内容：

try{
    hideWindow();
}catch (ReportedException ex){
    // ingore

}catch (NullPointerException ex){
       killWindow();
}finally  {
    //to do something more.
}

public class IgnorableException {  

     static class DontIgnoreCount  {
         int count;
     }

     // Thread local variable containing each thread's ID
     private static final ThreadLocal<DontIgnoreCount> dontIgnoreCount =
         new ThreadLocal<DontIgnoreCount>();

     static void incrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         if (counter == null) {
             counter = new DontIgnoreCount();
             dontIgnoreCount.set(counter);
         }
         counter.count++;
     }

     static void decrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         // Must not be null here
         counter.count--;

     static bool shouldSignal() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         return counter.count > 0;
     }
}

---

您可以使用以下内容：

try{
    hideWindow();
}catch (ReportedException ex){
    // ingore

}catch (NullPointerException ex){
       killWindow();
}finally  {
    //to do something more.
}

public class IgnorableException {  

     static class DontIgnoreCount  {
         int count;
     }

     // Thread local variable containing each thread's ID
     private static final ThreadLocal<DontIgnoreCount> dontIgnoreCount =
         new ThreadLocal<DontIgnoreCount>();

     static void incrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         if (counter == null) {
             counter = new DontIgnoreCount();
             dontIgnoreCount.set(counter);
         }
         counter.count++;
     }

     static void decrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         // Must not be null here
         counter.count--;

     static bool shouldSignal() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         return counter.count > 0;
     }
}

---

我对如何使用ThreadLocal有点模糊（可能还有其他一些tupos），但类似这样：

try{
    hideWindow();
}catch (ReportedException ex){
    // ingore

}catch (NullPointerException ex){
       killWindow();
}finally  {
    //to do something more.
}

public class IgnorableException {  

     static class DontIgnoreCount  {
         int count;
     }

     // Thread local variable containing each thread's ID
     private static final ThreadLocal<DontIgnoreCount> dontIgnoreCount =
         new ThreadLocal<DontIgnoreCount>();

     static void incrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         if (counter == null) {
             counter = new DontIgnoreCount();
             dontIgnoreCount.set(counter);
         }
         counter.count++;
     }

     static void decrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         // Must not be null here
         counter.count--;

     static bool shouldSignal() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         return counter.count > 0;
     }
}

请注意，上面没有显示为使编译器满意而必须添加的任何

抛出

子句。这一机制不会消除这些需求

---

您还可以输入委托/观察者方案，用一堆观察者对象替换简单计数器，并向观察者传递消息以引发异常。但是，这本身（没有耦合的异常/尝试范围）不允许将堆栈吹到适当的恢复点。

我对如何使用ThreadLocal有点模糊（可能还有其他一些Tupo），但类似于这样：

try{
    hideWindow();
}catch (ReportedException ex){
    // ingore

}catch (NullPointerException ex){
       killWindow();
}finally  {
    //to do something more.
}

public class IgnorableException {  

     static class DontIgnoreCount  {
         int count;
     }

     // Thread local variable containing each thread's ID
     private static final ThreadLocal<DontIgnoreCount> dontIgnoreCount =
         new ThreadLocal<DontIgnoreCount>();

     static void incrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         if (counter == null) {
             counter = new DontIgnoreCount();
             dontIgnoreCount.set(counter);
         }
         counter.count++;
     }

     static void decrementDontIgnore() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         // Must not be null here
         counter.count--;

     static bool shouldSignal() {
         DontIgnoreCount counter = dontIgnoreCount.get();
         return counter.count > 0;
     }
}

请注意，上面没有显示为使编译器满意而必须添加的任何

抛出

子句。这一机制不会消除这些需求

---

您还可以输入委托/观察者方案，用一堆观察者对象替换简单计数器，并向观察者传递消息以引发异常。但这本身（没有耦合的异常/尝试范围）不允许将堆栈吹到适当的恢复点。

你说的“忽略”是什么意思？不应将它们打印到concole`？不要将异常用于正常控制流。除了系统故障之外，通常应该有一种编写代码的方法来避免抛出异常。例如，您可以提供一种方法，在调用成员之前检查先决条件，以允许用户编写不引发异常的代码@TimHerold它们是通过hideWindow（）打印到控制台的，而不是通过示例中看到的代码。没有办法实现您想要的。Java异常如果未被捕获，将始终“冒泡”到下一个外部作用域。（这不同于、IIRC、PL/I、COBOL和其他一些语言中的类似异常的事件。）您最多可以添加捕获和忽略异常的异常处理程序（希望至少在记录它们之后）。最好是为您的处理程序“宣传”它希望以某种方式处理异常，只有当有人说他们想抓住它时才发出异常信号。这可能需要一个“广告”任务本地计数器，该计数器将由捕获例程递增/递减（在try/finally范围内，以确保在退出时递减）。你说的“忽略”是什么意思？不应将它们打印到concole`？不要将异常用于正常控制流。除了系统故障之外，通常应该有一种编写代码的方法来避免抛出异常。对于e