在 java 中以未检查的形式抛出已检查的异常，而不是包装

Question

我有以下代码，我需要扫描抛出的异常。如果它满足特定条件，我将忽略该异常。否则我重新抛出。抛出的异常是一个已检查的异常，这意味着重新抛出是困难的部分。包括我必须抓住它并且操作发生在一个重写方法内的事实，该方法的基础 class' 方法没有使用 throws clause。卡在重新编程整个巨大的库或将异常包装为 RuntimeException 之间（这不是一个选项，因为我们将包装的已检查异常预计在将来某个地方（派生 class）由 catch 子句在它的传播过程中——它是某种信号），我希望就这样的实现获得一些建议。或者也许只是实现。

    /*
     * Translated from c++11_7.3.19 AIEDs schemes >${ref[213]:`through}.
     * guarantees learning, re-learning and 'un-learning'. programmed intelligence is not
     * altered whatsover and is made as root of bias [x:~y]. fetch cycle is omitted.
     */
    @Override
    public void intelligenceSync()// No throws clause here
    {
        try {
            super.intelligenceSync();
            // the throwing culprit.
            global_contribution.acceptOrReformState(this);
            generateMetaLogicReforms(this);
        } catch (Throwable t_) {
            if (t_ instanceof Signalx) {
                Signalx sx = (Signalx) t_;
                // Note how bias inreases propagation speed by ~12.21 >${ref[371]:exp2}.
                applyBias(sx);
                stopInvalidation(sx);
                // check if x neuron is almost proved.
                if (sx.neuronSP() > sx.threshold()) {
                    // We'll find other ways of completing our proofs.
                    // Note the algorithm is not so complete.
                    netsync(sx);
                    while (sx.pushDeeper()) {
                        sx.enhance(Metrics.COMPLETION.esteem());
                        sx.suspendSubPathTraversal(Suspender.IN_DREAM_RESOLVE, Handler.NULL_LOGIC);
                    }
                    generateSubLogicReforms(sx);
                } else {
                    restore(sx);
                    continueInvalidation(sx);
                    // We rethrow.
                    uncheckedThrow(sx);
                    // exception thrown
                }
            } else if (t_ instanceof Signaly) {
                // Reforms must be handle explicitly.otherwise RelationalAttender will complain
                // .
                // ... blah blah blah.
            } else {
                // We rethrow
                uncheckedThrow(t_);
            }
            //
        }
    }

Answer 1

如果您想抛出未经检查的异常，或者最具体地说 Throwable，您可以使用以下方法。

private static <T extends Throwable> void uncheckedThrow_helper(Throwable e) throws T{
   throw (T)e;
}
static void uncheckedThrow(Throwable e){
    uncheckedThrow_helper(e);
}

调用该方法不会导致编译检测到任何 Unchecked Exception 错误。

try{
  uncheckedThrow(new Exception());
  System.out.println("It doesn't work");
}catch(Exception e){
  System.out.println("It works.");
}

输出：

It works.

Answer 2

我需要类似的东西，但我的方法需要一个 return 值，这导致我 return null 或类似的东西。

因此，我做了一个小小的改编：

private static <T extends Throwable> RuntimeException unchecked(Throwable t) throws T {
    throw (T) t;
}

该方法现在 returning 一个 RuntimeException，它允许我们“抛出”未经检查的异常，绕过编译器，并且不再期望 return 任何值。

private static String yourIOOperationThatReturnsSomething() {
    throw unchecked(new IOException("test"));
}

public static void main(String []args) {
    System.out.println(yourIOOperationThatReturnsSomething());
}

可以在此处找到一个运行示例：http://tpcg.io/VIC7A6

在 java 中以未检查的形式抛出已检查的异常，而不是包装

throw checked exception as unchecked in java instead of wrapping

java

try-catch

throws

catch-block

rethrow