Java支持内部/本地/子方法吗？

Question

这是我的代码。

public class SubFunction {
    private String drawTribleX(){
        return trible("X");
    }
    private String trible(String t){
        return t + t + t;
    }
    public static void main(String[] args){
        SubFunction o = new SubFunction();
        System.out.println(o.drawTribleX());
    }
}

我可以做这样的事情吗？

public class SubFunction {
    private String drawTribleX(){
        // *** move trible(t) inside drawTribleX() ***
        private String trible(String t){
            return t + t + t;
        }
        return trible("X");
    }
    public static void main(String[] args){
        SubFunction o = new SubFunction();
        System.out.println(o.drawTribleX());
    }
}

谢谢。

Answer 1

更新 2014-02-09：

JDK 8 引入了 lambda（匿名函数表达式），它允许您像这样解决它：

Function<String, String> trible = s -> s+s+s;
System.out.println(trible.apply("X"));           // prints XXX

---

（JDK 7 及更低版本） strong>

不，Java不支持“直接”嵌套方法。 （大多数函数式语言都是如此，包括一些 JVM 语言，例如 Scala 和 Clojure！）

仅供参考；您可以定义本地类（方法内的类），因此确实编译

class SubFunction {
    private String drawTribleX(){

        // *** move trible(t) inside drawTribleX() ***
        class Trible {
            private String trible(String t){
                return t + t + t;
            }
        }

        return new Trible().trible("X");
    }
    public static void main(String[] args){
        SubFunction o = new SubFunction();
        System.out.println(o.drawTribleX());
    }
}

注意，尽管有一些本地类的限制

3.11.2。 本地课程的限制

本地课程受到以下限制：

• 本地类仅在定义它的块中可见；它永远不能在该块之外使用。

• 本地类不能声明为 public、protected、private 或 static。这些修饰符适用于类的成员；它们不允许与局部变量声明或局部类声明一起使用。

• 与成员类一样，出于同样的原因，本地类不能包含静态字段、方法或类。唯一的例外是声明为静态和最终的常量。

• 接口无法在本地定义。

• 本地类与成员类一样，不能与其任何封闭类同名。

• 如前所述，局部类可以使用其范围内的局部变量、方法参数，甚至异常参数，但前提是这些变量或参数被声明为 Final。这是因为本地类实例的生命周期可能比定义该类的方法的执行时间长得多。因此，局部类必须拥有它使用的所有局部变量的私有内部副本（这些副本由编译器自动生成）。确保局部变量和私有副本始终相同的唯一方法是坚持局部变量是final的。

因此，正如您所看到的，在这些情况下，您的第一个选择（没有嵌套方法）更可取。

Answer 2

很简单——不。您不能将一个方法嵌套在另一个方法中。

如果您真的想要这样做，您可以在方法中定义类（奇怪的是，考虑到前面的限制），因此可以将您的方法包装在外部方法内的类中。

然而，这不是很惯用，一般做法似乎是有一个私有方法列表（在顶级类中），可能根据目的进行分组，并用注释块来划分组。

---

然而，如果您碰巧发现自己使用 Scala，您可以随心所欲地嵌套方法......

Answer 3

您也可以尝试这种方式，即匿名内部类。

public class SubFunction {
    private String drawTribleX() {
        // *** move trible(t) inside drawTribleX() ***
        Trible t = new Trible() {
            public String trible(String t) {
                return t + t + t;
            }
        };
        return t.trible("X");
    }

    public static void main(String[] args) {
        SubFunction o = new SubFunction();
        System.out.println(o.drawTribleX());
    }

    interface Trible {
        String trible(String t);
    }
}

Answer 4

您可以使用匿名类。像这样的东西；

class SubFunction {

    public static void main(String[] args) {
        SubFunction o = new SubFunction();
        System.out.println(o.drawTribleX());
    }

    private String drawTribleX() {
        MyTrible trible = new MyTrible() {
            @Override
            public String doTrible(String t) {
                return t + t + t;
            }
        };

        return trible.doTrible("X");
    }

    private interface MyTrible {
        public String doTrible(String t);
    }
}

如果您愿意，您可以使用相同的接口定义不同类型的操作，并根据需要传递这些操作。

Answer 5

可以在任何方法中编写 lambda。

例如，使用 lambda 创建递归方法：

像 Interface 这样的对象

class Foo{
   Foo parent;
}

lambda 方法表达式需要

public interface Function<ARGUMENTTYPE, RETURNTYPE>{
    RETURNTYPE apply(ARGUMENTTYPE argument);
}

递归 findRoot 方法来获取顶级 Foo.parent

private Foo findRoot(final Foo foo) {
    //Create a Lambda Function for recursive search.
    final Function<Foo, Foo> recursiveSearch = new Function<Foo, Foo>() {
        @Override
        public Foo apply(final Foo fee) {
            //is the parent null return null
            if (fee.parent == null) {
                return null;
            } else if (fee.parent.equals(fee)) {
                //safety check ;-)
                throw new IllegalStateException("Circular Dependencies of " + fee.toString());
            } else {
                Foo parentFoo = fee.parent;
                //check if parent has parent otherwise return parent in else block
                if (parentFoo != null && parentFoo.parent != null) {
                    return this.apply(parentFoo);
                } else {
                    return parentMarket;
                }
            }
        }
    };
    //get the root
    final Foo rootFoo = recursiveSearch.apply(foo);
    //Safety check 2 ;-)
    if (rootFoo != null && rootFoo.equals(foo)) {
        throw new IllegalStateException("Circular Dependencies of " + foo.toString)();
    }
    return rootFoo;
}