這篇文章主要講解了“Java嵌套類的定義及用法”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java嵌套類的定義及用法”吧！

創(chuàng)新互聯是一家專業(yè)的成都網站建設公司，我們專注成都網站建設、做網站、網絡營銷、企業(yè)網站建設，買鏈接，廣告投放平臺為企業(yè)客戶提供一站式建站解決方案，能帶給客戶新的互聯網理念。從網站結構的規(guī)劃UI設計到用戶體驗提高，創(chuàng)新互聯力求做到盡善盡美。

到現在為止，我們都是在Java文件中直接定義類。這樣的類出現在包(package)的級別上。Java允許類的嵌套定義。

這里將講解如何在一個類中嵌套定義另一個類。

 嵌套

內部類

Java允許我們在類的內部定義一個類。如果這個類是沒有static修飾符，那么這樣一個嵌套在內部的類稱為內部類(inner class)。

內部類被認為是外部對象的一個成員。在定義內部類時，我們同樣有訪問權限控制(public, private, protected)。

在使用內部類時，我們要先創(chuàng)建外部對象。由于內部類是外部對象的一個成員，我們可以在對象的內部自由使用內部類:

public class Test
{    public static void main(String[] args)
    {
        Human me        = new Human("Vamei");
        me.drinkWater(0.3);
    }
}class Human
{    /**
     * inner class     */
    private class Cup
    {        public void useCup(double w)
        {            this.water = this.water - w;
        }        public double getWater()
        {            return this.water;
        }        private double water = 1.0;
    }    /**
     * constructor     */
    public Human(String n)
    {        this.myCup = new Cup();        this.name  = n;
    }    public void drinkWater(double w)
    {
        myCup.useCup(w);
        System.out.println(myCup.getWater());
    }    private Cup myCup;    private String name;
}

上面的例子中，Cup類為內部類。該內部類有private的訪問權限，因此只能在Human內部使用。這樣，Cup類就成為一個被Human類專用的類。

如果我們使用其他訪問權限，內部類也能從外部訪問，比如:

public class Test
{    public static void main(String[] args)
    {
        Human me        = new Human("Vamei");
        me.drinkWater(0.3);
        Human.Cup soloCup = me.new Cup(); // be careful here
    }
}class Human
{    /**
     * inner class     */                                                                                                                                                             
    class Cup
    {        public void useCup(double w)
        {            this.water = this.water - w;
        }        public double getWater()
        {            return this.water;
        }        private double water = 1.0;
    }    /**
     * constructor     */
    public Human(String n)
    {        this.myCup = new Cup();        this.name  = n;
    }    public void drinkWater(double w)
    {
        myCup.useCup(w);
        System.out.println(myCup.getWater());
    }    private Cup myCup;    private String name;
}

這里，內部類為默認訪問權限(包訪問權限)。我們可以在Test類中訪問Human的內部類Cup，并使用該內部類創(chuàng)建對象。注意我們創(chuàng)建時如何說明類型以及使用new:

Human.Cup soloCup = me.new Cup();

我們在創(chuàng)建內部類對象時，必須基于一個外部類對象(me)，并通過該外部類對象來創(chuàng)建Cup對象(me.new)。我將在下一節(jié)講述其中的含義。

閉包

可以看到，我們直接創(chuàng)建內部類對象時，必須是基于一個外部類對象。也就是說，內部類對象必須依附于某個外部類對象。

內部對象與外部對象

與此同時，內部類對象可以訪問它所依附的外部類對象的成員(即使是private的成員)。從另一個角度來說，內部類對象附帶有創(chuàng)建時的環(huán)境信息，也就是其他語言中的閉包(closure)特性?？蓞⒖? Python閉包

我們看下面的例子:

public class Test
{    public static void main(String[] args)
    {
        Human me        = new Human("Vamei");
        Human him       = new Human("Jerry");
        Human.Cup myFirstCup  = me.new Cup();
        Human.Cup mySecondCup = me.new Cup();
        Human.Cup hisCup      = him.new Cup();
        System.out.println(myFirstCup.whosCup());
        System.out.println(mySecondCup.whosCup());
        System.out.println(hisCup.whosCup());
    }
}class Human
{    /**
     * inner class     */
    class Cup
    {        public String whosCup()
        {            return name;  // access outer field        }
    }    /**
     * constructor     */
    public Human(String n)
    {        this.name = n;
    }    public void changeName(String n)
    {        this.name = n;
    }    private String name;
}

運行結果:

Vamei
Vamei
Jerry

在上面的例子中，我們通過內部類對象訪問外部類對象的name成員。當我們基于不同的外部對象創(chuàng)建內部類對象時，所獲得的環(huán)境信息也將隨之變化。

嵌套static類 

我們可以在類的內部定義static類。這樣的類稱為嵌套static類(nested static class)。

我們可以直接創(chuàng)建嵌套static類的對象，而不需要依附于外部類的某個對象。相應的，嵌套static類也無法調用外部對象的方法，也無法讀取或修改外部對象的數據。從效果上看，嵌套static類拓展了類的命名空間(name space)，比如下面的Human.Mongolian:

public class Test
{    public static void main(String[] args)
    {
        Human.Mongolian him = new Human.Mongolian();
        him.Shout();
    }
}class Human
{    /**
     * nested class     */
    static class Mongolian
    {        public void Shout()
        {
            System.out.println("Oh...Ho...");
        }
    }
}

在定義嵌套static類時，我們同樣可以有不同的訪問權限修飾符。

總結

嵌套類允許我們更好的組織類

內部類實現了閉包

感謝各位的閱讀，以上就是“Java嵌套類的定義及用法”的內容了，經過本文的學習后，相信大家對Java嵌套類的定義及用法這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是創(chuàng)新互聯，小編將為大家推送更多相關知識點的文章，歡迎關注！