更多 Java 基础知识方面的文章，请参见文集《Java 基础知识》

成员内部类 member inner class

• 在类的内部
• 可以访问外部类的所有属性，包括 static 和 final，因此可以修改外部类

如下所示：

• 内部类 Inner 可以访问外部类 Outer 的成员变量 i
• 外部类 Outer 可以使用内部类 Inner
• 如果想在其他地方使用内部类 Inner，需要通过外部类的对象来访问

public class InnerClass_Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.f1();

        // 如果想在其他地方使用内部类 Inner，需要通过外部类的对象来访问
        // Outer.Inner inner = new Outer.Inner() 编译错误
        Outer.Inner inner = outer.new Inner();
        inner.f2();
    }
}

class Outer {
    private int i = 1;

    public void f1() {
        // 外部类 Outer 可以使用内部类 Inner
        Inner i = new Inner();
        i.f2();
    }

    // 内部类 Inner 可以访问外部类 Outer 的成员变量
    class Inner {
        public void f2() {
            i = 2;
        }
    }
}

局部内部类 local inner class

• 在类的方法的内部定义并使用
• 不能在方法的外部访问内部类
• 内部类只能访问方法中的 final 变量，不能访问方法外的变量

例如：

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

class Outer {
    public void f1() {
        // 在类的方法的内部
        class Inner {
            public void f2() {
                // do something
            }
        }

        Inner i = new Inner();
        i.f2();
    }
}

匿名内部类 anonymous inner class

继承式

public class InnerClass_Test {
    public static void main(String[] args) {
        Car c = new Car() {
            public void f() {
                System.out.println("This is BMW");
            }
        };

        c.f();
    }
}

class Car {
    public void f() {
        System.out.println("This is car");
    }
}

接口式

public class InnerClass_Test {
    public static void main(String[] args) {
        Run r = new Run() {
            public void f() {
                System.out.println("This is BMW running");
            }
        };

        r.f();
    }
}

interface Run {
    void f();
}

参数式

public class InnerClass_Test {
    public static void main(String[] args) {
        invoke(new Car() {
            public void f() {
                System.out.println("This is BMW");
            }
        });
    }

    public static void invoke(Car c) {
        c.f();
    }
}

class Car {
    public void f() {
        System.out.println("This is car");
    }
}

静态嵌套类 static nested class

• 与成员内部类不同，在外部使用静态嵌套类，不需要通过外部类的对象来访问。

public class InnerClass_Test {
    public static void main(String[] args) {
        // 在外部使用静态嵌套类，不需要通过外部类的对象来访问
        Outer.Nested_Outer n = new Outer.Nested_Outer();
        n.f();
    }
}

class Outer {
    static class Nested_Outer {
        public void f() {
            System.out.println("This is nested class");
        }
    }
}