如何执行在类内声明的函数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!
        // ...
    }
}

,

问题是您的LocalInnerClass方法不了解整个main。如果整个类型未知，则使用公共方法是没有帮助的。您需要重构代码以进行更改。

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

基本上有两种选择。一种是将整个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您可以返回该类型的值。