-1

我有以下代码，我需要扫描抛出的异常。如果它满足特定条件，我将忽略该异常。否则我重新扔。抛出的异常是一个检查异常，这意味着重新抛出是困难的部分。包括我必须抓住它，并且操作发生在一个被覆盖的方法中，该方法的基类方法没有使用throws clause. 卡在重新编程整个庞大的库或将异常包装为RuntimeException（这不是一个选项，因为我们将包装的检查异常，在其传播过程中的某个地方（派生类）预期会被一个 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_);
            }
            //
        }
    }
4

2 回答 2

2

如果您想抛出未经检查的异常，或者更具体地说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.

于 2020-11-22T17:06:44.460 回答
0

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

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

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

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

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

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

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

于 2022-02-09T09:10:47.473 回答