基礎

Java支持類中嵌套類，稱之為nested class。嵌套的層數沒有限制，但實際中一般最多用兩層。根據內部類是否有static修飾，分為 static nested class 和 non-static nested class 。non-static nested class又被稱為 inner class 。inner class里面又有兩個特殊一點的類：local class 和 anonymous class 。特殊之處主要在于語法使用上，實質功能是差不多的。 官方 是這樣解釋的：

Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are called static nested classes. Non-static nested classes are called inner classes.

用圖表示分類及關系如下：

上面是按照官方的說法來分的，實際中很多人習慣把所有的嵌套類都稱為inner class（內部類），這只是個稱謂，不影響溝通就好。后文用nested class來統稱static nested class和non-static nested class。各個類的主要特性和限制已經在圖中說明了（適用于JDK 8及以后）。

那為什么需要內部類呢？內部類是在Java 1.1中引入的，當時很多人質疑該設計增加了Java的復雜性，但實用性不強，當然這種問題仁者見仁智者見智。官方的解釋是這樣的：

Why Use Nested Classes?

Compellingreasons for using nested classes include the following:

• It is a way of logically grouping classes that are only used in one place : If a class is useful to only one other class, then it is logical to embed it in that class and keep the two together. Nesting such "helper classes" makes their package more streamlined.**
• It increases encapsulation : Consider two top-level classes, A and B, where B needs access to members of A that would otherwise be declared private. By hiding class B within class A, A's members can be declared private and B can access them. In addition, B itself can be hidden from the outside world.
• It can lead to more readable and maintainable code : Nesting small classes within top-level classes places the code closer to where it is used.

總的來說，嵌套類最大的目的是改善代碼的組織，并不是必不可少的功能。嵌套類能實現的功能，通過正常的類都可以實現，只不過可能要多寫點代碼，且不是很優雅而已。

為什么inner class可以訪問外層類的非靜態成員

要說明的是： 嵌套類是對于編譯器而言的，對虛擬機來說沒有什么嵌套類，只有正常的類 。也就是說嵌套類經過編譯器編譯之后要轉化成一個個正常的類，比如A類里面嵌套了B類。那經過編譯器之后會變成兩個獨立的類： A 和 A$B 。這樣問題就很簡單了，B類要訪問A類的非靜態成員，要滿足兩個條件：

要有A類的實例。

且要有訪問成員的權限或者方式。

而編譯器在編譯期間就幫我們干了這兩件事，下面驗證一下。

定義一個嵌套類：

