1 内部类定义
    简单的说，将一个类的定义放在另一个类的定义内部，这就是内部类，嵌套内部类的叫做外围类，下面的代码片段定义了一个内部类：

    1. public class Outer {
    2.     /**
    3.      * 内部类
    4.      */
    5.     class Inner {
    6.         private int j;
    7.         public int get() {
    8.             return this.j;
    9.         }
    10.     }
    11.     /**
    12.      * 外部类方法
    13.      */
    14.     public void operation() {
    15.         Inner in = new Inner();
    16.         System.out.println(in.get());
    17.     }
    18. /**
    19.      * 获取内部类
    20.      * @return
    21.      */
    22.     public Inner getInner(){
    23.         return new Inner();
    24.     }
    25.     public static void main(String[] args) {
    26.         Outer out = new Outer();
    27.         out.operation();
    28.     }
    29. }

    在外围类的方法中，我们可以像调用普通类那样去调用内部类，而在内部类中，我们可以调用外部类中的属性和方法（包括私有属性和私有方法），就像调用类本身的属性和方法，如果要在外部类之外的方法中创建内部类对象，则需要使用下面的方法：

    1. Outer out = new Outer();
    2.     Outer.Inner in = out.getInner();

    当然也可以使用下下面的方法实例化内部类：

    1. Outer out = new Outer();
    2. Outer.Inner in = out.new Inner();

    如果内部类有与外部类同名的域或者方法，可以用外部类名.this来访问外部成员，例如下面这个例子：

    1. class A {
    2.     private int s = 10;
    3.     public class B {
    4.         private int s = 20;
    5.         public void mb(int s) {
    6.             System.out.println(s);//30
    7.             System.out.println(this.s);//20
    8.             System.out.println(A.this.s);//10
    9.         }
    10.     }
    11. }
    12. public class TestInner {
    13.     public static void main(String[] args) {
    14.         A a = new A();
    15.         A.B b = a.new B();
    16.         b.mb(30);
    17.     }
    18. }

    内部类与类中的域、方法一样是外部类的成员，它的前面有访问修饰符和其它修饰符。内部类可用的修饰符比外部类的修饰符更多，外部类的修饰符包括public和默认的包访问权限，而内部类除了能使用外部类的修饰符之外，还能使用诸如protected、private和static等修饰符。

    内部类在使用static修饰符时需要遵循以下规则：

    • 实例化static内部类时，在new前面不需要使用外围类对象变量；
    • static内部类中不能访问其外部类的非static的域及方法，既只能够访问static成员；
    • static方法中不能访问非static的域及方法，也不能够不带前缀地new一个非static的内部类