轉:java內部類

在java語言中，有一種類叫做內部類(inner class)，也稱為嵌入類(nested class)，它是定義在其他類的內部。內部類作為其外部類的一個成員，與其他成員一樣，可以直接存取其外部類的資料和方法。只不過相比較外部類只有public和預設的修飾符不同，內部類作為一個成員，可以被任意修飾符修飾。編譯器在編譯時間，內部類的名稱為OuterClass$InnerClass.class 。


1、內部類訪問資料變數
當在某些時候，內部類中定義的變數與外部類中變數名稱相同時，如何確保正確地訪問每一個變數呢？

1.1在main中直接從外部類調用內部類的方法

class Outer
{
    private int index = 10;
    class Inner 
    {
        private int index = 20;
        void print()
        {
            int index = 30;
            System.out.println(this); // the object created from the Inner
            System.out.println(Outer.this); // the object created from the Outer
            System.out.println(index); // output is 30
            System.out.println(this.index); // output is 20
            System.out.println(Outer.this.index); // output is 10
        }
    }

    void print() 
    {
        Inner inner = new Inner();//得到內部類的引用
        inner.print();
    }
}

class Test 
{
    public static void main(String[] args) 
    {
        Outer outer = new Outer();
        outer.print();
    }
}
在這裡內部類Inner中關鍵字this指向內部類Inner的對象，如果要想指向外部類的對象，必須在this指標前加上外部類名稱，表示this是指向外部類構造的碎屑，如Outer.this 。

1.2在main中顯式返回內部類引用

class Outer 
{
    private int index = 10;
    class Inner 
    {
        private int index = 20;
        void print() 
        {
            int index = 30;
            System.out.println(index);
            System.out.println(this.index);
            System.out.println(Outer.this.index);
        }
    }

    Inner getInner() 
    {
        return new Inner();//返回一個內部類的引用
    }
}

class Test 
{
    public static void main(String[] args) 
    {
        Outer outer = new Outer();
        Outer.Inner inner = outer.getInner();
        inner.print();
    }
}
Inner是Outer的內部類，所以在類Test中必須用屬性引用符來標識出內部類。

1.3當main方法在Outer類內部

class Outer 
{
        private int index = 10;
        class Inner 
        {
             private int index = 20;
             void print() 
             {
                  int index = 30;
                  System.out.println(index);
                  System.out.println(this.index);
                  System.out.println(Outer.this.index);
             }
        }

        Inner getInner() 
        {
             return new Inner();//返回一個內部類的引用
        }

        public static void main(String[] args) 
        {
             Outer outer = new Outer();
             Inner inner = outer.getInner(); // 注意此處變化
             inner.print();
        }
}
因為main方法在Outer內部，故可以直接引用，不需要屬性引用符。


1.4在main方法中直接產生內部類對象

class Test 
{
        public static void main(String[] args) 
        {
             Outer outer = new Outer();
             Outer.Inner inner = outer.new Inner(); // 注意此處變化
             inner.print();
        }
}
在利用new構造方法構造一個外部類對象時，並沒有連帶著構造一個內部類對象，故需要訪問內部類方法時，必須使用new操作符為這個外部類對象再構造一個內部類對象。

2、局部內部類
在方法中定義的內部類是局部內部類，它只能存取方法中的final類型的局部變數，因為用final定義的局部變數相當於是一個常量，延長了其生命週期，使得方法在消亡時，其內部類仍可以訪問該變數。另外，它同樣也可以引用定義在外部類的變數和方法。而且方法體中的局部內部類不允許有存取修飾詞。

class Outer
{
        int num=10; 
        public void print(final int aArgs)
        {
             class Inner
             {
                 int num=20;
                 public Inner()
                 {
                     System.out.println("This is Inner.");//此句可看出它與匿名內部類用法的不同。
                 }

                 public void print()
                 {     
                     int num=30;
                     System.out.println(this); // the object created from the local Inner
                     System.out.println(num);
                     System.out.println(this.num);
                     System.out.println(Outer.this.num);
                     System.out.println(aArgs);
                 }
             }
             Inner inner=new Inner();//此句必須放在定義類Inner的後面
             inner.print();
        }

