因為欣賞所以轉載：先宣告轉摘地址吧 http://www.cnblogs.com/o-andy-o/archive/2012/04/07/2435825.html

內部類分為成員內部類、靜態巢狀類、方法內部類、匿名內部類。
幾種內部類的共性：
A、內部類仍然是一個獨立的類，在編譯之後會內部類會被編譯成獨立的.class檔案，但是前面冠以外部類的類命和$符號。
B、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。

 1 /** 2  * 四種不同型別的內部類
 3  * @author Administrator
 4  *
 5  */
 

 6 public class OuterOfInnerClass {
 7     int out_x  = 0;
 8     
 9     public void method() {
10         Inner1 inner1 = new Inner1();
11         final int a = -1;
12         //在方法體內部定義的內部類,只允許使用抽象或終態13         /**14          * 區域性內部類
15          *
16 */
17         class Inner2 {
18             public
 
 void method() {
19                 out_x = 3;
20                 System.out.println(a);
21             }
22         }
23         Inner2 inner2 = new Inner2();
24     }
25     /**26      *成員內部類 Inner Class
27      *
28 */
29     public class Inner1 {
30         
31     }
32     /**33      * 靜態內部類 Static Nested Class 
 
34      *
35 */
36     public static class Inner3 {
37         int a = new OuterOfInnerClass().out_x;
38         public void aa() {
39             
40         }
41     }
42 
43     public ParentAbstract rr() {
44         /**45          * 匿名內部類
46 */
47         return new ParentAbstract() {
48             void save() {
49                 
50             }
51             
52         };
53     }
54     
55     public void testInner1() {
56         int b = 1;
57         OuterOfInnerClass oo = new OuterOfInnerClass();
58         
59         OuterOfInnerClass.Inner1 inner1 = oo.new Inner1();
60     }
61 
62 }
63 
64 abstract class ParentAbstract {
65     abstract void save();
66 }

1、成員內部類：形式如下
    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修飾內部類，它就變成靜態內部類了。

2、方法內部類。
顧名思義，把類放在方法內。
    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引用的，因此在靜態方法內的內部類遭受同樣的待遇，即：只能訪問外部類的靜態成員。

3、匿名內部類。
顧名思義，沒有名字的內部類。表面上看起來它們似乎有名字，實際那不是它們的名字。
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");
            }
        });
    }
}

4、靜態巢狀類。
從技術上講，靜態巢狀類不屬於內部類。因為內部類與外部類共享一種特殊關係，更確切地說是對例項的共享關係。而靜態巢狀類則沒有上述關係。它只是位置在另一個類的內部，因此也被稱為頂級巢狀類。
靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類物件時，也能夠訪問它。靜態巢狀類不能訪問外部類的成員和方法。
    class Outer{
        static class Inner{}
    }
    class Test {
        public static void main(String[] args){
            Outer.Inner n = new Outer.Inner();
        }
    }