内部类根据使用不同的修饰符或者定位的位置不同，可以分为四种：
① 实例内部类： 内部类没有使用static修饰
② 静态内部类： 内部类使用了static修饰
③ 局部内部类： 在方法中定义的内部类
④ 匿名内部类： 适合于仅使用一次的类，属于局部内部类的特殊情况
外部类的访问修饰符：要么用public，要么缺省。
内部类看作是外部类的一个成员，好比字段，那么内部类可以使用public/缺省/protected/private修饰
还可以是static修饰
------------------------------------------------------------------------------
实例内部类：
没有使用static修饰内部类，说明内部类属于外部类的对象，而不是属于外部类。
特点：
1：创建实例内部类前，必须存在外部类对象，通过外部类对象创建内部类对象（当存在内部类对象时，一定存在外部类对象）
1 public class InstanceClass {
2
3 //创建一个内部类对象
4 Outter.Inner inner = new Outter().new Inner();//方法一
5 //创建一个内部类对象
6 Outter outter = new Outter();
7 Outter.Inner inner2 = outter.new Inner();//方法二
8 }
2：实例内部类可以直接访问外部类成员
class Outter{
String name = "amos";
class Inner{
public void getOutterName(){
System.out.println(name);
}
}
}
3.外部类必须通过内部类的实例去访问内部类的成员
class Outter{
public void getAge() {
System.out.println(new Outter().new Inner().age);
}
class Inner{
String name = "wong";
}}
4.如果实例内部类和外部类存在同名的字段或方法abc，那么在内部类中
this.abc表示访问内部类成员
外部类.this.abc:表示访问外部类成员
class Outter{
String name = "Outter";
class Inner{
String name = "Inner";
public void getName() {
String name = "local";
System.out.println(name);//local
System.out.println(this.name);//Inner
System.out.println(Inner.this.name);//Outter
}
}
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------
静态内部类：
使用static修饰的内部类
特点：
1.在创建静态内部类的实例时，不必创建外部类的实例
Outter.Inner inner = new Outter.Inner();
2.静态内部类可以直接访问外部类的静态成员
package innerSubclassTest;
class Outter{
static String name = "Outter";
static class Inner{
public void getOutterName() {
System.out.println(name);//直接访问外部类静态变量name
}
}
}
必须通过外部类的实例去访问外部类的实例成员。
class Outter{
int age = 18;
static class Inner{
public void getAge() {
System.out.println(new Outter().age);
}
}
}
3.在静态内部类中可以定义静态成员和实例成员
4.测试类可以通过完整的类名直接访问静态内部类的静态成员。
package innerSubclassTest;
class Outter{
static class Inner{
static int age = 18;
}
}
public class StaticInnerClass {
public static void main(String[] args) {
System.out.println(Outter.Inner.age2);//一静到底
}
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------
局部内部类：（★不用）
在方法中定义的内部类，其可见范围是当前方法，和局部变量一个级别。
1):不能使用public、private、protected、static修饰符
2):局部内部类只能在当前方法中使用
3):局部内部类和实例内部类一样，不能包含静态成员
4):局部内部类和实例内部类，可以访问外部类的所有成员
5):局部内部类访问的局部变量必须使用final修饰（在Java8中是自动隐式加上final，但是依然是常量，不能改变值）
6):★★局部内部类只能访问final修饰的局部变量
原因如下：局部变量存储在栈帧中，随着方法调用的结束，栈帧被销毁，那么局部变量也就不存在了。但是局部内部类的对象存储在堆中，方法调用结束后仍然存在，那么对于局部变量的引用依然存在，这会导致局部内部类的对象引用一个不存在的局部变量，内存会泄露。如果使用final修饰局部变量，那么局部变量会一直存在于堆中，不会导致内存泄露。
-----------------------------------------------------------------------------------------------------------------------------------------------------------
匿名内部类：只能访问final修饰的局部变量。
匿名内部类（Anonymous）,是一个没有名称的局部内部类，适合只使用一次的类
在开发中经常有这样的类，只需要定义一次，使用一次就可以丢弃了；此时：不应该白白定义在一个文件中。
在JavaSE/Android的事件处理中:不同的按钮点击之后，应该有不同的响应操作，首先使用匿名内部类。
特点：
1):匿名内部类本身没有构造器，但是会调用父类构造器。
2):匿名内部类尽管没有构造器，但是可以在匿名类中提供一段实例初始化代码块，JVM在调用父类构造器后，会执行该段代码。
3):内部类除了可以继承类之外，还可以实现接口。
格式：
new 父类构造器（实参列表）或接口（）{
//匿名内部类的实体部分
}
注意：匿名内部类必须继承一个父类或者实现一个接口，但最多只能继承一个父类或者实现一个接口。
举个栗子：
public abstract class Bird {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract int fly();
}
public class Test {
public void test(Bird bird){
System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
}
public static void main(String[] args) {
Test test = new Test();
test.test(new Bird() {
public int fly() {
return 10000;
}
public String getName() {
return "大雁";
}
});
}
}
------------------
Output：
大雁能够飞 10000米
在Test类中，test()方法接受一个Bird类型的参数，同时我们知道一个抽象类是没有办法直接new的，我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。
由于匿名内部类不能是抽象类，所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。
关于内部类更详尽的剖析：http://www.cnblogs.com/chenssy/p/3390871.html
本文参考自：http://www.cnblogs.com/chenssy/p/3390871.html
扣丁狼教育任小龙老师的课程Java基础完整版
来源：https://www.cnblogs.com/AmosWong/p/9495389.html