相关疑难解决方法(0)

最近我惊讶地发现在Java中的finally块中可以有一个return语句.

似乎很多人认为这样做是不好的,如' 不要在最终条款中返回 '中所描述的那样.更深入地抓了一下,我还发现' Java的回归并不总是 ',这显示了最终块中其他类型的流控制的一些非常可怕的例子.

所以,我的问题是,有人能给我一个例子,其中finally块中的return语句(或其他流控制)产生更好/更可读的代码吗？

通过阅读本论坛中已经提到的与上述主题相关的所有问题(参见标题),我完全理解finally总是被称为.(除了System.exit和无限循环).但是,我想知道是否return在catch块中调用了a,然后return从finally块调用了另一个.

例如:

public static void main(String[]args) {
    int a = new TestClass().absorbeTheValue();
}

int absorbeTheValue() {
    try {
        int a = 10/0;
        if (a > 0) return 4;
    } catch(Exception e) {
        return 45;
    } finally {
        return 34;
    }
}    

所以这里输出(当调用方法时)在任何情况下都是34.这意味着终于总能运行.我认为虽然其他"回归"根本没有运行.在很多帖子中,我发现最后将内容写入catch子句返回已写入的内容.我的理解是,一旦catch子句中的返回值即将被评估,控制流就会传递给finally子句,而子句又有另一个返回,这次返回将被评估,而不会将控制权传递给catch子句.通过这种方式,return在运行时唯一被调用的是最终返回.你同意吗？

甲return在finally不传递回控制到程序但返回值,并结束方法.我们可以这样说吗？

鉴于此代码:

String test() {
    try {
        return "1";
    } finally {
        return "2";
    }
}

语言规范是否定义了调用的返回值test()？换句话说:每个JVM中它总是一样的吗？

在Sun JVM中,返回值是2,但我想确定,这不依赖于VM.

当return;try块中存在try-finally执行时,我感到困惑.根据我的理解,finally块将始终执行,即在返回调用方法之前.在考虑以下简单代码时:

public class TryCatchTest {
    public static void main(String[] args){
        System.out.println(test());
    }
    static int test(){
        int x = 1;
        try{
            return x;
        }
        finally{
            x = x + 1;
        }
    }
}

打印的结果实际上是1.这是否表示finally块未执行？任何人都可以帮助我吗？

类似的问题已被问到here。但这并没有提供答案。

try {
        object = (Dev)Class.forName("Dev").newInstance();
    } catch (Exception e) 
    {
        throw new RuntimeException("Devis not available");
    }
    finally
    {
        return object;  
    }

但finally块给出警告：

finally 块没有正常完成

但根据我的理解，finally块总是被执行并返回对象。为什么警告说它不会正常完成？

我有Java背景，最近开始学习Kotlin。现在我正在读一本书“Programming Kotlin”，我看到了一个带有 try-catch 表达式的片段。这促使我编写了一些简单的函数来比较它在 Java 和 Kotlin 中的工作方式。第一个功能：

fun tryExpExplicit(throwing: Boolean): Int {
    return try {
        if (throwing) {
            throw RuntimeException()
        }
        return 1
    } catch (e: Exception) {
        return 2
    } finally {
        return 3
    }
}

按我的预期工作并且总是返回 3。

出乎意料的是，当我使用隐式返回时，行为不同

fun tryExpImplicit(throwing: Boolean): Int {
    return try {
        if (throwing) {
            throw RuntimeException()
        }
        1
    } catch (e: Exception) {
        2
    } finally {
        3
    }
}

并且 3 永远不会返回。
为什么这两个函数的工作方式不同？

据我了解，以下代码应打印0为输出，因为堆栈已满，应该立即退出方法。

但是，当我运行以下代码时，它100在第一种情况下打印1，而在第二种情况下打印：

class ErrorAndException {
        public static int callStackOverflow() {
            try {
                callStackOverflow();
                return 100;
            } catch (Error e) {
                System.out.println(e);
                return 0;
            } finally {
            }
        }

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

案例-2

class ErrorAndException {
            public static int callStackOverflow() {
                try {
                    callStackOverflow();
                    return 100;
                } catch (Error e) {
                    System.out.println(e);
                    return 0;
                } finally {
                           return 1
                }
            }

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