从外部调用方法本地内部类的方法

您可以做的一件事是使用私有接口并使 Inner 实现它，从而使 m2() 能够返回一个带有 display() 方法的对象，该方法可以在同一外部类

class Outer {
    public Displayable m1() {
        class Inner implements Displayable {
            @Override
            public void display() {
                System.out.println("msg is displayed");
            }
        }
        return new Inner();
    }

    private interface Displayable {
        void display();
    }

    public void m2() {
        m1().display();
    }
}

这里有三个问题

1. 类型 Inner 对 m2() 不可见

2. Inner 中创建的 m1() 实例对 m2()

   不可见

3. 永远不会调用方法 m1()。

局部类的目的正是为了降低类及其实例的可见性，避免在方法未被调用时创建实例。甚至 Inner 的初始化也应该推迟到方法 m1() 创建它的第一个实例。

不破坏这些属性的解决方案是

class Outer {
    private Runnable accessor;

    public void m1() {
        class Inner {
            void display() {
                System.out.println("msg is displayed");
            }
        }
        Inner inn = new Inner();
        accessor = inn::display;
    }
    
    public void m2() {
        m1();
        accessor.run();
    }
}

此处，m1() 不调用 display，而是使用标准接口提供对它的访问，而不会泄露有关其内部的任何信息。 m2() 调用方法 m1() 以获取访问权限，然后调用标准接口方法。

在 Java 中，我们可以在方法中编写一个类，这将是一个本地类型。与局部变量一样，内部类的作用域被限制在方法内。

方法局部内部类只能在定义内部类的方法中实例化。下面的程序展示了如何使用方法局部内部类

在适当的点实例化类。 我会告诉你代码* 包com;

    public class Outer{

    public void m1() {
        class Inner {
            
            public void display(){
                System.out.println("display from inner class");
            }
            
        }// end of inner class
       
        // Accessing the inner class
        Inner inner = new Inner();
        inner.display();            
    }//m1 ends here
    
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.m1();
    }
  
   }

使用反射可以轻松实现这一目标。

这里的 com.problem.solution 是我的包名。将其替换为您的包名称。

1. 获取与具有给定字符串名称的类或接口关联的外部和内部类对象。

   喜欢 - forName("com.problem.solution.Outer");

2. 然后尝试使用 - inner class

   访问 Class.forName("com.problem.solution.Outer$1Inner");

   在 Java 反射中，您可以使用 OuterClass$1InnerClass 这种类型的语法访问任何内部类。

3. 然后构造object，然后选择您想要的method，然后invoke那个方法。

完整代码：

//package com.problem.solution;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class OuterMain {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m2();
    }
}

class Outer {

    public void m1() {

        class Inner {

            void display() {
                System.out.println("msg is displayed");
            }
        }

        Inner y = new Inner();
    }

    public void m2() {

        try {
            
            Class<?> enclosingClass = Class.forName("com.problem.solution.Outer");
            Object enclosingInstance = enclosingClass.newInstance();

            Class<?> innerClass = Class.forName("com.problem.solution.Outer$1Inner");
            Constructor<?> ctor = innerClass.getDeclaredConstructor(enclosingClass);

            Object innerInstance = ctor.newInstance(enclosingInstance);
            
            Method someMethod = innerInstance.getClass().getDeclaredMethod("display");
            
            someMethod.setAccessible(true);
            someMethod.invoke(innerInstance);
            
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

输出：

msg is displayed

在接口的帮助下，可以根据您的要求访问内部类方法：

    class  OusterMain{
        public static void main(String[] args) {
            OuterClass oc = new OuterClass();
            oc.methodTwo();
        }
    }
    
    
    class OuterClass {
    
        public InnerInterface methodOne() {
    
            class InnerClass implements InnerInterface{
    
                @Override
                public void display() {
    
                    System.out.println("Print message.");
                }
            }
            // this reference is used to call display() method inside methodTwo()
            return new InnerClass(); 
        }
    
        private interface InnerInterface{
            void display();
        }
    
        public void methodTwo() {
            methodOne().display();
        }
    }