java以內部類(InnerClass)----非靜態內部類、靜態內部類、局部內部類、匿名內部類

提起java內褲類（innerClass）不少人不太熟悉，實際上相似的概念在c++裏面也有，那就是嵌套類（Nested Class），關於這倆者的區別，在下文中會有對比。內部類從表面上看，就是在類中定義了一個類（下文能夠看到，內部類能夠在不少地方定義），而實際上並無那麼簡單，乍看上去內部相似乎有些多餘，他的用處可能對於初學者來講並非那麼顯著,可是隨着對他的深刻了解，你會發現java的設計者在內褲類上面的確是用心良苦。學會使用內部類，是掌握java高級編程的一部分，他可讓你更優雅的設計你的程序結構。下面從如下幾個方面來介紹：

第一次見面：   

public class TestInnerClass{
    public static void main(String args[]){
        Goods good = new Goods();
        
        Contents content = good.dest();
        System.out.println(content.value());
        
        Destination destination = good.cont("BeiJing");
        System.out.println(destination.readLabel());
    }
}
interface Contents{
    int value();
}
interface Destination{
    String readLabel();
}
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 Content dest(){
        return new Content();
    }
    public GDestination cont(String s){
        return new GDestination(s);
    }
}

 

在這個例子裏，類Content和GDestination被定義在了Goods類內部，而且分別有着private和protected修飾符來控制訪問級別。Content表明着Goods的內容，而GDestination表明着Goods的目的地。在後面的main（）方法裏面，直接用Contents content 和Destination destination進行操做，你甚至連這倆個內部類的名字都沒有見過，這樣，內部類的好處就體現出來了，隱藏你不想讓別人知道的操做，即封裝性。

同時，咱們也發現了外部類做用範圍以外獲得內部類對象的第一個方法，那就是利用其外部類的方法建立並返回。上例中dest()和cont()方法就是這麼作的。那麼，還有沒有別的方法呢？固然有，其語法格式以下：

OuterClass outerObject = new OuterClass(Constructor parameters);

OuterClass .InnerClass innerObject = outerObject.new InnerClass(Constructor parameters);   //固然這時候要把內部類的構造行數改成public,不能是private了

注意在建立非靜態內部類對象時，必定要先建立起相應的外部類對象。至於緣由，也就引出了咱們的下一個話題 非靜態內部類對象有着指向其外部類對象的引用，對剛纔的例子稍做修改：

public class TestInnerClass{
    public static void main(String args[]){
        Goods good = new Goods();
        
        Contents content = good.dest();
        System.out.println(content.value());
    }
}
interface Contents{
    int value();
}
interface Destination{
    String readLabel();
}
class Goods{
    
    private int 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;
        public GDestination(String whereTo){
            label = whereTo;
        }
        public String readLabel(){
            return label;
        }
    }
    public Content dest(){
        return new Content();
    }
    public GDestination cont(String s){
        return new GDestination(s);
    }
}

在這裏咱們給Goods添加了一個新的private 成員變量 valueRate，意義是貨物的價值係數，在內部類Content的方法value()計算價值時把他乘上。咱們發現，value（）能夠訪問valueRate,這也是內部類的第二個好處，一個內部類對象能夠訪問建立他的外部類對象的內容，甚至包括私有變量！這是一個很是有用的特性，爲咱們在設計時提供了更多的思路跟捷徑。要想實現這個功能，內部類對象必須有指向外部類對象的引用。

java編譯器在建立內部類對象時，隱式的把其餘外部類的對象也傳了進來並一直保存着。這樣就使得內部類的對象始終能夠訪問其外部類的對象。同時這也是爲何在外部類做用範圍以外想要建立內部類對象必須建立起外部類對象的緣由。

有人會問，若是一個外部類的成員變量與內部類的成員變量同名，也即外部類的成員變量被屏蔽了，怎麼辦？沒事，java裏面有以下格式表達外部類的引用：

outerClass.this

有了它，咱們就不怕這種屏蔽的狀況了。

靜態內部類

和普通類同樣，內部類也能夠由靜態的。不過和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。這實際上和c++中的嵌套類很相像了。java內部類與c++嵌套類最大的不一樣就是在因而否有指向外部類引用這一點上，固然從設計的細節及其餘的一些角度來說還有一些區別。

