Java 中的嵌套函数

Question

Java 编程语言是否有任何扩展可以创建嵌套函数？

在很多情况下，我需要创建仅在另一个方法或 for 循环的上下文中使用一次的方法。到目前为止，我还无法在 Java 中完成此任务，尽管可以在 JavaScript 中轻松完成。

例如，这不能在标准 Java 中完成：

for(int i = 1; i < 100; i++){
    times(2); // Multiply i by 2 and print i
    times(i); // Square i and then print the result

    public void times(int num){

        i *= num;
        System.out.println(i);
    }
}

Answer 1

Java 8 引入了 lambda。

java.util.function.BiConsumer<Integer, Integer> times = (i, num) -> {
    i *= num;
    System.out.println(i);
};
for (int i = 1; i < 100; i++) {
    times.accept(i, 2); //multiply i by 2 and print i
    times.accept(i, i); //square i and then print the result
}

() -> 语法适用于仅定义一个方法的任何接口。因此，您可以将其与 Runnable 一起使用，但不能与 List 一起使用。

BiConsumer 是 java.util.function。

值得注意的是，在底层，这定义了一个匿名类并实例化它。 times 是对实例的引用。

Answer 2

下面的答案讨论的是 Java 8 之前的 Java 中最接近嵌套函数的情况。这不一定是我处理 JavaScript 中嵌套函数可能处理的相同任务的方式。通常，私有帮助器方法也能起到同样的作用 - 甚至可能是私有帮助器类型，您可以在方法中创建它的实例，但它可用于所有方法。

当然，在 Java 8 中，有 lambda 表达式，这是一个更简单的解决方案。

---

您可以轻松实现的最接近的是匿名内部类。这与 Java 目前最接近闭包的情况相同，尽管希望 Java 8 能提供更多支持。

匿名内部类有各种限制 - 与 JavaScript 示例（或任何使用 lambda 的内容）及其它们的示例相比，它们显然相当冗长。对封闭环境的访问仅限于最终变量。

所以（可怕地）扭曲你的例子：

interface Foo {
    void bar(int x);
}

public class Test {
    public static void main(String[] args) {
        // Hack to give us a mutable variable we can
        // change from the closure.
        final int[] mutableWrapper = { 0 };

        Foo times = new Foo() {
            @Override public void bar(int num) {
                mutableWrapper[0] *= num;
                System.out.println(mutableWrapper[0]);
            }
        };

        for (int i = 1; i < 100; i++) {
            mutableWrapper[0] = i;
            times.bar(2);
            i = mutableWrapper[0];

            times.bar(i);
            i = mutableWrapper[0];
        }
    }
}

输出：

2
4
10
100

这是你从 JavaScript 代码中得到的输出吗？

Answer 3

我认为在 Java 7 中最接近嵌套函数的不是使用匿名内部类 (Jon Skeet 的回答），但是通过使用其他很少使用的本地类。这样，即使是嵌套类的接口在其预期范围之外也不可见，而且也少了一些冗长。

Jon Skeet 的使用本地类实现的示例如下所示：

public class Test {
    public static void main(String[] args) {
        // Hack to give us a mutable variable we can
        // change from the closure.
        final int[] mutableWrapper = { 0 };

        class Foo {
            public void bar(int num) {
                mutableWrapper[0] *= num;
                System.out.println(mutableWrapper[0]);
            }
        };

        Foo times = new Foo();

        for (int i = 1; i < 100; i++) {
            mutableWrapper[0] = i;
            times.bar(2);
            i = mutableWrapper[0];

            times.bar(i);
            i = mutableWrapper[0];
        }
    }
}

输出：

2
4
10
100

Answer 4

此类方法有时称为闭包。看看Groovy——也许你会更喜欢它而不是Java。在 Java 8 中也可能存在闭包（请参阅 JSR335 和 < a href="http://openjdk.java.net/projects/jdk7/features/#deferred" rel="nofollow">延迟列表）。

Answer 5

对于无参数方法，您可以创建 Runnable 对象

private static void methodInsideMethod(){
    Runnable runnable = new Runnable(){
        @Override
        public void run(){
            System.out.println("Execute something");
        }
    };

    for(int i = 0; i < 10; i++){
        runnable.run();
    }
}

Answer 6

我不知道其他人是否已经弄清楚了这一点，但显然您可以使用 Java 10 及更高版本附带的 var 关键字来变魔术。如果您没有适合您的接口，这可以使您不必声明接口。

public class MyClass {
    public static void main(String args[]) {
        var magic = new Object(){
            public void magic(){
                System.out.println("Hello World!");
            }
        };
        magic.magic();
    }
}

我已经测试过它并且有效。我还没有找到可以让您进行简单共享的 Java 编译器。

Answer 7

考虑创建一个匿名本地类并使用其初始化块来完成工作：

public class LocalFunctionExample {
    public static void main(final String[] args) {
        for (final int i[] = new int[] { 1 }; i[0] < 100; i[0]++) {
            new Object() {
                {
                    times(2); //multiply i by 2 and print i
                    times(i[0]); //square i and then print the result
                }

                public void times(final int num) {
                    i[0] *= num;
                    System.out.println(i[0]);
                }
            };
        }
    }
}

输出：（

2
4
10
100

此技术并不自动需要“最终包装器技巧”，但此处需要处理突变要求。）

这几乎是与 lambda 版本一样简洁，但您可以使用您想要的任何方法签名，它们可以拥有真正的参数名称，并且可以直接通过它们的名称调用方法 - 无需 .apply()或者诸如此类的。 （这种事情有时也会让 IDE 工具工作得更好一些。）

Answer 8

我讨厌使用禁用词，但您可以使用 goto 语句在方法内创建一个有效的子例程。它丑陋且危险，但比之前的答案中显示的要容易得多。尽管在第一个方法内部进行调用的私有方法要好得多，并且可以很好地满足您的需求。我不知道为什么您想要使用嵌套方法来完成如此简单的事情。