所谓内部类，即定义在另一个类中的类。那么，为什么会有内部类这个概念，他的使用场景又是什么呢？首先，来看一下内部类的特点：
1. 它体现了一种代码的隐藏机制和访问控制机制，内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类，所以没有必要专门用一个Java文件存放这个类。

    public class Outer {
　　private int num; 
　　private class Inner {
　　　　private int num;
　　}
}

一般的类是不允许用private修饰符的，但是内部类却可以，该实例中，类Inner只对Outer可见，其他的类无法访问的到Inner类。


注意，这里有个例外，如果内部类的访问修饰符被设定为public，那么它是可以被其他类使用的，但是必须经由外部类来实例化内部类。

   public class Outer {
   private int num = 1;

   public class Inner {
       private int num = 2;
   }

   public static void main(String[] args) {
       Outer outer = new Outer();
       Inner inner = outer.new Inner();
       System.out.println(inner.num);
   }
}

2. 它包含有一个对外部类的this指针，从而可以访问外部类的所有元素，包括所有public/private的成员和方法:

    public class Outer {
    private int num = 1;

    public class Inner {
        private int num = 2;
        private void func () {
            System.out.println(Outer.this.num);
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.func();
    }
}

3. 另一方面，反向的，外部类对内部类的所有元素也都有访问权，包括内部类的私有成员和方法：

    public class Outer {
    private int num = 1;

    public class Inner {
        private int num = 2;
    }

    public void func () {
        Inner inner = new Inner();
        System.out.println(inner.num);
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.func();    // 2
    }
}

分类：

一、成员内部类

当某个类除了他的外部类，不会被其他类使用时，使用成员内部类。这种情况下，内部类依附于外部类而存在，原因可能有： 1. 不可能有其他类使用该内部类。 2. 该内部类不能被其他类使用，可能会导致错误。这是内部类使用比较多的一个场景。
1) 外部类可以直接访问内部类的成员和方法，但是必须先创建一个内部类的对象，再通过该对象使用其成员和方法。
2) 内部类可以访问外部类的成员和方法，但是要注意，当内部类拥有和外部类相同的成员或方法时，会发生隐藏现象，默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式访问：外部类.this.成员变量/方法
3) 内部类只是一个编译时的概念，一旦编译成功，就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为Inner的内部类，编译完后会生成Outer.class和Outer$Inner.class两个类
4) 成员内部类与普通的成员没什么区别，可以与普通成员一样进行修饰和限制

    public class Outer {
    private int num = 1;
    private int num1 = 10;

    public class Inner {
        private int num = 2;
        public void func () {
            System.out.println(Outer.this.num);
            System.out.println(num1);
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.func();
    }
}

二、局部内部类

 局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。局部内部类就像方法里面的局部变量一样，是不能有public、protected、private及static修饰符的。

  public class Outer {
  private int num = 1;
  private int num1 = 10;

  public void func () {
      class Inner {
          private int num = 2;
      }
      Inner inner = new Inner();
      System.out.println(inner.num);
  }


  public static void main(String[] args) {
      Outer outer = new Outer();
      outer.func();
  }
}

三、静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，它不持有指向外部类对象的引用this，并且它不能使用外部类的非static成员或方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体对象。它唯一的作用就是随着类的加载（而不是随着对象的产生）而产生。

    public class Outer {

    static class Inner {
        public Inner () {

        }
    }

    public static void main(String[] args) {
        Outer.Inner innner = new Outer.Inner();
    }
}

四、匿名内部类

匿名内部类应该是平时我们编写代码时用的最多的，在编写事件监听的代码时匿名内部类不但方便，而且使代码更加容易维护。匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outer$1.class。一般来说，匿名内部类用于集成其他类或者实现接口，并不需要增加额外的方法，只是对集成方法的实现或是重写。

   public class Outer {

   public void func () {
       System.out.println("1");
   }


   public static void main(String[] args) {
       Outer inner = new Outer() {
           public void func () {
               System.out.println("2");
           }
       };
       inner.func();
   }
}

总结：
1. 每个内部类都能独立的集成一个接口的实现，所以无论外部类是否已经集成了某个（接口）实现，对于内部类都没有影响。内部类使得多重集成的解决方案变得完整。
2. 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
3. 方便编写时间驱动程序。
4. 方便编写线程代码。

转载至：cnblogs.com/firefrost/p/5064210.html

参考：http://blog.csdn.net/historyasamirror/article/details/6049073

使用场景：

1..达到一个多重继承的效果.
说明：内部类和外部类的关系：内部类(除去用static修饰的)可以直接使用其外部类的成员变量以及成员函数，达到一个继承的效果，再加上自身继承基类来达到一个多重继承的效果.如下代码。

public class OuterClass {
    //内部类
    class InnerClass extends CommonClass{

        public void enhanceMethod1(){
             System.out.println("before");
             super.method1();//调用父类commonClass的函数
             method();//调用外部类outerClass的函数
             System.out.println("after");
        };
    }
 /***********************************************************************/   
    public void  method(){
        System.out.println("method函数");
    }
}

2.访问控制，只能通过其外部类来调用

//1.在其他类中 **需要**  通过outerCLass来创建和调用内部类innerClass
 InnerClass innerClass = new OuterClass().new InnerClass();

3.事件驱动
直接参考参考：http://blog.csdn.net/historyasamirror/article/details/6049073
一文中最后的代码。

java中的内部类

java内部类分为：成员内部类、静态内部类、局部内部类、匿名内部类。

使用场景：

• 成员内部类：不想被其他类公开使用的类，因为外部类只能定义为public或者缺省。类是属于对象的，所以不能有静态属性
• 静态内部类：一个类与另一个类关联性比较强，但是又可以不依赖外部类而独立存在。比如HashMap与Node。静态内部类是属于类的，跟普通类使用没什么区别。
• 局部内部类：局部内部类访问方法中定义的final类型的局部变量，局部类完全对外部隐藏，比较少用
• 匿名内部类：适用于快速构造对象，lambda表达式等场景

成员内部类

• 内部类的对象总有一个隐式引用，它指向创建它的外部类的对象，编译器修改了所有的内部类的构造器，添加了一个外围类引用的参数OuterClass.this

• 内部类构造器：A.B = new A().newB()

• 内部类不允许有static变量（static final除外）和方法

• 内部类拥有访问特权，可以访问外围类的私有域

// 只能public或缺省修饰
public class Outer {

    private static String name;

    private String key;

    private String getKey() {
        return key;
    }

    // public、private、protected或缺省修饰
    private class Inner {
        // static变量必须为常量
        private static final int LEN = 1;

        // 不能有static方法
        private void inner() {
            // 可以直接访问外部类的所有属性与方法
            System.out.println(key);
            // 外部类的static属性也可以访问
            System.out.println(name);
        }

    }
}

静态内部类

• 静态内部类没有外围类对象的引用特权
• 静态内部类可以有静态域和方法
• 声明在接口中的内部类自动成为public static类

public class Outer {

    private String key;

    static class Inner{
        // 可以有static属性
        private static int len = 1;

        // 可以有static方法
        private static void inner() {
            // 不能访问外部类属性key
            System.out.println(len);
        }
    }

}

局部内部类

• 局部类不能用public或private声明，作用域被限定在声明这个局部类的块中
• 不能有static方法和属性（static final除外）
• 只能访问局部的final变量

public class Outer {
    public static void main(String[] args) {
        final Object a = new Object() ;
        Object b = new Object();
        class Inner{
            // 不能有static与属性
            private void test() {
                // 只能访问final对象a
                System.out.println(a);
            }
        }
        // b重新赋值，否则可能会将b优化为final
        b = new Object();
    }
}

匿名内部类

• 匿名类不能有构造器，将构造器参数传递给超类的构造器
• 匿名类的equals方法无法判断:if (getClass() != other.getClass()) return false;
• “双括号初始化”
• 匿名内部类类名为OutClass$数字

invite(new ArrayList<String>() { {add("Harry"); add("Tony"); } } )