内部类又称嵌套类。内部类是指在外部类的内部再定义一个类，内部类可以是静态的，也可以用public、default、protected和private修饰。

内部类划分

• 静态内部类
  静态内部类不能访问外部类的非静态成员变量
• 非静态内部类
  非静态内部类能访问外部类的一切成员，包括私有成员。外部类不能直接访问内部类的成员，但可以通过内部类的实例访问内部类的私有成员。
  • 成员内部类
    成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的。
    成员内部类不能有static修饰的成员，但是却允许定义常量。

public class OuterClass {
    private String name;

    static class StaticInerCls{
        private String name;
    }

    class InerCls{
        private String name;
        private static int id;    //不允许，会报错
        private static final int TYPE = 0;   //允许
    }
}

• 局部内部类
  指内部类定义在方法体内，只能在该方法或条件的作用域内才能使用，退出这作用域就无法引用。
  局部类不仅可以访问外部类的所有成员，还可以访问方法体的局部变量，但必须是final修饰的局部变量。
  为什么要final呢？这是作用域的问题。在方法执行结束后，局部变量就被销毁了，而在方法中new的局部内部类，还会持有方法的引用。这样就导致外部对象可能访问了一个不存在的变量，因此需要用final进行修饰。
  而final进行修饰过的局部变量，在局部内部类中使用，实际上是对该局部变量进行了copy，将其拷贝到局部内部类中，后续使用持续维护这个对象在生命周期内，所以可以继续访问。
• 匿名内部类
  为了免去给内部类命名，或者只想使用一次，就可以选择使用匿名内部类。

内部类的四大作用

• 可以很好的实现隐藏
  一般非内部类是没有private、protected权限，而内部类有，因此可以将一些实现进行隐藏。
• 内部类拥有外部类所有元素的访问权限（包括private）
  静态内部类只能访问外部类的静态元素。
• 间接的实现了外部类的多继承
  Java只能单继承，但是可以实现多个接口。但是使用接口有时会有诸多不便，比如实现一个接口就必须实现它里面所有的方法，否则类必须声明为抽象类。
  而内部类可以通过让多个内部类分别继承多个其他类，使外部类可以同时获取多个其他类的属性，从而间接的实现多继承。

public interface Contents {  
    int value();  
}  
public interface Destination {  
    String readLabel();  
}  
public class Goods {  
    // 内部类
    private class Content implements Contents {  
        private int i = 11;  
        public int value() {  
            return i;  
        }  
    }  
    // 内部类
    protected class GDestination implements Destination {  
        private String label;  
        private GDestination(String whereTo) {  
            label = whereTo;  
        }  
        public String readLabel() {  
            return label;  
        }  
    }  
    public Destination dest(String s) {  
        return new GDestination(s);  
    }  
    public Contents cont() {  
        return new Content();  
    }  
}  
class TestGoods {  
    public static void main(String[] args) {  
        Goods p = new Goods();  
        // 间接实现类的多继承，
        Contents c = p.cont();  
        Destination d = p.dest("Beijing");  
    }  
} 

• 可以避免修改接口而实现同一个类中两种同名方法的调用
  假设一个类继承一个类，同时还实现了一个接口。此时如果继承的类和接口有两个同名的方法怎么办？
  因此，可以使用内部类来实现接口，就可以让外部类有效的避免该问题。

// 接口
public interface Incrementable{
  void increment();
}
// 类
public class MyIncrement {
    public void increment(){
      System.out.println("Other increment()");
    }
    static void f(MyIncrement f){
        f.increment();
    }
}
// 继承类和接口
public class Callee2 extends MyIncrement implements Incrementable{
  public void increment(){
        //代码
        // 此时就无法区分这个方法是属于覆盖MyIncrement这里的方法呢？
        // 还是Incrementable这里的方法
  }
}

// ********************内部类继承接口来解决***********
public class Callee2 extends MyIncrement{
  private int i=0;
  private void incr() {
        i++;
        System.out.println(i);
  }
  private class Closure implements Incrementable {
       public void increment(){
         incr();
       }
  }
  Incrementable getCallbackReference() {
       return new Closure();
  }
}