如何执行在类中声明的函数公共方法，而该类又在私有方法中？

Question

所以，我想执行以下代码块的 sum()：

import java.lang.reflect.Method;

public class LocalOuterClass {  // start of outer
    private int x = 10;
    private Object run() {  //start of inner
        class LocalInnerClass {
            private int y = 20;
            public void sum() {
                System.out.println(x+y);
            }
        }   //end of inner
        LocalInnerClass lc = new LocalInnerClass();
        //lc.sum();
        return lc;
    }
    public static void main(String[] args) {
        LocalOuterClass Loc = new LocalOuterClass();
        Object obj = Loc.run();
        System.out.println(obj.getClass());
        Method[] methods = obj.getClass().getMethods();
        for (Method method : methods) {
            String MethodName = method.getName(); 
            System.out.println("Name of the method: "+ MethodName);
        }
    }
}   //end of outer

当我执行 lc.sum() 时，正确执行 sum()。 但是当我将内部类的对象返回给 main() 并尝试执行 sum() 时，它会给出编译器错误。 在对象上执行 getClass().getMethods() 确实将 sum() 作为方法之一打印。 我应该怎么做才能在 main() 中执行 sum()？

Answer 1

您必须将返回类型更改为LocalInnerClass并将LocalInnerClass移出方法：

public class LocalOuterClass {

    private int x = 10;

    private class LocalInnerClass {

        private int y = 20;

        public void sum() {
            System.out.println(x + y);
        }
    }

    private LocalInnerClass run() {
        LocalInnerClass lc = new LocalInnerClass();
        //lc.sum();
        return lc;
    }

    public static void main(String[] args) {
        LocalOuterClass Loc = new LocalOuterClass();
        LocalInnerClass obj = Loc.run();

        obj.sum();  // it works!
        // ...
    }
}

Answer 2

问题是，您的main方法不知道整个LocalInnerClass 。 如果整个类型未知，它没有帮助，它有一个公共方法。 你需要重构你的代码才能改变它。

实际上，您的方法run当前返回一个Object类型的值，您需要返回一个LocalInnerClass类型的值，但是由于类型可见性，这是​​不可能的。

您基本上有两种选择。 一种是将整个LocalInnerClass移动到main可见的位置（如 oleg.cherednik 建议的那样）：

class LocalOuterClass {
    private int x = 10;
    private LocalInnerClass run() {  // now we can retun `LocalInnerClass`
        return new LocalInnerClass();
    }
    public static void main(String[] args) {
        new LocalOuterClass().run().sum(); // works!
    }
    
    private class LocalInnerClass {
        private int y = 20;
        public void sum() {
            System.out.println(x+y);
        }
    }
}

另一种选择是实现/扩展具有sum的不同类型，例如：

class LocalOuterClass { 
    private int x = 10;
    private Summable run() {  //start of inner
        class LocalInnerClass implements Summable {
            private int y = 20;
            public void sum() {
                System.out.println(x+y);
            }
        } 
        return new LocalInnerClass();
    }
    public static void main(String[] args) {
        new LocalOuterClass().run().sum(); // works as well
    }
    
    private interface Summable {
        void sum();
    }
}

使用此接口选项，类型LocalInnerClass仍然对您的run方法之外的任何人不可见，但是Summable是，并且由于您的LocalInnerClass实现了Summable您可以返回该类型的值。