顾名思义，在类的内部编写的类就叫内部类。即一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。内部类又分为成员内部类和局部内部类。

成员内部类

成员内部类有静态和非静态之分，类内有属性、方法、构造器。

public class TestOuter {
    // 非静态的成员内部类
    public class D{
        int age = 20;
        String name;
        public void method(){
            System.out.println(age); // 20
            a();
            int age = 30;
            System.out.println(age); // 30
            System.out.println(this.age); // 20
            System.out.println(TestOuter.this.age); // 10
        }
    }
    // 静态成员内部类
    static class E{
        public void method(){
            /*System.out.println(age);
            a();*/
        }
    }
    int age = 10;
    public void a(){
        System.out.println("这是a方法");
    }
    public TestOuter(){}
    public TestOuter(int age) {
        this.age = age;
    }
}

class Demo{
    public static void main(String[] args) {
        //创建外部类的对象：
        TestOuter to = new TestOuter();
        to.a();

        //静态的成员内部类创建对象：
        TestOuter.E e = new TestOuter.E();

        //非静态的成员内部类创建对象：
        //错误：TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d = t.new D();
    }
}

注意事项如下：

• 内部类可以访问外部类的内容
• 内部类和外部类属性重名的时候，要用 外部类.this.属性 调用
• 静态内部类中只能访问外部类中被 static 修饰的内容
• 外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
• 非静态的成员内部类创建对象需要额外注意

局部内部类

public class TestOuter {
    public void method(){
        final int num = 10;
        class A{
            public void a(){
                // num = 20;
                System.out.println(num);
            }
        }
    }

    public Comparable method2(){
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }

    public Comparable method3(){
        // 匿名内部类
        return new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }

    public void test(){
        Comparable com = new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
        System.out.println(com.compareTo("abc"));
    }
}

注意事项如下：

• 在局部内部类中访问到的变量必须是被 final 修饰的
• 如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
• 一个匿名内部类一定是在 new 的后面，用其隐含实现一个接口或实现一个类。