初識Java內部類

       提起Java內部類（Inner Class）可能很多人不太熟悉，實際上類似的概念在C++裡也有，那就是巢狀類（Nested Class），關於這兩者的區別與聯絡，在下文中會有對比。內部類從表面上看，就是在類中又定義了一個類（下文會看到，內部類可以在很多地方定義），而實際上並沒有那麼簡單，乍看上去內部類似乎有些多餘，它的用處對於初學者來說可能並不是那麼顯著，但是隨著對它的深入瞭解，你會發現Java的設計者在內部類身上的確是用心良苦。學會使用內部類，是掌握Java高階程式設計的一部分，它可以讓你更優雅地設計你的程式結構。下面從以下幾個方面來介紹：
       
        第一次見面
        public interface Contents {
            int value();
        }
       
        public interface Destination {
            String readLabel();
        }
       
        public class Goods {
            private class Content implements Contents {
                private int i = 11;
                public int value() {
                    return i;
                }
            }
       
            protected class GDestination implements Destination {
                private String label;
                private GDestination(String whereTo) {
                    label = whereTo;
                }
                public String readLabel() {
                    return label;
                }
            }
       
            public Destination dest(String s) {
                return new GDestination(s);
            }
            public Contents cont() {
                return new Content();
            }
        }
       
        class TestGoods {
            public static void main(String[] args) {
                Goods p = new Goods();
                Contents c = p.cont();
                Destination d = p.dest("Beijing");
            }
        }
        
        在這個例子裡類Content和GDestination被定義在了類Goods內部，並且分別有著protected和private修飾符來控制訪問級別。Content代表著Goods的內容，而GDestination代表著Goods的目的地。它們分別實現了兩個介面Content和Destination。在後面的main方法裡，直接用 Contents c和Destination d進行操作，你甚至連這兩個內部類的名字都沒有看見！這樣，內部類的第一個好處就體現出來了——隱藏你不想讓別人知道的操作，也即封裝性。
        同時，我們也發現了在外部類作用範圍之外得到內部類物件的第一個方法，那就是利用其外部類的方法建立並返回。上例中的cont()和dest()方法就是這麼做的。那麼還有沒有別的方法呢？當然有，其語法格式如下：
       
        outerObject=new outerClass(Constructor Parameters);
       
        outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);
        
       
        注意在建立非靜態內部類物件時，一定要先建立起相應的外部類物件。至於原因，也就引出了我們下一個話題——
       
        非靜態內部類物件有著指向其外部類物件的引用
        對剛才的例子稍作修改：
       
        public class Goods {
       
            private valueRate=2;
       
            private class Content implements Contents {
                private int i = 11*valueRate;
                public int value() {
                    return i;
                }
            }
       
            protected class GDestination implements Destination {
                private String label;
                private GDestination(String whereTo) {
                    label = whereTo;
                }
                public String readLabel() {
                    return label;
                }
            }
       
            public Destination dest(String s) {
                return new GDestination(s);
            }
            public Contents cont() {
                return new Content();
            }
        }
        
       
        修改的部分用紅色顯示了。在這裡我們給Goods類增加了一個private成員變數valueRate，意義是貨物的價值係數，在內部類Content的方法value()計算價值時把它乘上。我們發現，value()可以訪問valueRate，這也是內部類的第二個好處——一個內部類物件可以訪問建立它的外部類物件的內容，甚至包括私有變數！這是一個非常有用的特性，為我們在設計時提供了更多的思路和捷徑。要想實現這個功能，內部類物件就必須有指向外部類物件的引用。Java編譯器在建立內部類物件時，隱式的把其外部類物件的引用也傳了進去並一直儲存著。這樣就使得內部類物件始終可以訪問其外部類物件，同時這也是為什麼在外部類作用範圍之外向要建立內部類物件必須先建立其外部類物件的原因。
       
        有人會問，如果內部類裡的一個成員變數與外部類的一個成員變數同名，也即外部類的同名成員變數被遮蔽了，怎麼辦？沒事，Java裡用如下格式表達外部類的引用：
       
        outerClass.this
       
        有了它，我們就不怕這種遮蔽的情況了。
       
        靜態內部類
        和普通的類一樣，內部類也可以有靜態的。不過和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部的引用。這實際上和C++中的巢狀類很相像了，Java內部類與C++巢狀類最大的不同就在於是否有指向外部的引用這一點上，當然從設計的角度以及以它一些細節來講還有區別。
       
        除此之外，在任何非靜態內部類中，都不能有靜態資料，靜態方法或者又一個靜態內部類（內部類的巢狀可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。
       
        區域性內部類
        是的，Java內部類也可以是區域性的，它可以定義在一個方法甚至一個程式碼塊之內。
       
        public class Goods1 {
             public Destination dest(String s) {
                  class GDestination implements Destination {
                       private String label;
                       private GDestination(String whereTo) {
                            label = whereTo;
                       }
                       public String readLabel() { return label; }
                  }
                  return new GDestination(s);
             }
       
             public static void main(String[] args) {
                  Goods1 g= new Goods1();
                  Destination d = g.dest("Beijing");
             }
        }
        
       
        上面就是這樣一個例子。在方法dest中我們定義了一個內部類，最後由這個方法返回這個內部類的物件。如果我們在用一個內部類的時候僅需要建立它的一個物件並創給外部，就可以這樣做。當然，定義在方法中的內部類可以使設計多樣化，用途絕不僅僅在這一點。
       
        下面有一個更怪的例子：
       
        public class Goods2{
             private void internalTracking(boolean b) {
                  if(b) {
                       class TrackingSlip {
                            private String id;
                            TrackingSlip(String s) {
                                 id = s;
                            }
                            String getSlip() { return id; }
                       }
                       TrackingSlip ts = new TrackingSlip("slip");
                       String s = ts.getSlip();
                  }
             }
       
             public void track() { internalTracking(true); }
       
             public static void main(String[] args) {
                  Goods2 g= new Goods2();
                  g.track();
             }
        }
        
       
        你不能在if之外建立這個內部類的物件，因為這已經超出了它的作用域。不過在編譯的時候，內部類TrackingSlip和其他類一樣同時被編譯，只不過它由它自己的作用域，超出了這個範圍就無效，除此之外它和其他內部類並沒有區別。
       
        匿名內部類
        java的匿名內部類的語法規則看上去有些古怪，不過如同匿名陣列一樣，當你只需要建立一個類的物件而且用不上它的名字時，使用內部類可以使程式碼看上去簡潔清楚。它的語法規則是這樣的：
       
        new interfacename(){......}; 或 new superclassname(){......};
       
        下面接著前面繼續舉例子：
       
        public class Goods3 {
             public Contents cont(){
                  return new Contents(){
                       private int i = 11;
                       public int value() {
                            return i;
                       }
                  };
             }
        }
       
        這裡方法cont()使用匿名內部類直接返回了一個實現了介面Contents的類的物件，看上去的確十分簡潔。
       
        在java的事件處理的匿名介面卡中，匿名內部類被大量的使用。例如在想關閉視窗時加上這樣一句程式碼：
       
        frame.addWindowListener(new WindowAdapter(){
             public void windowClosing(WindowEvent e){
                  System.exit(0);
             }
        });
       
        有一點需要注意的是，匿名內部類由於沒有名字，所以它沒有建構函式（但是如果這個匿名內部類繼承了一個只含有帶引數建構函式的父類，建立它的時候必須帶上這些引數，並在實現的過程中使用super關鍵字呼叫相應的內容）。如果你想要初始化它的成員變數，有下面幾種方法：
       
        如果是在一個方法的匿名內部類，可以利用這個方法傳進你想要的引數，不過記住，這些引數必須被宣告為final。
        將匿名內部類改造成有名字的區域性內部類，這樣它就可以擁有建構函式了。
        在這個匿名內部類中使用初始化程式碼塊。
        為什麼需要內部類？
        java內部類有什麼好處？為什麼需要內部類？
       
        首先舉一個簡單的例子，如果你想實現一個介面，但是這個介面中的一個方法和你構想的這個類中的一個方法的名稱，引數相同，你應該怎麼辦？這時候，你可以建一個內部類實現這個介面。由於內部類對外部類的所有內容都是可訪問的，所以這樣做可以完成所有你直接實現這個介面的功能。
       
        不過你可能要質疑，更改一下方法的不就行了嗎？
       
        的確，以此作為設計內部類的理由，實在沒有說服力。
       
        真正的原因是這樣的，java中的內部類和介面加在一起，可以的解決常被C++程式設計師抱怨java中存在的一個問題——沒有多繼承。實際上，C++的多繼承設計起來很複雜，而java通過內部類加上介面，可以很好的實現多繼承的效果。
       
        本文的目的只是向大家介紹一下內部類的概念以及使用方法，在後續文章裡，將會針對本文中的內容舉更多具體的例子，以及介紹如何使用內部類構建一個Applicaton Framework。