1 内部类分类

1.1 成员内部类

成员内部类像是外部类一个成员。成员内部类可以无条件地访问外部类的所有成员属性和成员方法（包含private属性和静态成员）。当成员内部类的属性与方法和外部类的属性与方法名一样时，会发生隐藏现象，默认访问的是成员内部类的属性与方法。

• 成员内部类可以由private、public、protected修饰。如果由private修饰，则只能在外部类内部使用；若由public修饰，则可以在任何地方访问。
• 成员内部类依附于外部类存在，因此如果需要创建内部类对象，必须先有一个外部类的对象存在。

InnerClass innerClass = outerClass.new InnerClass();

1.2 静态内部类

关键字static修饰的内部类，不需要依赖于外部类，可以直接创建。

OuterClass.InnerClass inner = new OuterClass.InnerClass();

不能直接访问外部类的非static成员变量或方法。

new OuterClass.成员;

在没有外部类的对象下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。静态内部类不持有指向外部类对象的引用的。

1.3 局部内部类

局部内部类定义和访问限于同一个方法内或一个作用域里的类。

class Test
{
  public void test()
  {
    class Man
    {
      public void eat()
      {
        System.out.println("eat something");
      } 
    }
    Man man = new Man();
    man.eat();
  }
}

局部内部类像是方法中的局部变量一样，不能有private、public、protected或static修饰。

1.4 匿名内部类

匿名内部类没有构造方法，大部分用于接口回调；不能使用权限、static、final、abstract修饰；只能创建一个内部类实例。继承一个父类或实现一个接口，不需要增加额外的方法，只是对方法的实现或重写。

abstract class Person
{
   public abstract void eat();
}

public class Demo
{
  public static void main(String[] args)
  {
//若不使用匿名内部类，需要先有类继承Person然后实现eat()方法
    Person person = new Person()
    {
      public void eat()
      {
        System.out.println("eat something");
      }
    }
  }
}

在接口上使用匿名内部类，一次性使用。

public interfafe OnClickListener
{
   void onClick(View v);
}

class LaunchActivity extends Activity
{
  public Button button;

  @Override
  protected void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_lanuch);
    Button button = (Button) findViewById(R.id.launchButton);
    button.setOnClickListener(new OnClickListener)  
    {
      @Override
      public void onClick(View v)
      {
        ...  
      }
    }  
  }
}

类似的有Runnable接口。

2 内部类的使用

2.1 内部类与外部类访问

内部类可以无条件调用外部类的方法，如果内部类有同名方法必须使用OuterClass.this.MethodName()方式调用(this表示对外部类的引用)，否则默认访问内部类中的方法；若是无同名情况可以直接调用。

public class OuterClass
{
   private void outerMethod()
  {
    System.out.println("outer");  
  }

  public static void main(String[] args)
  {  
    OuterClass outerClass = new OuterClass();
    OuterClass.InnerClass innerClass 
                    = outerClass.new InnerClass();
    innerClass.innerMethod();
  }

  class InnerClass
  {
    public void innerMethod()
    {
      OuterClass.this.outerMethod();  //输出outer
      outerMethod();  //输出inner
    } 

    public void outerMethod()
    { 
       System.out.println("inner"); 
    }
  }
}

• JDK 1.8以前，内部类只能访问外部类中被声明为final的变量。因为生命周期可能不一样。
• 不可以在static方法中直接new内部类，否则会出现错误，因为静态方法是在类实例化之前就可以使用的。除非将内部类也声明为静态。

2.2 匿名内部类方法调用

public class Test
{
  public static void main(String[] args)
  {  
    Person per = new Person()
    {
      public void say()
      {  
        System.out.println("say"); 
      }
      @Override
      public void speak()
      {
        System.out.println("speak"); 
      }
    }
    per.speak(); //speak
    per.say(); //无法调用
  }
}

interface Person
{
  public void speak();
}

per.say() 无法调用，因为Person per = new Person()创建的是Person对象，而非匿名内部类对象，只有继承父类和实现的方法可以调用。

public class Test
{
  public static void main(String[] args)
  {  
    new Person()
    {
      public void say()
      {  
        System.out.println("say"); 
      }
      @Override
      public void speak()
      {
        System.out.println("speak"); 
      }
    }.say();  //直接调用匿名内部类的方法
  }
}

interface Person
{
  public void speak();
}