Java 内部函数 | 了解内部类与匿名内部类中的函数定义和使用方法

Java 内部函数以及内部类与匿名内部类中的函数定义和使用方法是 Java 语言中面向对象编程的核心部分。内部函数是定义在类或接口内部的函数，可以访问类或接口的成员，也可以在外部调用，是 Java 语言中一种灵活的语法特性。接下来我们将详细介绍 Java 内部函数、内部类和匿名内部类中的函数定义和使用方法。

Java 内部函数的定义和使用方法

Java 内部函数是定义在类或接口内部的函数，可以访问类或接口的成员，也可以在外部调用。内部函数的定义方法与普通函数的定义方法类似，只需要将函数定义在类或接口中，然后在需要调用时直接使用即可。下面是一个简单的例子：

public class InnerFunctionDemo {
    private int x = 1;
    private void printX() {
        System.out.println("x = " + x);
    }
    public void test() {
        printX();
        int y = 2;
        final int z = 3;
        class Inner {
            private int x = 4;
            void printY() {
                System.out.println("y = " + y);
            }
            void printZ() {
                System.out.println("z = " + z);
            }
            void printAll() {
                printX();
                printY();
                printZ();
                System.out.println("Inner.x = " + x);
            }
        }
        Inner inner = new Inner();
        inner.printAll();
    }
    public static void main(String[] args) {
        InnerFunctionDemo outer = new InnerFunctionDemo();
        outer.test();
    }
}

上面的例子中定义了一个名为 Inner 的内部类，在 Inner 类中定义了三个函数 printY、printZ 和 printAll，其中 printAll 函数调用了外部类 InnerFunctionDemo 中定义的 printX 函数以及内部类 Inner 中的 printY、printZ 和 x 成员。在外部类中，通过创建 Inner 实例调用了 Inner 类中的 printAll 函数。

需要注意的是：

1. 内部类可以访问外部类的所有成员（包括成员变量和成员函数），但外部类只能访问内部类中的 public 成员。

2. 内部类和外部类可以有相同的成员变量名，使用 this.x 可以访问内部类中的 x，外部类中的 x 则需要使用 OuterClass.this.x 的方式来访问。

3. 内部类可以被访问修饰符 public、protected、private 和默认修饰符修饰，但外部类只能被 public 或默认修饰符修饰。

内部类的定义和使用方法

Java 内部类是一个定义在另一个类中的类，可以访问外部类的所有成员和方法。内部类有四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。下面分别介绍这四种类型的内部类的定义和使用方法。

1. 成员内部类

成员内部类是定义在另一个类中的普通类，在外部类中可以通过 new 关键字创建成员内部类的实例。成员内部类的定义方式如下：

public class Outer {
    private int x = 3;
    public class Inner {
        private int y = 4;
        public void print() {
            System.out.println("Outer.x = " + x);
            System.out.println("Inner.y = " + y);
        }
    }
}

在上面的例子中，定义了一个名为 Inner 的成员内部类，内部类中可以访问外部类的所有成员，包括成员变量和成员函数。可以在外部类中通过以下方式创建 Inner 的实例：

Outer o = new Outer();
Outer.Inner i = o.new Inner();
i.print();

通过 new Outer().new Inner() 的方式也可以创建 Inner 实例，但是这种方式需要用到一个外部类的实例。

2. 局部内部类

局部内部类是定义在方法或代码块中的类，只在定义的代码块内可见，不能被其他方法或代码块访问。局部内部类的定义方式如下：

public class Outer {
    public void test() {
        final int x = 5;
        class Inner {
            public void print() {
                System.out.println("x = " + x);
            }
        }
        Inner i = new Inner();
        i.print();
    }
}

在上面的例子中，定义了一个名为 Inner 的局部内部类，可以访问外部类中的变量 x，用 final 修饰是因为某些情况下能够提高性能的原因。可以在外部类的 test 方法中通过以下方式创建 Inner 的实例：

Outer o = new Outer();
o.test();

3. 匿名内部类

匿名内部类是没有名字的内部类，可以直接在代码中创建并使用它。匿名内部类通常用于创建实现某个接口或继承自某个类的对象。匿名内部类的定义方式如下：

public class Outer {
    public void test() {
        MyInterface i = new MyInterface() {
            public void print() {
                System.out.println("hello world");
            }
        };
        i.print();
    }
}
interface MyInterface {
    void print();
}

在上面的例子中，定义了一个匿名内部类对象，实现了一个名为 MyInterface 的接口，并覆盖了接口中的 print 函数。可以在外部类的 test 方法中通过以下方式创建匿名内部类的实例：

Outer o = new Outer();
o.test();

4. 静态内部类

静态内部类是一个类定义在另一个类中的静态方法内，定义方式与成员内部类类似，但静态内部类不能访问外部类的非静态成员。静态内部类的定义方式如下：

public class Outer {
    public static void test() {
        StaticInner i = new StaticInner();
        i.print();
    }
    static class StaticInner {
        public void print() {
            System.out.println("static inner");
        }
    }
}

在上面的例子中，定义了一个名为 StaticInner 的静态内部类，可以在外部类的静态方法中直接创建 StaticInner 的实例，访问其成员函数。可以在外部类中通过以下方式调用静态方法：

Outer.test();

需要注意的是，静态内部类不依赖于外部类的实例，可以在没有外部类实例的情况下直接访问静态内部类的成员。

总结

Java 内部函数以及内部类与匿名内部类中的函数定义和使用方法是 Java 语言中面向对象编程的核心部分。内部函数可以访问类或接口的成员，也可以在外部调用，是一种灵活的语法特性。内部类可以访问外部类的所有成员和方法，分为成员内部类、局部内部类、匿名内部类和静态内部类，每种类型的内部类都有不同的应用场景。在实际编程中可以根据需要选择合适的方式使用。