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

因此，我想执行以下代码块的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（），我应该怎么做？

您必须将返回类型更改为

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!
        // ...
    }
}

---

问题是，

main

-方法不知道整个

localinerclass

。如果整个类型未知，那么它有一个公共方法是没有帮助的。为了改变这一点，您需要重构代码

实际上，您的方法

run

当前返回类型为

Object

的值，您需要返回类型为

localinerclass

的值，但是由于类型可见性的原因，这是不可能的

基本上有两种选择。一种是将整个

LocalinerClass

移动到

main

可见的位置（如oleg.cherednik建议的）：

class LocalOuterClass{
私人整数x=10；
private LocalInnerClass run（）{//现在我们可以重新运行'LocalInnerClass'`
返回新的LocalnerClass（）；
}
公共静态void main（字符串[]args）{
新建LocalOuterClass（）.run（）.sum（）；//有效！
}
私有类本地类{
私人智力y=20；
公帑{
系统输出打印项次（x+y）；
}
}
}

另一个选项是实现/扩展具有

sum

的不同类型，例如：

class LocalOuterClass{
私人整数x=10；
私有可求和运行（）{//内部
类LocalinerClass实现可求和{
私人智力y=20；
公帑{
系统输出打印项次（x+y）；
}
} 
返回新的LocalnerClass（）；
}
公共静态void main（字符串[]args）{
新的LocalOuterClass（）.run（）.sum（）；//也可以使用
}
专用接口可求和{
无效金额（）；
}
}

使用此接口选项，

localinerclass

类型对于

run

-方法之外的任何人仍然不可见，但是

Summable

-接口不可见，并且由于

localinerclass

实现了

Summable

，因此可以返回该类型的值