除此以外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套能夠不僅一層）。不過靜態內部類中能夠擁有者一切。這也算倆者的第二個區別吧。

局部內部類：

是的，java內部類能夠定義在一個方法裏面甚至一個代碼塊以內。

public class TestInnerClass{
    public static void main(String args[]){
        Goods good = new Goods();
        
        Destination destination = good.dest("beijing");
        System.out.println(destination.readLabel());
    }
}

interface Destination{
    String readLabel();
}
class Goods{
    public Destination dest(String s){
        class GDestination implements Destination{
            private String label;
            public GDestination(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new GDestination(s);
    }
}

上面就是這樣一個例子。在方法dest（）中咱們定義了一個內部類，最後由這個方法返回這個內部類。若是咱們在建立一個對象的時候僅須要建立一個對象而且創給外部，就能夠這樣作。固然，定義在方法中的內部類可使設計多樣化，用途毫不僅僅在這一點。

下面有一個更怪的例子：

 

public class TestInnerClass{
    private void into(boolean b){
        if(b){
            class GDestination {
                private String label;
                public GDestination(String whereTo){
                    label = whereTo;
                }
                public String readLabel(){
                    return label;
                }    
            }
            GDestination destination = new GDestination("beijing");
            System.out.println(destination.readLabel());
        }
    }
    public void dest(boolean b){
        into(b);
    }
    public static void main(String args[]){
        TestInnerClass inner = new TestInnerClass();
        inner.dest(true);
    }
}

你不能再if()語句以外建立這個內部類的對象，應爲這已經超出了他的做用域。不過在編譯的時候，內部類GDestination和其餘類同樣同時被編譯，不過他有他本身的做用域。超出了這個範圍就無效，除此以外和其餘的內部類並無區別。

匿名內部類

java的匿名內部類看上去有些古怪，不過如同匿名數組同樣，單你只須要建立一個類的對象而用不上他的名字的時候，使用內部類看上去可使代碼更簡潔清楚。他的語法規則是這樣的：

new interfaceName(){...................};或：new superClassName(){................................};

下面接着前面繼續舉例子：

public class TestInnerClass{
    public Contents cont(){
        return new Contents(){
            private int i = 11;
            public int value(){
                return i;
            }
        };
    }
    public static void main (String args[]){
        TestInnerClass test = new TestInnerClass();
        Contents content = test.cont();
        
        System.out.println(content.value());
    }
}
interface Contents{
    public int value();
}

這裏的cont()使用匿名內部類直接返回了一個實現了接口Contents的類對象，看上去的確十分簡潔。

在java的事件處理機制的匿名適配器中，匿名內部類被大量使用。例如在關閉窗口時附加上這樣一段代碼：

frame.addWindowListener(new WindowAdapter(){  
    public void windowClosing(WindowEvent e){  
       System.exit(0);  
    }  
});   

有一點須要注意的是，匿名內部類因爲沒有名字，因此他沒有構造函數（可是若是這個匿名內部類繼承了一個只含有帶參構造函數的父類，建立他的時候必須帶上這些參數，並在實現的過程當中使用super關鍵字調用相應的內容）。若是你想初始化他的成員變量，有下面幾種方法：

若是是在一個方法的匿名內部類，能夠利用這個方法傳進你想要的參數，不過記住，這些參數必須聲明爲final 。

將匿名內部類改形成有名字的局部內部類，這樣他就能夠擁有構造函數了。

在這個匿名內部類中使用初始化代碼塊。

爲何須要內部類？

java內部類有什麼好處？爲何須要內部類？

首先舉一個簡單的例子，若是你想實現一個接口，可是這個接口中的一個方法和你構想的這個類中的一個方法的名稱，參數相同，你應該怎麼辦？這時候，你能夠建立一個內部類實現這個接口。因爲內部類對於外部類的全部內容都是能夠訪問的，因此這樣作能夠完成你直接實現這個接口的功能。

不過你可能要質疑，更改一下方法不就能夠了嗎？

的確，以此做爲設計內部類的理由，沒有說服力。

真正的緣由是這樣的，java中的內部類和接口加在一塊兒，能夠解決常被C++程序員抱怨java中存在的一個問題 沒有多繼承。實際上，c++的多繼承設計起來很複雜，而java經過內部類+接口，能夠很好的實現多繼承的效果。