Question

例如：

try {
        Thread.sleep(333);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

我可以使用像trySleep(Thread.sleep(333));之类的创建方法以某种方式使用上面的try / catch吗？它会和原始的尝试完全相同吗？

使用示例：

public class Test implements Runnable {

    public Test() {
        Thread thisThread = new Thread(this);
        thisThread.start();
    }

    @Override
    public void run() {
        while (true){
            System.out.println("Testing");
            trySleep(Thread.sleep(333));
        }
    }

    public void trySleep(/*Thread object*/){
        //Code for try/catch
    }

    public static void main(String[] args) {
        new Test();
    }

}

当然上面的代码不会编译，只是针对这个问题。

我想要这种事情的原因是因为我发现try / catch事情非常混乱并且安静地阅读。

Answer 1

您可以将Thread.sleep包装在一个函数中，该函数将任何异常重新抛出为运行时异常（或任何未捕获的异常）。

public static void trySleep(long millis) {
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted during sleep", e);
    }
}

Answer 2

我不明白这个问题。如果将三行添加到trySleep-method Body中，则会得到一个让线程休眠的方法。

所以答案是肯定的。

顺便说一下：你写了一个无尽的睡眠循环

Answer 3

是的，您可以这样做，但不完全按照您现在描述的方式。无论你使用Thread.sleep()的哪个地方，你都必须抓住InterruptedException，所以你必须将调用包含在这样的方法中：

public void trySleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        e.printStackTrace(); //handle exception here
    }
}

您可以这样调用此方法：trySleep(333)

有时候最好只为你的方法添加一个throws声明，或者重新抛出一个更有意义的异常，除非你知道这是捕获异常最有意义的位置。

Answer 4

您可以按照建议将其睡眠代码包装在另一种方法中。

public static void trySleep(Thread target, long millis){
    try{
        target.sleep(millis);
    } catch(InterruptedException e) {
         System.err.println("Exception Occurred while trying to sleep!");
    }
}

事实上，您可能应该这样做，因为使代码模块化是正确的方法。

Answer 5

我认为你真正需要考虑的一件重要的事情（除了正确解决这个问题的答案之外），就是要了解你所调用的代码。

在您的代码中：

@Override
public void run() {
    while (true){
        System.out.println("Testing");
        trySleep(Thread.sleep(333));
    }
}

特别是这一行：

trySleep(Thread.sleep(333));

你基本上是在说

使用值333调用方法Thread.sleep（）。
无论Thread.sleep（）返回什么值，都将其传递给另一个方法。

但是the Javadocs说这是一种无效的方法。

同样在您的代码中：

public void trySleep(/*Thread object*/){
    //Code for try/catch
}

您应该检查this stackoverflow post为什么这不是一个好习惯（因为您将尝试在实例对象上调用静态方法）。

其他人已就此回答了您的问题，但我强烈建议您对这些方面进行梳理，因为这表明您可能会错过一些重要概念的重要知识。

Answer 6

您可以使用java 8的lambda表达式执行类似的操作：

@FunctionalInterface
interface InterruptedExceptionRunnable {
    void run() throws InterruptedException;
}

void trySleep(InterruptedExceptionRunnable exRunnable) {
    try {
        exRunnable.run();
    } catch(InterruptedException ex) {
        ex.printStackTrace();
    }
}

允许你写这个：

trySleep(()->Thread.sleep(333));

Answer 7

是的，基本上可以使用Java 8 lambdas。

class Example {
    @FunctionalInterface
    interface InterruptableRunnable {
        void run() throws InterruptedException;
    }

    static void tryRun(InterruptableRunnable r) {
        try {
            r.run();
        } catch(InterruptedException ie) {
            ie.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                // passing a lambda
                tryRun( () -> Thread.sleep(333) );
            }
        });

        t.start();
        // passing a method reference
        tryRun(t::join);
    }
}

Java：是否可以缩短try / catch？

7 个答案: