内部类

可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类

public class Demo{
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.dostuff();
    }
}
class Outer{
    private int size = 2;
    class Inner{
        public void dostuff() {
            size++;
            System.out.println(size);
        }
    }
}

• 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
• 成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
局部类有几个重要特性：

• 仅在定义了它们的代码块中是可见的；
• 可以使用定义它们的代码块中的任何局部 final 变量(java8支持非final)；
• 局部类不可以是 static 的，里边也不能定义 static 成员；
• 局部类不可以用 public、private、protected 修饰，只能使用缺省的；
• 局部类可以是 abstract 的。

public class Outer {
    public static final int TOTAL_NUMBER = 5;
    public int id = 123;
    public void func() {
        final int age = 15;
        String str = "http://www.baidu.com";
        class Inner {
            public void innerTest() {
                System.out.println(TOTAL_NUMBER);
                System.out.println(id);
                System.out.println(str);  // java8支持
                System.out.println(age);
            }
        }
        new Inner().innerTest();
    }
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.func();
    }
}

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

class Outter {
    int a = 10;
    static int b = 20;

    static class Inner {
        public void func(){
            // System.out.println(a); 报错
            System.out.println(b);
        }
    }
}

public class Demo {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
        inner.func();
    }
}

匿名内部类

匿名内部类是局部内部类的一种特殊形式，也就是没有变量名指向这个类的实例，而且具体的类实现会写在这个内部类里面。

注意：匿名类必须继承一个父类或实现一个接口。

不使用匿名内部类来实现抽象方法：

abstract class Person {
    public abstract void eat();
}
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

运行结果：
eat something

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用。但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类。使用匿名内部类实现：

abstract class Person {
    public abstract void eat();
}
public class Demo {
    public static void main(String[] args){
       
        // 继承 Person 类
        new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        }.eat();
    }
}

可以看到，匿名类继承了 Person 类并在大括号中实现了抽象类的方法。

参考

Java内部类详解
Java静态内部类、匿名内部类、成员式内部类和局部内部类