java內部類,java內部類實例化

本文目錄一覽：

• 1、在Java中什麼是內部類？
• 2、Java內部類有幾種？
• 3、java中內部類
• 4、java 內部類和外部類的區別？
• 5、java內部類與匿名內部類作用分別是什麼？
• 6、java裡面的內部類和外部類是什麼?_?

在Java中什麼是內部類？

內部類就是寫在類中或方法中的類，它還是一個類，與其他類的不同就是他只為這個外部類（包含內部類的類）類所用

Java內部類有幾種？

Java中的幾種內部類：

成員內部類：作為外部類的一個成員存在，與外部類的屬性、方法並列。當某個類除了他的外部類，不會被其他類使用時應該選擇使用成員內部類。

局部內部類：局部內部類定義在外部類的某個代碼塊或方法塊中。如果只會在某個方法或塊中創建這個類的對象，就可以使用局部內部類。

匿名內部類：匿名內部類一般定義在需要傳遞介面或回調的的地方，一個匿名內部類一定是在new的後面，用其隱含實現一個介面或繼承一個類。假如只需要創建這個類的一個對象不需要知道其實際類型(不需要使用到類名)，那麼就可以使用匿名內部類。

靜態內部類：和成員內部類一樣，作為外部類的一個成員存在，與外部類的屬性、方法並列，只不過在聲明類的時候加入了static關鍵字。有時候，使用內部類只是為了把一個類隱藏在另外一個類的內部，並不需要內部類引用外圍類對象。這時可以使用靜態內部類，以便取消產生對外部類的引用。

java中內部類

在java語言中，有一種類叫做內部類(inner class)，也稱為嵌入類(nested class)，它是定義在其他類的內部。內部類作為其外部類的一個成員，與其他成員一樣，可以直接訪問其外部類的數據和方法。只不過相比較外部類只有public和默認的修飾符不同，內部類作為一個成員，可以被任意修飾符修飾。編譯器在編譯時，內部類的名稱為OuterClass$InnerClass.class 。

1、內部類訪問數據變數

當在某些時候，內部類中定義的變數與外部類中變數名稱相同時，如何確保正確地訪問每一個變數呢？

1.1在main中直接從外部類調用內部類的方法

class Outer

{

private int index = 10;

class Inner

{

private int index = 20;

void print()

{

int index = 30;

System.out.println(this); // the object created from the Inner

System.out.println(Outer.this); // the object created from the Outer

System.out.println(index); // output is 30

System.out.println(this.index); // output is 20

System.out.println(Outer.this.index); // output is 10

}

}

void print()

{

Inner inner = new Inner();//得到內部類的引用

inner.print();

}

}

class Test

{

public static void main(String[] args)

{

Outer outer = new Outer();

outer.print();

}

}

在這裡內部類Inner中關鍵字this指向內部類Inner的對象，如果要想指向外部類的對象，必須在this指針前加上外部類名稱，表示this是指向外部類構造的碎屑，如Outer.this 。

1.2在main中顯式返回內部類引用

class Outer

{

private int index = 10;

class Inner

{

private int index = 20;

void print()

{

int index = 30;

System.out.println(index);

System.out.println(this.index);

System.out.println(Outer.this.index);

}

}

Inner getInner()

{

return new Inner();//返回一個內部類的引用

}

}

class Test

{

public static void main(String[] args)

{

Outer outer = new Outer();

Outer.Inner inner = outer.getInner();

inner.print();

}

}

Inner是Outer的內部類，所以在類Test中必須用屬性引用符來標識出內部類。

1.3當main方法在Outer類內部

class Outer

{

private int index = 10;

class Inner

{

private int index = 20;

void print()

{

int index = 30;

System.out.println(index);

System.out.println(this.index);

System.out.println(Outer.this.index);

}

}

Inner getInner()

{

return new Inner();//返回一個內部類的引用

}

public static void main(String[] args)

{

Outer outer = new Outer();

Inner inner = outer.getInner(); // 注意此處變化

inner.print();

}

}

