Java內部類

轉自：http://www.cnblogs.com/yan5lang/archive/2011/05/27/2059506.html

從Java1.1開始引入了內部類以來，它就引起了人們的激烈爭論。其實任何優秀的語言特性用得不好就是濫用，內部類用得不好就會導致代碼像迷宮一樣，導致出現毫無重用的綜合征。

1、內部類分為成員內部類、靜態嵌套類、方法內部類、匿名內部類。

幾種內部類的共性：

A、內部類仍然是一個獨立的類，在編譯之后會內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類命和$符號。

B、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變量，無論是否是private的。

2、成員內部類：形式如下

class Outer {
    class Inner{}
}

編譯上述代碼會產生兩個文件：Outer.class和Outer$Inner.class。

成員內部類內不允許有任何靜態聲明！下面代碼不能通過編譯。

 

class Inner{
   static int a = 10;
}

能夠訪問成員內部類的唯一途徑就是通過外部類的對象！

A、從外部類的非靜態方法中實例化內部類對象。

    class Outer {
        private int i = 10;
        public void makeInner(){
            Inner in = new Inner();
            in.seeOuter();
        }
        class Inner{
            public void seeOuter(){
                System.out.print(i);
            }
        }
    }

表面上，我們並沒有創建外部類的對象就實例化了內部類對象，和上面的話矛盾。

事實上，如果不創建外部類對象也就不可能調用makeInner()方法，所以到頭來還是要創建外部類對象的。

你可能試圖把makeInner()方法修飾為靜態方法，即static public void makeInner()。

這樣不創建外部類就可以實例化外部類了！

但是在一個靜態方法里能訪問非靜態成員和方法嗎？顯然不能。

它沒有this引用。沒能跳出那條規則！

但是如果在這個靜態方法中實例化一個外部類對象，再用這個對象實例化外部類呢？完全可以！也就是下一條的內容。

B、從外部類的靜態方法中實例化內部類對象。

   class Outer {
        private int i = 10;
        class Inner{
            public void seeOuter(){
                System.out.print(i);
            }
        } 
        public static void main(String[] args) {
            Outer out = new Outer();
            Outer.Inner in = out.new Inner();
            //Outer.Inner in = new Outer().new Inner();
            in.seeOuter();
        }
    }

被注釋掉的那行是它上面兩行的合並形式，一條簡潔的語句。

對比一下：在外部類的非靜態方法中實例化內部類對象是普通的new方式：Inner in = new Inner();

在外部類的靜態方法中實例化內部類對象，必須先創建外部類對象：

Outer.Inner in = new Outer().new Inner();

C、內部類的this引用。

普通的類可以用this引用當前的對象，內部類也是如此。但是假若內部類想引用外部類當前的對象呢？用“外部類名”.this；的形式,如下例的 Outer.this。

   class Outer {
        class Inner{
            public void seeOuter(){
                System.out.println(this);
                System.out.println(Outer.this);
            }
        }
    }

D、成員內部類的修飾符。

對於普通的類，可用的修飾符有final、abstract、strictfp、public和默認的包訪問。

但是成員內部類更像一個成員變量和方法。

可用的修飾符有：final、abstract、public、private、protected、strictfp和static。 一旦用static修飾內部類，它就變成靜態內部類了。

3、方法內部類。

顧名思義，把類放在方法內。

   class Outer {
        public void doSomething(){
            class Inner{
                public void seeOuter(){
                }
            }
        }
    }

A、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。

B、方法內部類對象不能使用該內部類所在方法的非final局部變量。

因為方法的局部變量位於棧上，只存在於該方法的生命期內。

當一個方法結束，其棧結構被刪除，局部變量成為歷史。

但是該方法結束之后，在方法內創建的內部類對象可能仍然存在於堆中！

例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變量內。

正因為不能保證局部變量的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。

[講的太好了，之前的疑惑現在沒有了]

