Java内部类

在Java中，允许在一个类的内部定义类，这样的类被称作内部类，这个内部类所在的类被称为外部类。

在Java中，将内部类划分为如下四种：成员内部类，局部内部类，静态内部类和匿名内部类。

成员内部类

在一个类中除了可以定义成员变量、成员方法外，还可以定义类，这样的类被称为成员内部类。

在成员内部类中，可以访问外部类的所有成员，包括成员变量和成员方法；在外部类中，同样可以访问成员内部类中的变量和方法。

public class Outer {

    private int count = 12;

    private void showInner() {
        Inner inner = new Inner();
        System.out.println("index=" + inner.index);
    }

    class Inner {
        private int index = 17;

        public void showOuter() {
            System.out.println("count=" + count);
        }

    }

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

        Outer.Inner inner = outer.new Inner();
        inner.showOuter();
    }
}

局部内部类

局部内部类，也称为方法内部类，就是定义在某个局部范围中的类，它和局部变量一样，都在方法中定义的，其有效范围只限于方法内部。

在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中的变量和方法却只能在创建该局部内部类的方法中进行访问。

public class Outer {

    private int count = 0;

    public void show() {

        class Inner {
            
            public void showOuter() {
                System.out.println("count=" + count);
            }
        }

        Inner inner = new Inner();
        inner.showOuter();
    }
    
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

静态内部类

所谓静态内部类，就是成员内部类被static所修饰。

静态内部类在成员内部类前添加了static关键字。在功能上，静态内部类中只能访问外部类的静态成员，同时通过外部类访问静态内部类成员时，可以跳过外部类从而直接通过内部类访问静态内部类成员。

public class Outer {

    final static String AUTHOR = "ijunfu";

    static class Inner {

        void showOuter() {
            System.out.println(AUTHOR);
        }
    }

    public static void main(String[] args) {
        new Inner().showOuter();
    }
}

匿名内部类

匿名内部类其实就是没有名称的内部类。

在调用包含有接口类型参数的方法时，通常为了简化代码，可以直接通过匿名内部类的形式传入一个接口类型参数，在匿名内部类中直接完成方法的实现。

public class Outer {

    public void eat(Animal animal) {
        System.out.println("outer");
        animal.eat();
    }

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

        // 使用接口
        Cat cat = new Cat();
        outer.eat(cat);

        // 使用匿名内部类
        outer.eat(new Animal() {
            @Override
            public void eat() {
                System.out.println("我最喜欢吃草");
            }
        });
    }
}

interface Animal {
    void eat();
}

class Cat implements Animal {

    @Override
    public void eat() {
        System.out.println("我最喜欢吃鱼了");
    }
}

注意：从JDK 8开始，运行在局部内部类、匿名内部类中访问非final修饰的局部变量。而在之前，局部变量前必须加final修饰，否则程序编译报错。