在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。
主要参考博客（这个博主写的非常好，深入理解内部类部分未拜读）

成员内部类

成员内部类是最普通的内部类，成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括 private 成员和静态成员）。
它的定义为位于另一个类的内部，形如下面的形式：

class Circle {
    private double radius = 0;
    public Circle(double radius) {
        this.radius = radius;
        Draw draw = new Draw();
        draw.drawRadius();
    }
    // 该类像是类 Circle 的一个成员，Circle 称为外部类
    class Draw {
        public void drawRadius() {
            // 外部类的 private 成员
            System.out.println(radius);
            System.out.println(Circle.this.radius);
        }
    }
}

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，但是外部类想访问成员内部类的成员却不是这么随心所欲了。
在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问，代码示例如上。

成员内部类是依附外部类而存在的，也就是说：如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

public class Test {
    public static void main(String[] args)  {
        // 第一种方式：通过Outter对象来创建
        Outter outter = new Outter();
        Outter.Inner inner0 = outter.new Inner();
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
class Outter {
    private Inner inner = null;
    public Outter() {
    }
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
    class Inner {
        public Inner() {
        }
    }
}

内部类可以拥有四种访问权限，而外部类智能被 public 修饰和默认访问权限。
上面示例中，成员内部类 Inner，
如果用 private 修饰，则只能在外部类的内部访问。
如果用 public 修饰，则任何地方都能访问。
如果用 protected 修饰，则只能在同一个包下或者继承外部类的情况下访问。
如果是默认访问权限，则只能在同一个包下访问。
成员内部类中不可以包含任何静态成分，否则会造成内外部类初始化问题（报错）。

成员内部类的继承问题。
一般来说，内部类是很少用来作为基类用的。但是当用来继承的话，要注意两点：

成员内部类的引用方式必须为 Outter.Inner
构造器中必须有指向外部类对象的引用，并通过这个引用调用 super()。这段代码摘自《Java编程思想》
```
class WithInner {
  class Inner{
  }
}
class InheritInner extends WithInner.Inner {
  // InheritInner() 是不能通过编译的，一定要加上形参
  InheritInner(WithInner wi) {
      // 必须有这句调用
      wi.super(); 
  }
  public static void main(String[] args) {
      WithInner wi = new WithInner();
      InheritInner obj = new InheritInner(wi);
  }
}
```
静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个 static 关键字。
静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非 static 成员，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非 static 成员必须依附于具体的对象。 ```java public class Test { public static void main(String[] args) {
```
  Outter.Inner inner = new Outter.Inner();
```
} }

class Outter { public Outter() {

}
static class Inner {
    public Inner() {
    }
}

}

<a name="tJZim"></a>
# 局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于：局部内部类的访问仅限于方法内或者该作用域内。<br />局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。
```java
class People{
    public People() {
    }
}
class Man{
    public Man(){
    }
    public People getWoman(){
        // 局部内部类
        class Woman extends People{
            int age =0;
        }
        return new Woman();
    }
}

匿名内部类

匿名内部类可以使代码更简洁，可以在定义一个类的同时对其进行实例化。
使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。
它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类。
匿名内部类是唯一一种没有构造器的类。
正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。
匿名内部类在编译的时候由系统自动起名为 name$1.class ，name 为匿名内部类所在类的类名。

官方文档
官网文档中的示例：

public class HelloWorldAnonymousClasses {
    /**
     * 包含两个方法的 HelloWorld 接口
     */
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }
    public void sayHello() {
        // 局部内部类 EnglishGreeting 实现了 HelloWorld 接口
        // 可以其他的 Greeting 比如：frenchGreeting、SpanishGreeting
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            @Override
            public void greet() {
                greetSomeone("world");
            }
            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }
        HelloWorld englishGreeting = new EnglishGreeting();
        // 2、匿名类实现HelloWorld接口
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            @Override
            public void greet() {
                greetSomeone("tout le monde");
            }
            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };
        englishGreeting.greet();
        englishGreeting.greetSomeone("Fred");
    }
    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}

匿名内部类可以访问外部类的所有成员（匿名内部类写在类内部，作为成员时可以。写在方法内部不可以）
匿名内部类不能访问外部类未加 final 修饰的变量（JDK1.8 即使没有用 final 修饰也可以访问）
匿名内部类中不可以定义静态属性、方法
匿名内部类中可以有常量属性（static final 修饰的属性）
匿名内部内中可以定义属性
匿名内部内中可以可以有额外的方法（父接口、类中没有的方法）
匿名内部内中可以定义内部类
匿名内部内中可以对其他类进行实例化

public class ShadowTest {
    public int x = 0;
    interface FirstLevel {
        void methodInFirstLevel(int x);
    }
    FirstLevel firstLevel =  new FirstLevel() {
        public int x = 1;
        public static final String finalStr = "Hello World";
        @Override
        public void methodInFirstLevel(int x) {
            System.out.println("x = " + x);
            System.out.println("this.x = " + this.x);
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
        }
    };
    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.firstLevel;
        fl.methodInFirstLevel(23);
    }
}

内部类的好处

每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个接口的实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整。
方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
方便编写事件驱动程序 (Android 开发)。
方便编写线程代码。

Java基础

Java 的内部类

成员内部类

静态内部类

匿名内部类

内部类的好处