因為main方法在Outer內部，故可以直接引用，不需要屬性引用符。

1.4在main方法中直接產生內部類對象

class Test

{

public static void main(String[] args)

{

Outer outer = new Outer();

Outer.Inner inner = outer.new Inner(); // 注意此處變化

inner.print();

}

}

在利用new構造方法構造一個外部類對象時，並沒有連帶著構造一個內部類對象，故需要訪問內部類方法時，必須使用new操作符為這個外部類對象再構造一個內部類對象。

2、局部內部類

在方法中定義的內部類是局部內部類，它只能訪問方法中的final類型的局部變數，因為用final定義的局部變數相當於是一個常量，延長了其生命周期，使得方法在消亡時，其內部類仍可以訪問該變數。另外，它同樣也可以引用定義在外部類的變數和方法。而且方法體中的局部內部類不允許有訪問修飾符。

class Outer

{

int num=10;

public void print(final int aArgs)

{

class Inner

{

int num=20;

public Inner()

{

System.out.println(“This is Inner.”);//此句可看出它與匿名內部類用法的不同。

}

public void print()

{

int num=30;

System.out.println(this); // the object created from the local Inner

System.out.println(num);

System.out.println(this.num);

System.out.println(Outer.this.num);

System.out.println(aArgs);

}

}

Inner inner=new Inner();//此句必須放在定義類Inner的後面

inner.print();

}

public static void main(String[] args)

{

Outer outer=new Outer();

outer.print(40);

}

}

對於局部類的命名，不管是在一個方法中定義多個類還是在幾個方法中分別定義類，其編譯後命名是：OuterClass$1InnerClass.class

3、匿名內部類

匿名內部類作為一種特殊的內部類，除了具有普通內部類的特點，還有自己的一些獨有特性：

匿名內部類必須擴展一個基類或實現一個介面，但是不能有顯式的extends和implements子句；

匿名內部類必須實現父類以及介面中的所有抽象方法；

匿名內部類總是使用父類的無參構造方法來創建實例。如果是實現了一個介面，則其構造方法是Object()；

匿名內部類編譯後的命名為：OuterClass$n.class，其中n是一個從1開始的整數，如果在一個類中定義了多個匿名內部類，則按照他們的出現順序從1開始排號。

abstract class A

{

abstract public void sayHello();

}

class Outer

{

public static void main(String[] args)

{

new Outer().callInner(new A()

{

public void sayHello()

{

System.out.println(this); // the object created from the anonymous Inner

System.out.println(“Hello!”);

}

});

}

public void callInner(A a)

{

a.sayHello();

}

}

4、靜態內部類

和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態的內部類,才可以聲明一個static成員，靜態內部類可以訪問外圍類的靜態方法、成員（包括private static的成員）。靜態內部類實例化的時候不必先實例化外圍類，可以直接實例化內部類。而對於非靜態內部類則必須先實例化其外部類，才能再實例化本身。

5．內部類的繼承

當一個類繼承自一個內部類時，預設的構造器不可用。必須使用如下語法：

class WithInner

{

class Inner

{

public void sayHello()

{

System.out.println(“Hello.”);

}

}

}

public class Test extends WithInner.Inner

{

Test(WithInner wi)

{

wi.super();

}

public static void main(String[] args)

{

WithInner wi=new WithInner();

Test test=new Test(wi);

test.sayHello();

}

}

因為每一個內部類都有一個指向外部類的引用，在繼承一個內部類，必須先創建一個外部類，通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類，則就不需要這樣，直接super()調用即可；

6、內部類的2種特殊用法

一個類從另一個類派生出來，又要實現一個介面。但在介面中定義的方法與父類中定義的方法的意義不同，則可以利用內部類來解決這個問題。

interface Machine

{

void run();

}

class Person

{

void run()

{

System.out.println(“run”);

}

}

class Robot extends Person

{

private class MachineHeart implements Machine

{

public void run()

{

System.out.println(“heart run”);

}

}

Machine getMachine()

{

return new MachineHeart();

}

}