        public static void main(String[] args)
        {
             Outer outer=new Outer();
             outer.print(40);
        }
}
對於局部類的命名，不管是在一個方法中定義多個類還是在幾個方法中分別定義類，其編譯後命名是：OuterClass$1InnerClass.class

3、匿名內部類
匿名內部類作為一種特殊的內部類，除了具有普通內部類的特點，還有自己的一些專屬特性：
匿名內部類必須擴充一個基類或實現一個介面，但是不能有顯式的extends和implements子句；
匿名內部類必須實現父類以及介面中的所有抽象方法；
匿名內部類總是使用父類的無參構造方法來建立執行個體。如果是實現了一個介面，則其構造方法是Object()；
匿名內部類編譯後的命名為：OuterClass$n.class，其中n是一個從1開始的整數，如果在一個類中定義了多個匿名內部類，則按照他們的出現順序從1開始排號。

abstract class A
{
    abstract public void sayHello();
}

class Outer
{
    public static void main(String[] args)
    {
         new Outer().callInner(new A()
         {
               public void sayHello()
               {
                     System.out.println(this); // the object created from the anonymous Inner
                     System.out.println("Hello!");
               }
         });
    }

    public void callInner(A a)
    {
        a.sayHello();
    }
}

4、靜態內部類
和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。除此之外，在任何非靜態內部類中，都不能有待用資料，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態內部類,才可以聲明一個static成員，靜態內部類可以訪問外圍類的靜態方法、成員（包括private static的成員）。靜態內部類執行個體化的時候不必先執行個體化外圍類，可以直接執行個體化內部類。而對於非靜態內部類則必須先執行個體化其外部類，才能再執行個體化本身。

5．內部類的繼承
當一個類繼承自一個內部類時，預設的構造器不可用。必須使用如下文法：
class WithInner
{
    class Inner
    {
        public void sayHello()
        {
            System.out.println("Hello.");
        }
    }
}

public class Test extends WithInner.Inner
{
    Test(WithInner wi)
    {
        wi.super();
    }
    public static void main(String[] args)
    {
        WithInner wi=new WithInner();
        Test test=new Test(wi);
        test.sayHello();
    }
} 
因為每一個內部類都有一個指向外部類的引用，在繼承一個內部類，必須先建立一個外部類，通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類，則就不需要這樣，直接super()調用即可；

6、內部類的2種特殊用法
一個類從另一個類派生出來，又要實現一個介面。但在介面中定義的方法與父類中定義的方法的意義不同，則可以利用內部類來解決這個問題。
interface Machine
{
    void run();
}

class Person
{     
    void run()
    {
        System.out.println("run");
    }
}

class Robot extends Person
{
    private class MachineHeart implements Machine
    {
        public void run()
        {
            System.out.println("heart run");
        }
    }

    Machine getMachine()
    {
        return new MachineHeart();
    }
}

class Test
{
    public static void main(String[] args)
   {
        Robot robot = new Robot();
        Machine m = robot.getMachine();
        m.run();
        robot.run();
    }
}
在Robot類內部使用內部類MachineHeart來實現介面Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現介面Machine，則該如何調用父類的run方法？

利用內部類可解決c++中多重繼承所解決的問題
class A
{
    void fn1()
    {
        System.out.println("It' s fn1.");
    }
}

abstract class B
{
    abstract void fn2();
}

class C extends A
{
    B getB()
    {
        return new B() 
        {
            public void fn2()
            {
                System.out.println("It' s fn2.");
            }
        };
    }
}

class Test
{
    public static void main(String[] args)
    {
        C c = new C();
        c.fn1();
        c.getB().fn2();
    }
}
類C既要繼承類A又要繼承類B，則可將類B的定義放入類C內部，使之成為內部類。


一般情況下 當我們需要在某一情形下實現一個介面，而在另一情形下又不需要實現這個介面時，我們可以使用內部類來解決這一問題。讓內部類來實現這個介面。另外一個很好的理由是java內部類加上介面可以有效地實現多重繼承。

參考資料：http://hi.baidu.com/kiddoneal/blog/item/3b6a68864fd75a20c75cc348.html