1.   成员内部类Member Inner Class

在一个类中使用内部类，可以在内部类中直接存取其所在类的任何成员变量和方法。

在外部类里面创建成员内部类的实例：

this.new Innerclass();或者new InnerClass();

在外部类之外创建内部类的实例：

(new Outerclass()).new Innerclass();

在内部类里访问外部类的成员：

Outerclass.this.member

2.   静态内部类Static Inner Class

静态内部类只能使用外部类的静态成员和方法，而不能使用非静态成员和方法。

在外部类里面创建成员内部类的实例：

new Innerclass();

在外部类之外创建内部类的实例：

new Outerclass. Innerclass();

3.   局部内部类Local Inner Class

局部内部类在方法里面，跟局部变量一样，不能有public，protected，private等关键词修饰，它不能访问外部类中的成员变量和方法，只能访问其所在方法里面的final变量。

4.   匿名内部类Anonymous Inner Class

匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。

匿名内部类隐式地继承了一个父类或者实现了一个接口。

匿名内部类使用得比较多，通常是作为一个方法参数。

OuterClass:

package javase.innerclass;

public class OuterClass {

   static int x=0;

   int y=0;

   public class MemberInnerClass{

      private int y=0;

      MemberInnerClass(){

        y=5;

      }

      public void fun(){

        System.out.println("fun function from member inner class");

        //调用内部类中的方法，如果内部类不存在此方法。

        //而外部类中存在，则调用的是外部类中的方法。

        printY(10);

        //调用外部类中的方法

        OuterClass.this.printY();

      }

      public void printY(int y){

        System.out.println("printY function from member inner class");

        //输出通过参数传进来的y

        System.out.println("函数参数y="+y);

        //输出内部类中的属性y

        System.out.println("内部类中属性y="+this.y);

        //输出外部类中的属性y

        System.out.println("外部类中属性y="+OuterClass.this.y);

      }

   }

   public void printY(){

      System.out.println("printY function from outter class");

      //在外部类里面新建成员内部类的实例,也可以这样写：

       //MemberInnerClass innerClass=new MemberInnerClass();

      MemberInnerClass innerClass=this.new MemberInnerClass();

      //在外部类里面新建静态内部类的实例

      StaticInnerClass staticClass=new StaticInnerClass();

      //输出成员内部类中的成员变量

      System.out.println("成员内部类属性y="+innerClass.y);

      //输出外部内中的成员变量

      System.out.println("外部类属性y="+y);

      //输出静态内部类中的成员变量

      System.out.println("静态内部类属性x="+staticClass.x);

   }

   public static class StaticInnerClass{

      private int x=10;

      public void printX(){

        System.out.println("printX function from static inner class");

        //输出内部类中的变量

        System.out.println("静态内部类属性x="+x);

        //只能调用外部类的静态成员和方法

        System.out.println("外部类属性x="+OuterClass.x);

      }

   }

   public void testLocalInnerClass(){

      final int k=1;

      //局部内部类

      class LocalInnerClass{

        public void printK(){

           System.out.println("printK function from local inner class");

           //只能访问方法中的final变量

           System.out.println("局部内部类所在的方法中的变量k="+k);

        }

      }

      LocalInnerClass localClass=new LocalInnerClass();

      localClass.printK();

   }

}

TestOuterClass:

package javase.innerclass;

import java.util.Date;

public class TestOuterClass {

   public static void main(String args[]){

      OuterClass out=new OuterClass();

      System.out.println("=====成员内部类==========");

      //在外部类外实例化局部内部类对象

      OuterClass.MemberInnerClass in= out.new MemberInnerClass();

      in.fun();

      System.out.println("=====静态内部类==========");

      //在外部类外实例化静态内部类对象

      OuterClass.StaticInnerClass staticInnerClass=new OuterClass.StaticInnerClass();

      staticInnerClass.printX();

      System.out.println("=====局部内部类==========");

      //局部内部类

      out.testLocalInnerClass();

      System.out.println("=====匿名内部类==========");

      //匿名内部类,相当于继承Date类，并且重写了toString方法

      System.out.println(new Date(){

        private static final long serialVersionUID = 1L;

        @Override

        public String toString(){

           return "hello "+super.toString();

        }

      }.toString());

   }

}