class Test

{

public static void main(String[] args)

{

Robot robot = new Robot();

Machine m = robot.getMachine();

m.run();

robot.run();

}

}

在Robot類內部使用內部類MachineHeart來實現介面Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現介面Machine，則該如何調用父類的run方法？

利用內部類可解決c++中多重繼承所解決的問題

class A

{

void fn1()

{

System.out.println(“It’ s fn1.”);

}

}

abstract class B

{

abstract void fn2();

}

class C extends A

{

B getB()

{

return new B()

{

public void fn2()

{

System.out.println(“It’ s fn2.”);

}

};

}

}

class Test

{

public static void main(String[] args)

{

C c = new C();

c.fn1();

c.getB().fn2();

}

}

類C既要繼承類A又要繼承類B，則可將類B的定義放入類C內部，使之成為內部類。

一般情況下 當我們需要在某一情形下實現一個介面，而在另一情形下又不需要實現這個介面時，我們可以使用內部類來解決這一問題。讓內部類來實現這個介面。另外一個很好的理由是java內部類加上介面可以有效地實現多重繼承。

java 內部類和外部類的區別？

1. Java項目一般從src目錄開始有com…A.java這樣的目錄結構。這就是包結構。所以一般編譯後的結構是跟包結構一模一樣的，這樣的結構保證了import時能找到正確的class引用包訪問許可權就是指同包下的類可見。

import 一般加上全路徑，並且使用.*時只包含當前目錄的所有類文件，不包括子目錄。

2. 外部類只有public和default兩種修飾，要麼全局可訪問，要麼包內可訪問。

3. 內部類可以有全部訪問許可權，因為它的概念就是一個成員變數，所以訪問許可權設置與一般的成員變數相同。

非靜態內部類是外部類的一個成員變數，只跟外部類的實例有關。

靜態內部類是獨立於外部類存在的一個類，與外部類實例無關，可以通過外部類.內部類直接獲取Class類型。

想要了解更多可以跟我一起討論哦

java內部類與匿名內部類作用分別是什麼？

