纯粹是个人学习总结，如有不对的地方请吐槽。

内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。
　　(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
　　(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
　　(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

1. 成员内部类

成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。
要注意的是，成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的

2. 局部内部类

局部内部类可以定义在方法内，也可以定义再作用域内。
局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

方法内：

public Destination destination(String s) {
    class PDestination implements Destination {
        private String label;

        private PDestination(String whereTo) {
            label = whereTo;
        }

        public String readLabel() {
            return label;
        }
    }
    return new PDestination(s);
}

作用域内：

private void internalTracking(boolean b) {
    if (b) {
        class TrackingSlip {
            private String id;
            TrackingSlip(String s) {
                id = s;
            }
            String getSlip() {
                return id;
            }
        }
        TrackingSlip ts = new TrackingSlip("slip");
        String s = ts.getSlip();
    }
}

3. 嵌套内部类

嵌套内部类，就是修饰为static的内部类。声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。
嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为private，一般声明为public，方便调用。

4. 匿名内部类

有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。
例如：

((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() {
    @Override
    public void onClick(View v) {
        new Thread() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
            }

        }.start();
    }
});

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的
当所在的方法的形参需要被内部类里面使用时，该形参必须为final。

5.内部类的继承

内部类的继承，是指内部类被继承，普通类 extents 内部类。而这时候代码上要有点特别处理
例如：

public 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);
    }
}

class WithInner {
    class Inner {
    }
}

可以看到子类的构造函数里面要使用父类的外部类对象.super();而这个对象需要从外面创建并传给形参。

由于时间比较久了，是最近才想把总结的已到简书上，所以吧原文地址给忘了