一、內(nèi)部類:　

（1）內(nèi)部類的同名方法

內(nèi)部類可以調(diào)用外部類的方法，如果內(nèi)部類有同名方法必須使用'OuterClass.this.MethodName()'格式調(diào)用（其中OuterClass與MethodName換成實際外部類名及其方法；this為關(guān)鍵字，表示對外部類的引用）；若內(nèi)部類無同名方法可以直接調(diào)用外部類的方法。

但外圍類無法直接調(diào)用內(nèi)部類的private方法，外部類同樣無法直接調(diào)用其它類的private方法。注意：內(nèi)部類直接使用外部類的方法與該方法的權(quán)限與是否static無關(guān)，它取決于內(nèi)部類是否有同名方法。

package innerclass;public class OuterClass { private void outerMethod() { System.out.println('It’s Method of OuterClass'); } public static void main(String[] args) { OuterClass t = new OuterClass(); OuterClass.Innerclass in = t.new Innerclass(); in.innerMethod(); } class Innerclass { public void innerMethod() { OuterClass.this.outerMethod();// 內(nèi)部類成員方法與外部類成員方法同名時，使用this調(diào)用外部類的方法 outerMethod();// 內(nèi)部類沒有同名方法時執(zhí)行外部類的方法 } private void outerMethod() { System.out.println('It’s Method of Innerclass'); } }}

輸出結(jié)果為：

It’s Method of OuterClass

It’s Method of Innerclass

（2）內(nèi)部類訪問外部類的變量必須聲明為final

方法中的局部變量，方法結(jié)束后這個變量就要釋放掉，final保證這個變量始終指向一個對象。

首先，內(nèi)部類和外部類其實是處于同一個級別，內(nèi)部類不會因為定義在方法中就會隨著方法的執(zhí)行完畢而跟隨者被銷毀。問題就來了，如果外部類的方法中的變量不定義final，那么當(dāng)外部類方法執(zhí)行完畢的時候，這個局部變量肯定也就被GC了，然而內(nèi)部類的某個方法還沒有執(zhí)行完，這個時候他所引用的外部變量已經(jīng)找不到了。如果定義為final，java會將這個變量復(fù)制一份作為成員變量內(nèi)置于內(nèi)部類中，這樣的話，由于final所修飾的值始終無法改變，所以這個變量所指向的內(nèi)存區(qū)域就不會變。

注意，若使用JDK1.8，方法中內(nèi)部類的方法是可以直接訪問外部類的方法的局部變量，并且不需要聲明為final類型。

public class OuterClass { int num1 = 0;// 成員變量 private void outerMethod() { int num2 = 0;// 方法內(nèi)的局部變量 class Innerclass_1 { public void innerMethod() { System.out.println(num1);// 方法中內(nèi)部類的方法，可以正常訪問外部類的成員變量 System.out.println(num2);// JDK1.8以前，方法中內(nèi)部類的方法，不能直接訪問外部類的方法的局部變量，必須聲明為final } } }}

如果使用JDK1.8以前的版本，Eclipse會出現(xiàn)如下錯誤提示：

（3）內(nèi)部類的實例化

內(nèi)部類實例化不同于普通類，普通類可以在任意需要的時候?qū)嵗鴥?nèi)部類必須在外層類實例化以后方可實例化，并與外部類建立關(guān)系

因此在外部類中的非static方法中，是可以實例化內(nèi)部類對象

private void outerMethod() { System.out.println('It’s Method of OuterClass'); Innerclass in = new Innerclass();//在外部類的outerMethod方法中實例化內(nèi)部類是可以啊 }

但在static方法中，就要注意啦！！！！不能在static方法中直接new內(nèi)部類，否則出現(xiàn)錯誤：

No enclosing instance of type OuterClass is accessible. Must qualify the allocation with an enclosing instance of type OuterClass (e.g. x.new A() where x is an instance of OuterClass).

這是因為靜態(tài)方法是在類實例化之前就可以使用的，通過類名調(diào)用，這時動態(tài)內(nèi)部類都還沒實例化呢，怎么用，總不能調(diào)用一個不存在的東西吧。

如果想在Static方法中new內(nèi)部類，可以把內(nèi)部類聲明為Static

public class OuterClass { private void outerMethod() { System.out.println('It’s Method of OuterClass'); } public static void main(String[] args) { Innerclass in = new Innerclass(); in.innerMethod(); } static class Innerclass {//把內(nèi)部類聲明為static public void innerMethod() { System.out.println('It’s Method of innerMethod'); } } }

當(dāng)然，一般不使用static的方式，而是推薦這種方法：x.new A() ，其中 x是外部類OuterClass的實例，A是內(nèi)部類Innerclass

package innerclass;public class OuterClass { private void outerMethod() { System.out.println('It’s Method of OuterClass'); } public static void main(String[] args) { OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式 in.innerMethod(); } class Innerclass { public void innerMethod() { System.out.println('It’s Method of innerMethod'); } }}

x.new A() ，其中 x是外部類OuterClass的實例，A是類部類Innerclass，當(dāng)然可以拆分如下，這樣就顯然很明白啦：

public static void main(String[] args) { OuterClass out = new OuterClass();//外部實例 OuterClass.Innerclass in = out.new Innerclass();//外部實例.new 外部類 in.innerMethod(); }

（4）什么情況下使用內(nèi)部類

典型的情況是，內(nèi)部類繼承自某個類或?qū)崿F(xiàn)某個接口，內(nèi)部類的代碼操作創(chuàng)建其的外層類的對象。所以你可以認(rèn)為內(nèi)部類提供了某種進(jìn)入其外層類的窗口。

使用內(nèi)部類最吸引人的原因是：每個內(nèi)部類都能獨立地繼承自一個（接口的）實現(xiàn)，所以無論外層類是否已經(jīng)繼承了某個（接口的）實現(xiàn)，對于內(nèi)部類都沒有影響。如果沒有內(nèi)部類提供的可以繼承多個具體的或抽象的類的能力，一些設(shè)計與編程問題就很難解決。從這個角度看，內(nèi)部類使得多重繼承的解決方案變得完整。接口解決了部分問題，而內(nèi)部類有效地實現(xiàn)了“多重繼承”。

（5）在靜態(tài)方法中實例化內(nèi)部類例子：（內(nèi)部類放在靜態(tài)方法中）

package javatest2;public class JavaTest2 { public static void main(String[] args) { class Boy implements Person { public void say() {// 匿名內(nèi)部類自定義的方法say System.out.println('say方法調(diào)用'); } @Override public void speak() {// 實現(xiàn)接口的的方法speak System.out.println('speak方法調(diào)用'); } } Person per = new Boy(); per.speak();// 可調(diào)用 per.say();// 不能調(diào)用 }}interface Person { public void speak();}

per.speak()可調(diào)用，而per.say()不能調(diào)用，這時因為per是Person對象，要想調(diào)用子類的方法，可以強制向下轉(zhuǎn)型為：((Boy) per).say();或者直接改為Boy per = new Boy();。從中可發(fā)現(xiàn)，要想調(diào)用內(nèi)部類的自定義的方法，必須通過內(nèi)部類的對象來調(diào)用。那么，匿名內(nèi)部類連名字都沒有，怎么調(diào)用內(nèi)部類自定義的方法？

（二）匿名內(nèi)部類

匿名內(nèi)部類也就是沒有名字的內(nèi)部類正因為沒有名字，所以匿名內(nèi)部類只能使用一次，它通常用來簡化代碼編寫，但使用匿名內(nèi)部類還有個前提條件：必須繼承一個父類或?qū)崿F(xiàn)一個接口，但最多只能繼承一個父類，或?qū)崿F(xiàn)一個接口。

關(guān)于匿名內(nèi)部類還有如下兩條規(guī)則：

1）匿名內(nèi)部類不能是抽象類，因為系統(tǒng)在創(chuàng)建匿名內(nèi)部類的時候，會立即創(chuàng)建內(nèi)部類的對象。因此不允許將匿名內(nèi)部類定義成抽象類。

2）匿名內(nèi)部類不等定義構(gòu)造器（構(gòu)造方法），因為匿名內(nèi)部類沒有類名，所以無法定義構(gòu)造器，但匿名內(nèi)部類可以定義實例初始化塊，

怎樣判斷一個匿名類的存在啊？看不見名字，感覺只是父類new出一個對象而已，沒有匿名類的名字。

先看段偽代碼

abstract class Father(){....}public class Test{ Father f1 = new Father(){ .... } //這里就是有個匿名內(nèi)部類}

一般來說，new 一個對象時小括號后應(yīng)該是分號，也就是new出對象該語句就結(jié)束了。但是出現(xiàn)匿名內(nèi)部類就不一樣，小括號后跟的是大括號，大括號中是該new 出對象的具體的實現(xiàn)方法。因為我們知道，一個抽象類是不能直接new 的，必須先有實現(xiàn)類了我們才能new出它的實現(xiàn)類。上面的偽代碼就是表示new 的是Father的實現(xiàn)類，這個實現(xiàn)類是個匿名內(nèi)部類。

其實拆分上面的匿名內(nèi)部類可為：

class SonOne extends Father{ ... //這里的代碼和上面匿名內(nèi)部類，大括號中的代碼是一樣的}public class Test{ Father f1 = new SonOne() ;}

先看一個例子，體會一下匿名內(nèi)部類的用法：

運行結(jié)果：eat something

可以看到，我們直接將抽象類Person中的方法在大括號中實現(xiàn)了，這樣便可以省略一個類的書寫。并且，匿名內(nèi)部類還能用于接口上

public class JavaTest2 { public static void main(String[] args) { Person per = new Person() { public void say() {// 匿名內(nèi)部類自定義的方法say System.out.println('say方法調(diào)用'); } @Override public void speak() {// 實現(xiàn)接口的的方法speak System.out.println('speak方法調(diào)用'); } }; per.speak();// 可調(diào)用 per.say();// 出錯，不能調(diào)用 }} interface Person { public void speak();}

這里per.speak()是可以正常調(diào)用的，但per.say()不能調(diào)用，為什么呢？注意Person per = new Person()創(chuàng)建的是Person的對象，而非匿名內(nèi)部類的對象。其實匿名內(nèi)部類連名字都沒有，你咋實例對象去調(diào)用它的方法呢？但繼承父類的方法和實現(xiàn)的方法是可以正常調(diào)用的，本例子中，匿名內(nèi)部類實現(xiàn)了接口Person的speak方法，因此可以借助Person的對象去調(diào)用。

若你確實想調(diào)用匿名內(nèi)部類的自定義的方法say()，當(dāng)然也有方法：

（1）類似于speak方法的使用，先在Person接口中聲明say()方法，再在匿名內(nèi)部類中覆寫此方法。

（2）其實匿名內(nèi)部類中隱含一個匿名對象，通過該方法可以直接調(diào)用say()和speak()方法；代碼修改如下：

public class JavaTest2 { public static void main(String[] args) { new Person() { public void say() {// 匿名內(nèi)部類自定義的方法say System.out.println('say方法調(diào)用'); } @Override public void speak() {// 實現(xiàn)接口的的方法speak System.out.println('speak方法調(diào)用'); } }.say();// 直接調(diào)用匿名內(nèi)部類的方法 }}interface Person { public void speak();}

補充知識： Java內(nèi)部類的定義、如何創(chuàng)建內(nèi)部類、內(nèi)部類的分類、內(nèi)部類與外部類的關(guān)系

1. 內(nèi)部類的基本概念

1.1 內(nèi)部類的定義

內(nèi)部類： 所謂內(nèi)部類就是在一個類內(nèi)部進(jìn)行其他類結(jié)構(gòu)的嵌套操作。

class Outer{ private String str ='外部類中的字符串'; //************************** //定義一個內(nèi)部類 class Inner{ private String inStr= '內(nèi)部類中的字符串'; //定義一個普通方法 public void print(){ //調(diào)用外部類的str屬性 System.out.println(str); } } //************************** //在外部類中定義一個方法，該方法負(fù)責(zé)產(chǎn)生內(nèi)部類對象并調(diào)用print()方法 public void fun(){ //內(nèi)部類對象 Inner in = new Inner(); //內(nèi)部類對象提供的print in.print(); }}public class Test{ public static void main(String[] args) { //創(chuàng)建外部類對象 Outer out = new Outer(); //外部類方法 out.fun(); }}

運行結(jié)果：外部類中的字符串

但是如果去掉內(nèi)部類：

class Outer{ private String outStr ='Outer中的字符串'; public String getOutStr() { return outStr; } public void fun(){ //2 //this表示當(dāng)前對象 Inner in = new Inner(this); //3 in.print(); //5 }}class Inner{ private String inStr= 'Inner中的字符串'; private Outer out; //構(gòu)造注入 public Inner(Outer out) //3 { this.out=out; //4.為Inner中的out變量初始化 } public void print(){ //6 System.out.println(out.getOutStr()); //7 }} public class Test{ public static void main(String[] args) { Outer out = new Outer(); //1. out.fun(); //2. }}

執(zhí)行結(jié)果：Outer中的字符串

但是去掉內(nèi)部類之后發(fā)現(xiàn)程序更加難以理解。

1.2 內(nèi)部類的優(yōu)缺點

內(nèi)部類的優(yōu)點:

內(nèi)部類與外部類可以方便的訪問彼此的私有域（包括私有方法、私有屬性）。

內(nèi)部類是另外一種封裝，對外部的其他類隱藏。

內(nèi)部類可以實現(xiàn)java的單繼承局限。

內(nèi)部類的缺點:

結(jié)構(gòu)復(fù)雜。

記錄：使用內(nèi)部類實現(xiàn)多繼承：

class A { private String name = 'A類的私有域'; public String getName() { return name; }}class B { private int age = 20; public int getAge() { return age; }}class Outter { private class InnerClassA extends A { public String name() { return super.getName(); }} private class InnerClassB extends B { public int age() { return super.getAge(); }} public String name() { return new InnerClassA().name(); } public int age() { return new InnerClassB().age(); }}public class Test2 { public static void main(String[] args) { Outter outter = new Outter(); System.out.println(outter.name()); System.out.println(outter.age()); }}

2. 創(chuàng)建內(nèi)部類

2.1 在外部類外部 創(chuàng)建非靜態(tài)內(nèi)部類

語法： 外部類.內(nèi)部類 內(nèi)部類對象 = new 外部類().new 內(nèi)部類();

舉例： Outer.Inner in = new Outer().new Inner();

2.2 在外部類外部 創(chuàng)建靜態(tài)內(nèi)部類

語法： 外部類.內(nèi)部類 內(nèi)部類對象 = new 外部類.內(nèi)部類();

舉例： Outer.Inner in = new Outer.Inner();

2.3 在外部類內(nèi)部創(chuàng)建內(nèi)部類語法

在外部類內(nèi)部創(chuàng)建內(nèi)部類，就像普通對象一樣直接創(chuàng)建：Inner in = new Inner();

3. 內(nèi)部類的分類

在Java中內(nèi)部類主要分為成員內(nèi)部類、靜態(tài)內(nèi)部類、方法內(nèi)部類、匿名內(nèi)部類

3.1 成員內(nèi)部類

類比成員方法

成員內(nèi)部類內(nèi)部不允許存在任何static變量或方法 正如成員方法中不能有任何靜態(tài)屬性 （成員方法與對象相關(guān)、靜態(tài)屬性與類有關(guān)）

class Outer { private String name = 'test'; public static int age =20; class Inner{ public static int num =10; public void fun() { System.out.println(name); System.out.println(age); } }}public class Test{ public static void main(String [] args) {}}

2. 成員內(nèi)部類是依附外部類的，只有創(chuàng)建了外部類才能創(chuàng)建內(nèi)部類。

3.2 靜態(tài)內(nèi)部類

關(guān)鍵字static可以修飾成員變量、方法、代碼塊、其實還可以修飾內(nèi)部類，使用static修飾的內(nèi)部類我們稱之為靜態(tài)內(nèi)部類，靜態(tài)內(nèi)部類和非靜態(tài)內(nèi)部類之間存在一個最大的區(qū)別，非靜態(tài)內(nèi)部類在編譯完成之后會隱含的保存著一個引用，該引用是指向創(chuàng)建它的外圍類，但是靜態(tài)類沒有。沒有這個引用就意味著：

1.靜態(tài)內(nèi)部類的創(chuàng)建不需要依賴外部類可以直接創(chuàng)建。

2.靜態(tài)內(nèi)部類不可以使用任何外部類的非static類（包括屬性和方法），但可以存在自己的成員變量。

class Outer { public String name = 'test'; private static int age =20; static class Inner{ private String name; public void fun() { System.out.println(name); System.out.println(age); } }}public class Test{ public static void main(String [] args) { Outer.Inner in = new Outer.Inner(); }}

3.3 方法內(nèi)部類

方法內(nèi)部類顧名思義就是定義在方法里的類

1.方法內(nèi)部類不允許使用訪問權(quán)限修飾符（public、private、protected）均不允許。

class Outer{ private int num =5; public void dispaly(final int temp) { //方法內(nèi)部類即嵌套在方法里面 public class Inner{ } }}public class Test{ public static void main(String[] args) {}}

2. 方法內(nèi)部類對外部完全隱藏，除了創(chuàng)建這個類的方法可以訪問它以外，其他地方均不能訪問 (換句話說其他方法或者類都不知道有這個類的存在)方法內(nèi)部類對外部完全隱藏，出了創(chuàng)建這個類的方法可以訪問它，其他地方均不能訪問。

3. 方法內(nèi)部類如果想要使用方法形參，該形參必須使用final聲明（JDK8形參變?yōu)殡[式final聲明）

class Outer{ private int num =5; //普通方法 public void dispaly(int temp) { //方法內(nèi)部類即嵌套在方法里面 class Inner{ public void fun() {System.out.println(num);temp++;System.out.println(temp); } } //方法內(nèi)部類在方法里面創(chuàng)建 new Inner().fun(); }}public class Test{ public static void main(String[] args) { Outer out = new Outer(); out.dispaly(2); }}

3.4 匿名內(nèi)部類

匿名內(nèi)部類就是一個沒有名字的方法內(nèi)部類，因此特點和方法與方法內(nèi)部類完全一致，除此之外，還有自己的特點：

1.匿名內(nèi)部類必須繼承一個抽象類或者實現(xiàn)一個接口。

2.匿名內(nèi)部類沒有類名，因此沒有構(gòu)造方法。

//匿名內(nèi)部類//聲明一個接口interface MyInterface { //接口中方法沒有方法體 void test();}class Outer{ private int num = 5; public void dispaly(int temp) { //匿名內(nèi)部類，匿名的實現(xiàn)了MyInterface接口 //隱藏的class聲明 new MyInterface() { public void test() {System.out.println('匿名實現(xiàn)MyInterface接口');System.out.println(temp); } }.test(); }}public class Test{ public static void main(String[] args) { Outer out = new Outer(); out.dispaly(3); }}

4. 內(nèi)部類與外部類的關(guān)系

對于非靜態(tài)的內(nèi)部類，內(nèi)部類的創(chuàng)建依賴外部類的實例對象，在沒有外部類實例之前是無法創(chuàng)建內(nèi)部類的。內(nèi)部類可以直接訪問外部類的元素（包括私有域）—外部類在內(nèi)部類之前創(chuàng)建，創(chuàng)建內(nèi)部類時會將外部類的對象傳入

class Outer{ //成員變量 與對象有關(guān) private String msg; private int age; //-------------------------- class Inner{ public void dispaly() { //此處有一個隱藏的Outer.this msg = 'test'; age = 20; System.out.println(msg); System.out.println(age); } } //-------------------------- public void test() { Inner in = new Inner(); in.dispaly(); }}public class Test{ public static void main(String[] args) { Outer out = new Outer(); out.test(); }}

外部類可以通過內(nèi)部類的引用間接訪問內(nèi)部類元素 ? -要想訪問內(nèi)部類屬性，必須先創(chuàng)建內(nèi)部類對象

class Outer{ public void dispaly() { //外部類通過創(chuàng)建內(nèi)部類的對象間接訪問內(nèi)部類元素 Inner in = new Inner(); in.dispaly(); } class Inner{ public void dispaly() { System.out.println('內(nèi)部類'); } }}public class Test1{ public static void main(String[] args) { Outer out = new Outer(); out.dispaly(); }}

內(nèi)部類是一個相對獨立的個體，與外部類沒有關(guān)系。

以上這篇Java內(nèi)部類和匿名內(nèi)部類的用法說明就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持好吧啦網(wǎng)。