Java 內部類 \x0d\x0a分四種：成員內部類、局部內部類、靜態內部類和匿名內部類。 \x0d\x0a1、成員內部類： 即作為外部類的一個成員存在，與外部類的屬性、方法並列。\x0d\x0a注意：成員內部類中不能定義靜態變數,但可以訪問外部類的所有成員。\x0d\x0apublic class Outer{\x0d\x0aprivate static int i = 1;\x0d\x0aprivate int j=10;\x0d\x0aprivate int k=20;\x0d\x0apublic static void outer_f1(){\x0d\x0a //do more something\x0d\x0a}\x0d\x0apublic void out_f2(){\x0d\x0a //do more something\x0d\x0a}\x0d\x0a\x0d\x0a//成員內部類\x0d\x0aclass Inner{\x0d\x0a//static int inner_i =100; //內部類中不允許定義靜態變數\x0d\x0aint j=100;//內部類中外部類的實例變數可以共存\x0d\x0aint inner_i=1;\x0d\x0avoid inner_f1(){\x0d\x0a System.out.println(i);//外部類的變數如果和內部類的變數沒有同名的，則可以直接用變數名訪問外部類的變數\x0d\x0a System.out.println(j);//在內部類中訪問內部類自己的變數直接用變數名\x0d\x0a System.out.println(this.j);//也可以在內部類中用”this.變數名”來訪問內部類變數\x0d\x0a //訪問外部類中與內部類同名的實例變數可用”外部類名.this.變數名”。\x0d\x0a System.out.println(k);//外部類的變數如果和內部類的變數沒有同名的，則可以直接用變數名訪問外部類的變數\x0d\x0a outer_f1();\x0d\x0a outer_f2();\x0d\x0a}\x0d\x0a}\x0d\x0a//外部類的非靜態方法訪問成員內部類\x0d\x0apublic void outer_f3(){\x0d\x0a Inner inner = new Inner();\x0d\x0a inner.inner_f1();\x0d\x0a}\x0d\x0a\x0d\x0a//外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣\x0d\x0apublic static void outer_f4(){\x0d\x0a //step1 建立外部類對象\x0d\x0a Outer out = new Outer();\x0d\x0a //***step2 根據外部類對象建立內部類對象***\x0d\x0a Inner inner=out.new Inner();\x0d\x0a //step3 訪問內部類的方法\x0d\x0a inner.inner_f1();\x0d\x0a}\x0d\x0a\x0d\x0apublic static void main(String[] args){\x0d\x0a outer_f4();\x0d\x0a}\x0d\x0a}\x0d\x0a成員內部類的優點：\x0d\x0a⑴ 內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類聲明為PRIVATE，但是對於處於其內部的內部類還是可見的。）\x0d\x0a⑵ 用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問許可權。\x0d\x0a注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。\x0d\x0a2、局部內部類： 即在方法中定義的內部類，與局部變數類似，在局部內部類前不加修飾符public或private，其範圍為定義它的代碼塊。\x0d\x0a注意：局部內部類中不可定義靜態變數，可以訪問外部類的局部變數(即方法內的變數)，但是變數必須是final的。\x0d\x0apublic class Outer {\x0d\x0a private int s = 100;\x0d\x0a private int out_i = 1;\x0d\x0a public void f(final int k){\x0d\x0a final int s = 200;\x0d\x0a int i = 1;\x0d\x0a final int j = 10;\x0d\x0a class Inner{ //定義在方法內部\x0d\x0a int s = 300;//可以定義與外部類同名的變數\x0d\x0a //static int m = 20;//不可以定義靜態變數\x0d\x0a Inner(int k){\x0d\x0a inner_f(k);\x0d\x0a }\x0d\x0a int inner_i = 100;\x0d\x0a void inner_f(int k){\x0d\x0a System.out.println(out_i);//如果內部類沒有與外部類同名的變數，在內部類中可以直接訪問外部類的實例變數\x0d\x0a System.out.println(k);//*****可以訪問外部類的局部變數(即方法內的變數)，但是變數必須是final的*****\x0d\x0a// System.out.println(i);\x0d\x0a System.out.println(s);//如果內部類中有與外部類同名的變數，直接用變數名訪問的是內部類的變數\x0d\x0a System.out.println(this.s);//用”this.變數名” 訪問的也是內部類變數\x0d\x0a System.out.println(Outer.this.s);//用外部”外部類類名.this.變數名” 訪問的是外部類變數\x0d\x0a }\x0d\x0a }\x0d\x0a new Inner(k);\x0d\x0a }\x0d\x0a\x0d\x0a public static void main(String[] args) {\x0d\x0a //訪問局部內部類必須先有外部類對象\x0d\x0a Outer out = new Outer();\x0d\x0a out.f(3);\x0d\x0a }\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0a注意：\x0d\x0a在類外不可直接生成局部內部類（保證局部內部類對外是不可見的）。要想使用局部內部類時需要生成對象，對象調用方法，在方法中才能調用其局部內部類。通過內部類和介面達到一個強制的弱耦合，用局部內部類來實現介面，並在方法中返回介面類型，使局部內部類不可見，屏蔽實現類的可見性。\x0d\x0a\x0d\x0a3、靜態內部類： 靜態內部類定義在類中，任何方法外，用static定義。\x0d\x0a注意：靜態內部類中可以定義靜態或者非靜態的成員\x0d\x0apublic class Outer {\x0d\x0a private static int i = 1;\x0d\x0a private int j = 10;\x0d\x0a public static void outer_f1(){\x0d\x0a \x0d\x0a }\x0d\x0a public void outer_f2(){\x0d\x0a \x0d\x0a }\x0d\x0a// 靜態內部類可以用public,protected,private修飾\x0d\x0a// 靜態內部類中可以定義靜態或者非靜態的成員\x0d\x0a static class Inner{\x0d\x0a static int inner_i = 100;\x0d\x0a int inner_j = 200;\x0d\x0a static void inner_f1(){\x0d\x0a System.out.println(“Outer.i”+i);//靜態內部類只能訪問外部類的靜態成員\x0d\x0a outer_f1();//包括靜態變數和靜態方法\x0d\x0a }\x0d\x0a void inner_f2(){\x0d\x0a// System.out.println(“Outer.i”+j);//靜態內部類不能訪問外部類的非靜態成員\x0d\x0a// outer_f2();//包括非靜態變數和非靜態方法\x0d\x0a } \x0d\x0a \x0d\x0a }\x0d\x0a \x0d\x0a public void outer_f3(){\x0d\x0a// 外部類訪問內部類的靜態成員：內部類.靜態成員\x0d\x0a System.out.println(Inner.inner_i);\x0d\x0a Inner.inner_f1();\x0d\x0a// 外部類訪問內部類的非靜態成員:實例化內部類即可\x0d\x0a Inner inner = new Inner();\x0d\x0a inner.inner_f2();\x0d\x0a \x0d\x0a }\x0d\x0a public static void main(String[] args) {\x0d\x0a new Outer().outer_f3();\x0d\x0a }\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0a注意：*******生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：\x0d\x0aOuter.Inner in=new Outer.Inner()；\x0d\x0a而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類不可用private來進行定義。*******\x0d\x0a\x0d\x0a例子：\x0d\x0a對於兩個類，擁有相同的方法：\x0d\x0aclass People\x0d\x0a{\x0d\x0a run();\x0d\x0a}\x0d\x0aclass Machine{\x0d\x0a run();\x0d\x0a}\x0d\x0a此時有一個robot類：\x0d\x0aclass Robot extends People implement Machine.\x0d\x0a此時run()不可直接實現。\x0d\x0a注意：當類與介面（或者是介面與介面）發生方法命名衝突的時候，此時必須使用內部類來實現。用介面不能完全地實現多繼承，用介面配合內部類才能實現真正的多繼承。\x0d\x0a\x0d\x0a4、匿名內部類 \x0d\x0a匿名內部類是一種特殊的局部內部類，它是通過匿名類實現介面。\x0d\x0aIA被定義為介面。\x0d\x0aIA I=new IA(){};\x0d\x0a\x0d\x0a匿名內部類的特點：\x0d\x0a\x0d\x0a1，一個類用於繼承其他類或是實現介面，並不需要增加額外的方法，只是對繼承方法的事先或是覆蓋。\x0d\x0a2，只是為了獲得一個對象實例，不需要知道其實際類型。\x0d\x0a3，類名沒有意義，也就是不需要使用到。\x0d\x0a\x0d\x0apublic class Outer {\x0d\x0a private static int i = 1;\x0d\x0a private int j = 10;\x0d\x0a public static void outer_f1(){\x0d\x0a \x0d\x0a }\x0d\x0a public void outer_f2(){\x0d\x0a \x0d\x0a }\x0d\x0a// 靜態內部類可以用public,protected,private修飾\x0d\x0a// 靜態內部類中可以定義靜態或者非靜態的成員\x0d\x0a static class Inner{\x0d\x0a static int inner_i = 100;\x0d\x0a int inner_j = 200;\x0d\x0a static void inner_f1(){\x0d\x0a System.out.println(“Outer.i”+i);//靜態內部類只能訪問外部類的靜態成員\x0d\x0a outer_f1();//包括靜態變數和靜態方法\x0d\x0a }\x0d\x0a void inner_f2(){\x0d\x0a// System.out.println(“Outer.i”+j);//靜態內部類不能訪問外部類的非靜態成員\x0d\x0a// outer_f2();//包括非靜態變數和非靜態方法\x0d\x0a }\x0d\x0a }\x0d\x0a \x0d\x0a public void outer_f3(){\x0d\x0a// 外部類訪問內部類的靜態成員：內部類.靜態成員\x0d\x0a System.out.println(Inner.inner_i);\x0d\x0a Inner.inner_f1();\x0d\x0a// 外部類訪問內部類的非靜態成員:實例化內部類即可\x0d\x0a Inner inner = new Inner();\x0d\x0a inner.inner_f2();\x0d\x0a \x0d\x0a }\x0d\x0a public static void main(String[] args) {\x0d\x0a new Outer().outer_f3();\x0d\x0a }\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0a註：一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類，沒有類名，根據多態，我們使用其父類名。因他是局部內部類，那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面，那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法，所以其使用範圍非常的有限。當需要多個對象時使用局部內部類，因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面，那麼其運行的類型為實現這個介面的類。\x0d\x0a\x0d\x0a________________________________________________________________________________\x0d\x0a\x0d\x0a內部類總結：\x0d\x0a1.首先，把內部類作為外部類的一個特殊的成員來看待，因此它有類成員的封閉等級：private ,protected,默認(friendly),public\x0d\x0a 它有類成員的修飾符: static,final,abstract\x0d\x0a2.非靜態內部類nested inner class,內部類隱含有一個外部類的指針this,因此，它可以訪問外部類的一切資源（當然包括private）\x0d\x0a 外部類訪問內部類的成員，先要取得內部類的對象,並且取決於內部類成員的封裝等級。\x0d\x0a 非靜態內部類不能包含任何static成員.\x0d\x0a3.靜態內部類：static inner class,不再包含外部類的this指針，並且在外部類裝載時初始化.\x0d\x0a 靜態內部類能包含static或非static成員.\x0d\x0a 靜態內部類只能訪問外部類static成員.\x0d\x0a 外部類訪問靜態內部類的成員，循一般類法規。對於static成員，用類名.成員即可訪問，對於非static成員，只能\x0d\x0a 用對象.成員進行訪問\x0d\x0a\x0d\x0a4.對於方法中的內部類或塊中內部類只能訪問塊中或方法中的final變數。\x0d\x0a\x0d\x0a類成員有兩種static , non-static，同樣內部類也有這兩種\x0d\x0anon-static 內部類的實例，必須在外部類的方法中創建或通過外部類的實例來創建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),並且可直接訪問外部類的信息,外部類對象可通過OuterClassName.this來引用\x0d\x0astatic 內部類的實例, 直接創建即可，沒有對外部類實例的引用。\x0d\x0a內部類不管static還是non-static都有對外部類的引用\x0d\x0anon-static 內部類不允許有static成員\x0d\x0a\x0d\x0a方法中的內部類只允許訪問方法中的final局部變數和方法的final參數列表，所以說方法中的內部類和內部類沒什麽區別。但方法中的內部類不能在方法以外訪問，方法中不可以有static內部類\x0d\x0a匿名內部類如果繼承自介面,必須實現指定介面的方法,且無參數 \x0d\x0a匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞

java裡面的內部類和外部類是什麼?_?

外部類：

最普通的，我們平時見到的那種類，就是在一個後綴為.java的文件中，直接定義的類

內部類：

內部類，顧名思義，就是包含在外部類中的類，就叫做內部類。內部類有兩種，一種是靜態內部類，一種是非靜態內部類。

靜態內部類和非靜態內部類之間的區別主要如下：

1、內部原理的區別：

靜態內部類是屬於外部類的類成員，是一種靜態的成員，是屬於類的，就有點類似於private static Singleton instance = null；非靜態內部類，是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的，也就是說，每個非靜態內部類，不是屬於外部類的，是屬於外部類的每一個實例的，創建非靜態內部類的實例以後，非靜態內部類實例，是必須跟一個外部類的實例進行關聯和有寄存關係的。

2、創建方式的區別：

創建靜態內部類的實例的時候，只要直接使用「外部類.內部類()」的方式，就可以，比如School.Teacher()；創建非靜態內部類的實例的時候，必須要先創建一個外部類的實例，然後通過外部類的實例，再來創建內部類的實例，new School().Teacher()

通常來說，我們一般都會為了方便，會選擇使用靜態內部類。