http://www.iteye.com/topic/1074555

一、 定義
放在一個類的內部的類我們就叫內部類。
二、 作用
1.內部類可以很好的實現隱藏
  一般的非內部類，是不允許有 private 與protected權限的，但內部類可以
2．內部類擁有外圍類的所有元素的訪問權限
3.可是實現多重繼承
4.可以避免修改接口而實現同一個類中兩種同名方法的調用。
三、   例子
1.實現隱藏
   平時我們對類的訪問權限，都是通過類前面的訪問修飾符來限制的，一般的非內部類，是不允許有 private 與protected權限的，但內部類可以，所以我們能通過內部類來隱藏我們的信息。可以看下面的例子
接口
package insidecategory;

public interface Incrementable
{
  void increment();
}
具體類
package insidecategory;

public class Example {

    private class InsideClass implements InterfaceTest
    {
         public void test()
         {
             System.out.println("這是一個測試");
         }
    }
    public InterfaceTest getIn()
    {
        return new InsideClass();
    }
}
上面加粗的部分是內部類，訪問修飾符是private
客戶端程序
package insidecategory;

public class TestExample {

  public static void main(String args[])
  {
    Example a=new Example();
    InterfaceTest a1=a.getIn();
    a1.test();
  }
}
加粗的那部分就是客戶端調用的代碼，從這段代碼裏面我只知道Example的
getIn()方法能返回一個InterfaceTest 實例但我並不知道這個實例是這麼實現的。而且由於InsideClass 是private的，所以我們如果不看代碼的話根本看不到這個具體類的名字，所以說它可以很好的實現隱藏。
2.可以無條件地訪問外圍類的所有元素
package insidecategory;

public class TagBean {

 private String name="liutao";
   private class InTest
   {
      public InTest()
      {
          System.out.println(name);
      }
   }
   public void test()
   {
    new InTest();
   }
   public static void main(String args[])
   {
       TagBean bb=new TagBean();
       bb.test();
   }
}
看上面加粗部分，name這個變量是在TagBean裏面定義的私有變量。這個變量在內部類中可以無條件地訪問System.out.println(name);
 3.可以實現多重繼承
    個特點非常重要，個人認爲它是內部類存在的最大理由之一。正是由於他的存在使得Java的繼承機制更加完善。大家都知道Java只能繼承一個類，它的多重繼承在我們沒有學習內部類之前是用接口來實現的。但使用接口有時候有很多不方便的地方。比如我們實現一個接口就必須實現它裏面的所有方法。而有了內部類就不一樣了。它可以使我們的類繼承多個具體類或抽象類。大家看下面的例子。
類一
  package insidecategory;

public class Example1 {

   public String name()
   {
       return "liutao";
   }
}
類二
package insidecategory;

public class Example2 {

    public int age()
    {
        return 25;
    }
}

類三
 package insidecategory;

public class MainExample 
{
   private class test1 extends Example1 
    {
        public String name()
        {
          return super.name();
        }
    }
    private class test2 extends Example2
    {
       public int age()
       {
         return super.age();
       }
    }
   public String name()
    {
    return new test1().name(); 
   }
   public int age()
   {
       return new test2().age();
   }
   public static void main(String args[])
   {
       MainExample mi=new MainExample();
       System.out.println("姓名:"+mi.name());
       System.out.println("年齡:"+mi.age());
   }
}
大家注意看類三，裏面分別實現了兩個內部類 test1,和test2 ，test1類又繼承了Example1，test2繼承了Example2，這樣我們的類三MainExample就擁有了Example1和Example2的方法和屬性，也就間接地實現了多繼承。
四、 避免修改接口而實現同一個類中兩種同名方法的調用。
  大家假想一下如果，你的類要繼承一個類，還要實現一個接口，可是你發覺你繼承的類和接口裏面有兩個同名的方法怎麼辦？你怎麼區分它們？？這就需要我們的內部類了。看下面的代碼
接口
 package insidecategory;

public interface Incrementable
{
  void increment();
}

類  MyIncrement
   package insidecategory;

public class MyIncrement {

    public void increment()
    {
      System.out.println("Other increment()");
    }
    static void f(MyIncrement f)
    {
        f.increment();
    }

}
大家看上面加黑的部分，兩個方法都是一樣的。在看下面這個類要繼承這兩個類
如果不用內部類
package insidecategory;

public class Callee2 extends MyIncrement implements Incrementable
{
public void increment()
      {
        //代碼
       }
}
想問一下大家increment()這個方法是屬於覆蓋MyIncrement這裏的方法呢？還是Incrementable這裏的方法。我怎麼能調到MyIncrement這裏的方法？顯然這是不好區分的。而我們如果用內部類就很好解決這一問題了。看下面代碼
package insidecategory;

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();
  }
}
我們可以用內部類來實現接口，這樣就不會與外圍類的方法衝突了