下面是完整的例子：

   class Outer {
        public void doSomething(){
            final int a =10;
            class Inner{
                public void seeOuter(){
                    System.out.println(a);
                }
            }
            Inner in = new Inner();
            in.seeOuter();
        }
        public static void main(String[] args) {
            Outer out = new Outer();
            out.doSomething();
        }
     }

C、方法內部類的修飾符。

與成員內部類不同，方法內部類更像一個局部變量。 可以用於修飾方法內部類的只有final和abstract。

D、靜態方法內的方法內部類。

靜態方法是沒有this引用的，因此在靜態方法內的內部類遭受同樣的待遇，即：只能訪問外部類的靜態成員。

4、匿名內部類。

顧名思義，沒有名字的內部類。表面上看起來它們似乎有名字，實際那不是它們的名字。

A、繼承式的匿名內部類。

   class Car {
        public void drive(){
            System.out.println("Driving a car!");
        }
    }
    
    class Test{
        public static void main(String[] args) {
            Car car = new Car(){
                public void drive(){
                    System.out.println("Driving another car!");
                }
            };
            car.drive();
        }
    }

結果輸出了：Driving another car! Car引用變量不是引用Car對象，而是Car匿名子類的對象。

建立匿名內部類的關鍵點是重寫父類的一個或多個方法。

再強調一下，是重寫父類的方法，而不是創建新的方法。

因為用父類的引用不可能調用父類本身沒有的方法！

創建新的方法是多余的。簡言之，參考多態。

B、接口式的匿名內部類。

   interface  Vehicle {
        public void drive();
    }
    
    class Test{
        public static void main(String[] args) {
            Vehicle v = new Vehicle(){
                public void drive(){
                    System.out.println("Driving a car!");
                }
            };
            v.drive();
        }
    }

上面的代碼很怪，好像是在實例化一個接口。

事實並非如此，接口式的匿名內部類是實現了一個接口的匿名類。

而且只能實現一個接口。

C、參數式的匿名內部類。

    class Bar{
        void doStuff(Foo f){}
    }

    interface Foo{
        void foo();
    }

    class Test{
        static void go(){
            Bar b = new Bar();
            b.doStuff(new Foo(){
                public void foo(){
                    System.out.println("foofy");
                }
            });
        }
    }

5、靜態嵌套類。

從技術上講，靜態嵌套類不屬於內部類。

因為內部類與外部類共享一種特殊關系，更確切地說是對實例的共享關系。

而靜態嵌套類則沒有上述關系。它只是位置在另一個類的內部，因此也被稱為頂級嵌套類。

靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類對象時，也能夠訪問它。

靜態嵌套類不能訪問外部類的成員和方法。

   class Outer{
        static class Inner{}
    }
    class Test {
        public static void main(String[] args){
            Outer.Inner n = new Outer.Inner();
        }
    }

 

 靜態內部類：不能訪問外部類的非靜態成員，這是由Java語法中"靜態方法不能直接訪問非靜態成員"所限定。

                　若想訪問外部類的變量，必須通過其它方法解決，由於這個原因，靜態嵌套類使用很少。

                　靜態內部類其實已經脫離了外部類。

               　在創建靜態內部類對象時也不需要外部類對象的存在。

              　其實質是一個放置在別的類內部的普通類。

　　　　　　而關鍵字static也只是說明其在創建對象時不依賴於外部類對象的存在，並不是說這個類本身是靜態的。

• 靜態內部類與前面所講的兩種非靜態內部類的語法基本相同。區別主要是在內部類的聲明前面要加上static 關鍵字。
• 靜態內部類的對象可以直接生成，而不需要外部類的對象來生成，這樣實際上是使靜態內部類成為了一個頂級類。這主要是因為靜態內部類是外部類的靜態成員，並不依賴於外部類的對象而存在。
•  靜態內部類與非靜態內部類的區別是本質上的。非靜態內部類是外部類對象組成的一部分，主要是輔助外部類對象工作的，與外部類對象存在這對成員變量的共享關系。

 http://hi.baidu.com/zhumulangma/item/bcd478c140427b2cef466532