java 如何调用内部类的方法调用

调用内部类方法的基本步骤

在Java中调用内部类的方法需要先创建外部类的实例，再通过外部类实例创建内部类实例，最后通过内部类实例调用其方法。

public class OuterClass {
    public class InnerClass {
        public void innerMethod() {
            System.out.println("Inner method called");
        }
    }
}

// 调用方式
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.innerMethod();

静态内部类的方法调用

如果内部类是静态的，可以直接通过外部类名创建内部类实例，无需外部类实例。

public class OuterClass {
    public static class StaticInnerClass {
        public void staticInnerMethod() {
            System.out.println("Static inner method called");
        }
    }
}

// 调用方式
OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
staticInner.staticInnerMethod();

方法内部类的方法调用

方法内部类（局部内部类）只能在定义它的方法内部实例化和调用。

public class OuterClass {
    public void outerMethod() {
        class MethodInnerClass {
            public void methodInnerMethod() {
                System.out.println("Method inner method called");
            }
        }

        MethodInnerClass mic = new MethodInnerClass();
        mic.methodInnerMethod();
    }
}

// 调用方式
OuterClass outer = new OuterClass();
outer.outerMethod();

匿名内部类的方法调用

匿名内部类通常在创建时就定义并实例化，可以直接调用其方法。

public interface MyInterface {
    void interfaceMethod();
}

public class OuterClass {
    public void createAnonymousClass() {
        MyInterface anonymous = new MyInterface() {
            @Override
            public void interfaceMethod() {
                System.out.println("Anonymous class method called");
            }
        };

        anonymous.interfaceMethod();
    }
}

// 调用方式
OuterClass outer = new OuterClass();
outer.createAnonymousClass();

私有内部类的方法调用

私有内部类的方法只能通过外部类的公共方法间接调用。

public class OuterClass {
    private class PrivateInnerClass {
        public void privateInnerMethod() {
            System.out.println("Private inner method called");
        }
    }

    public void callPrivateInnerMethod() {
        PrivateInnerClass pic = new PrivateInnerClass();
        pic.privateInnerMethod();
    }
}

// 调用方式
OuterClass outer = new OuterClass();
outer.callPrivateInnerMethod();

从外部类外部访问内部类方法

当需要从外部类的外部访问内部类方法时，可以在外部类中提供获取内部类实例的方法。

public class OuterClass {
    public class InnerClass {
        public void innerMethod() {
            System.out.println("Inner method called");
        }
    }

    public InnerClass getInnerClass() {
        return new InnerClass();
    }
}

// 调用方式
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.getInnerClass();
inner.innerMethod();

使用反射调用内部类方法

通过反射机制可以动态调用内部类的方法，适用于需要运行时确定调用哪个方法的情况。

import java.lang.reflect.Method;

public class OuterClass {
    public class InnerClass {
        private void reflectiveInnerMethod() {
            System.out.println("Reflective inner method called");
        }
    }
}

// 调用方式
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();

try {
    Method method = inner.getClass().getDeclaredMethod("reflectiveInnerMethod");
    method.setAccessible(true);
    method.invoke(inner);
} catch (Exception e) {
    e.printStackTrace();
}