public class OuterClass {/*** 定義一個公有成員變量*/public Object publicVariable = "public member variable";private Object privateVariable = "private member variable";/*** 定義兩個私有成員變量*/ private Object privateVariable2 = "private member variable2";/*** 定義一個私有成員方法* @param parameter*/private void privateMethod(String parameter) {System.out.println(parameter);}/*** 調用inner class*/public void show() {InnerClass innerClass = new InnerClass();innerClass.print();}/*** inner class*/class InnerClass {void print() {// inner class里面直接調用了外部類的私有成員變量和成員方法System.out.println(privateVariable);privateMethod("invoke outer class private method.");// 調用外層類的公有變量System.out.println(publicVariable);}}public static void main(String[] args) {new OuterClass().show();} }

上面代碼定義了外層類是 OuterClass ，內部類是 InnerClass 。外層類定義了1個公有變量、2個私有變量和1個私有方法。然后在InnerClass里面直接使用了OuterClass的所有成員。程序運行結果如下：

private member variable invoke outer class private method. public member variable

反編譯一下上面的兩個類：

# javap -p OuterClass.class Compiled from "OuterClass.java" public class OuterClass {public java.lang.Object publicVariable;private java.lang.Object privateVariable;private java.lang.Object privateVariable2;public OuterClass();private void privateMethod(java.lang.String);public void show();public static void main(java.lang.String[]);# 注意這兩個靜態方法static java.lang.Object access$000(OuterClass);static void access$100(OuterClass, java.lang.String); }# javap -p OuterClass$InnerClass.class Compiled from "OuterClass.java" class OuterClass$InnerClass {# 注意這個final的成員變量和下面的構造函數final OuterClass this$0;OuterClass$InnerClass(OuterClass);void print(); }

結論就是：

編譯器修改了內部類：增加了一個final的外層類實例作為內部類的成員變量；修改了內部類的構造函數，將外部類實例通過內部類的構造函數傳遞給內部類。這樣內部類就有了外部類的實例，上面的第1個條件就達成了。

編譯器在外部類中增加了幾個非private的靜態方法。對于內部類訪問外部類的每一個私有成員，都會有這么一個方法。這樣內部類就可以通過這些靜態方法去訪問外部類的私有成員了。非私有的成員直接通過1中的外層類實例即可訪問，所以就無需生成這些靜態方法了。

再進一步驗證一下上面的結論1，當執行 InnerClass innerClass = new InnerClass(); 語句創建一個內部類實例之后，可以觀測到下面的結果：

可以看到，內部類實例（ OuterClass$InnerClass@470 ）自動引用了外層類實例（ OuterClass@464 ）。所以， inner class之所以能訪問外層類的成員是因為它在實例化的時候就已經和一個外層類的實例關聯了 ，實際是通過這個外層類實例去訪問外層類的成員。對于私有成員，還生成了一些輔助的靜態方法。這也說明，要實例化inner class，必須先實例化它的外層類。

另外有個限制就是inner class里面不能定義靜態變量和靜態方法，一個例外是可以定義基礎類型和String類型的靜態常量。比如：

static final String s = “s”; // OK static final int i = 5; // OK static final Integer ii = 5; // 錯誤

local class和anonymous class都屬于特殊的inner class，所以上面講述的所有東西對他們也適用。

為什么static nested class不能訪問外層類的非靜態成員

原因很簡單，static nested class除了被定義到某個類里面以外，幾乎和普通的類沒有什么區別。 它不會和外層類的某個實例關聯 ，比如我們在上面的OuterClass里面再定義一個StaticNestedClass ：

static class StaticNestedClass {private int a;void foo() {} }

反編譯以后：

# javap -p OuterClass$StaticNestedClass.class Compiled from "OuterClass.java" class OuterClass$StaticNestedClass {private int a;OuterClass$StaticNestedClass();void foo(); }

除了類名被改寫了以外，和原來定義的類沒有任何區別。所以如果沒有被定義為private的話，static nested class完全可以獨立于外層類使用。

所有nested class都可以訪問外層類的靜態成員

上面討論的都是nested class能不能訪問外層類的非靜態成員，那如果是靜態成員呢？結論就是所有nested class都可以訪問的靜態成員，不管是不是私有。原理的話和inner class訪問外層類非static成員是一樣的，如果是private的，編譯器會在外層中生成一個輔助訪問的static方法，如果是非私有的，那通過類就可以直接訪問。

## 如果nested class是private的？

我們知道正常的類是不能使用private和protected的（只能是public或者不加訪問修飾符），但nested class卻可以，因為nested class其實就是外層類的一個特殊成員，就像成員變量、成員方法一樣。比如，如果我們不想讓外部的其它類看到nested class的類，就可以將它設置成private的，但對于外層類是沒有影響的，照樣可以操作這個類。這個怎么做到的呢？

我們將上面的StaticNestedClass改為private的：

private static class StaticNestedClass {void foo() {System.out.println(a);} }

反編譯看下：

# javap -p OuterClass$StaticNestedClass.class Compiled from "OuterClass.java" class OuterClass$StaticNestedClass {private OuterClass$StaticNestedClass();void foo();OuterClass$StaticNestedClass(OuterClass$1); }

可以看到，如果nested class被設置成private，它原來的構造函數就會被設置為private的，同時編譯器又新增了一個外部可見的構造函數OuterClass$StaticNestedClass(OuterClass$1) ，這個構造函數的一個入參就是外部類的實例。這樣，外部類實例化nested class的時候會先調用這個構造函數，這個構造函數內部又調用了原始的private的構造函數。inner class也是這樣的。

## 總結

嵌套類的實質就是外層類的成員，就像成員變量、成員方法一樣，初衷是提高代碼結構的緊湊和可維護性。 使用嵌套類的幾乎唯一的場景就是這個內部類僅供外層類（或者包含它的代碼塊）使用，其它場景都應該使用正常的一級類 。按這個思路使用即可，不要濫用，更不要搞騷操作。

Reference

• Core Java Volume I
• Orace The Java? Tutorials

原文鏈接：https://niyanchun.com/java-nested-class.html

如果覺得本文對你有幫助，可以點進我主頁關注我公眾號，上面有更多技術干貨文章以及相關資料共享，大家一起學習進步！

總結

以上是生活随笔為你收集整理的c++ 私有内部类_Java内部类新解，你没有见过的船新版本的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。