Java內部類和匿名內部類的用法說明
一、內部類:
（1）內部類的同名方法
內部類可以調用外部類的方法，如果內部類有同名方法必須使用"OuterClass.this.MethodName()"格式調用（其中OuterClass與MethodName換成實際外部類名及其方法；this為關鍵字，表示對外部類的引用）；若內部類無同名方法可以直接調用外部類的方法。
但外圍類無法直接調用內部類的private方法，外部類同樣無法直接調用其它類的private方法。注意：內部類直接使用外部類的方法與該方法的權限與是否static無關，它取決于內部類是否有同名方法。
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();// 內部類成員方法與外部類成員方法同名時，使用this調用外部類的方法
outerMethod();// 內部類沒有同名方法時執(zhí)行外部類的方法
}
private void outerMethod() {
System.out.println("It's Method of Innerclass");
}
}
}
輸出結果為：
It's Method of OuterClass
It's Method of Innerclass
（2）內部類訪問外部類的變量必須聲明為final
方法中的局部變量，方法結束后這個變量就要釋放掉，final保證這個變量始終指向一個對象。
首先，內部類和外部類其實是處于同一個級別，內部類不會因為定義在方法中就會隨著方法的執(zhí)行完畢而跟隨者被銷毀。問題就來了，如果外部類的方法中的變量不定義final，那么當外部類方法執(zhí)行完畢的時候，這個局部變量肯定也就被GC了，然而內部類的某個方法還沒有執(zhí)行完，這個時候他所引用的外部變量已經找不到了。如果定義為final，java會將這個變量復制一份作為成員變量內置于內部類中，這樣的話，由于final所修飾的值始終無法改變，所以這個變量所指向的內存區(qū)域就不會變。
注意，若使用JDK1.8，方法中內部類的方法是可以直接訪問外部類的方法的局部變量，并且不需要聲明為final類型。
public class OuterClass {
int num1 = 0;// 成員變量
private void outerMethod() {
int num2 = 0;// 方法內的局部變量
class Innerclass_1 {
public void innerMethod() {
System.out.println(num1);// 方法中內部類的方法，可以正常訪問外部類的成員變量
System.out.println(num2);// JDK1.8以前，方法中內部類的方法，不能直接訪問外部類的方法的局部變量，必須聲明為final
}
}
}
}
如果使用JDK1.8以前的版本，Eclipse會出現(xiàn)如下錯誤提示：
（3）內部類的實例化
內部類實例化不同于普通類，普通類可以在任意需要的時候實例化，而內部類必須在外層類實例化以后方可實例化，并與外部類建立關系
因此在外部類中的非static方法中，是可以實例化內部類對象
private void outerMethod() {
System.out.println("It's Method of OuterClass");
Innerclass in = new Innerclass();//在外部類的outerMethod方法中實例化內部類是可以啊
}
但在static方法中，就要注意啦?。。?！不能在static方法中直接new內部類，否則出現(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)方法是在類實例化之前就可以使用的，通過類名調用，這時動態(tài)內部類都還沒實例化呢，怎么用，總不能調用一個不存在的東西吧。
如果想在Static方法中new內部類，可以把內部類聲明為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 {//把內部類聲明為static
public void innerMethod() {
System.out.println("It's Method of innerMethod");
}
}
}
當然，一般不使用static的方式，而是推薦這種方法：x.new A() ，其中 x是外部類OuterClass的實例，A是內部類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，當然可以拆分如下，這樣就顯然很明白啦：
public static void main(String[] args) {
OuterClass out = new OuterClass();//外部實例
OuterClass.Innerclass in = out.new Innerclass();//外部實例.new 外部類
in.innerMethod();
}
（4）什么情況下使用內部類
典型的情況是，內部類繼承自某個類或實現(xiàn)某個接口，內部類的代碼操作創(chuàng)建其的外層類的對象。所以你可以認為內部類提供了某種進入其外層類的窗口。
使用內部類最吸引人的原因是：每個內部類都能獨立地繼承自一個（接口的）實現(xiàn)，所以無論外層類是否已經繼承了某個（接口的）實現(xiàn)，對于內部類都沒有影響。如果沒有內部類提供的可以繼承多個具體的或抽象的類的能力，一些設計與編程問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。接口解決了部分問題，而內部類有效地實現(xiàn)了“多重繼承”。
（5）在靜態(tài)方法中實例化內部類例子：（內部類放在靜態(tài)方法中）
package javatest2;
public class JavaTest2 {
public static void main(String[] args) {
class Boy implements Person {
public void say() {// 匿名內部類自定義的方法say
System.out.println("say方法調用");
}
@Override
public void speak() {// 實現(xiàn)接口的的方法speak
System.out.println("speak方法調用");
}
}
Person per = new Boy();
per.speak();// 可調用
per.say();// 不能調用
}
}
interface Person {
public void speak();
}
per.speak()可調用，而per.say()不能調用，這時因為per是Person對象，要想調用子類的方法，可以強制向下轉型為：((Boy) per).say();或者直接改為Boy per = new Boy();。從中可發(fā)現(xiàn)，要想調用內部類的自定義的方法，必須通過內部類的對象來調用。那么，匿名內部類連名字都沒有，怎么調用內部類自定義的方法？
（二）匿名內部類
匿名內部類也就是沒有名字的內部類正因為沒有名字，所以匿名內部類只能使用一次，它通常用來簡化代碼編寫，但使用匿名內部類還有個前提條件：必須繼承一個父類或實現(xiàn)一個接口，但最多只能繼承一個父類，或實現(xiàn)一個接口。
關于匿名內部類還有如下兩條規(guī)則：
1）匿名內部類不能是抽象類，因為系統(tǒng)在創(chuàng)建匿名內部類的時候，會立即創(chuàng)建內部類的對象。因此不允許將匿名內部類定義成抽象類。
2）匿名內部類不等定義構造器（構造方法），因為匿名內部類沒有類名，所以無法定義構造器，但匿名內部類可以定義實例初始化塊，
怎樣判斷一個匿名類的存在啊？看不見名字，感覺只是父類new出一個對象而已，沒有匿名類的名字。
先看段偽代碼
abstract class Father(){
....
}
public class Test{
Father f1 = new Father(){ .... } //這里就是有個匿名內部類
}
一般來說，new 一個對象時小括號后應該是分號，也就是new出對象該語句就結束了。但是出現(xiàn)匿名內部類就不一樣，小括號后跟的是大括號，大括號中是該new 出對象的具體的實現(xiàn)方法。因為我們知道，一個抽象類是不能直接new 的，必須先有實現(xiàn)類了我們才能new出它的實現(xiàn)類。上面的偽代碼就是表示new 的是Father的實現(xiàn)類，這個實現(xiàn)類是個匿名內部類。
其實拆分上面的匿名內部類可為：
class SonOne extends Father{
... //這里的代碼和上面匿名內部類，大括號中的代碼是一樣的
}
public class Test{
Father f1 = new SonOne() ;
}
先看一個例子，體會一下匿名內部類的用法：
運行結果：eat something
可以看到，我們直接將抽象類Person中的方法在大括號中實現(xiàn)了，這樣便可以省略一個類的書寫。并且，匿名內部類還能用于接口上
public class JavaTest2 {
public static void main(String[] args) {
Person per = new Person() {
public void say() {// 匿名內部類自定義的方法say
System.out.println("say方法調用");
}
@Override
public void speak() {// 實現(xiàn)接口的的方法speak
System.out.println("speak方法調用");
}
};
per.speak();// 可調用
per.say();// 出錯，不能調用
}
}
interface Person {
public void speak();
}
這里per.speak()是可以正常調用的，但per.say()不能調用，為什么呢？注意Person per = new Person()創(chuàng)建的是Person的對象，而非匿名內部類的對象。其實匿名內部類連名字都沒有，你咋實例對象去調用它的方法呢？但繼承父類的方法和實現(xiàn)的方法是可以正常調用的，本例子中，匿名內部類實現(xiàn)了接口Person的speak方法，因此可以借助Person的對象去調用。
若你確實想調用匿名內部類的自定義的方法say()，當然也有方法：
（1）類似于speak方法的使用，先在Person接口中聲明say()方法，再在匿名內部類中覆寫此方法。
（2）其實匿名內部類中隱含一個匿名對象，通過該方法可以直接調用say()和speak()方法；代碼修改如下：
public class JavaTest2 {
public static void main(String[] args) {
new Person() {
public void say() {// 匿名內部類自定義的方法say
System.out.println("say方法調用");
}
@Override
public void speak() {// 實現(xiàn)接口的的方法speak
System.out.println("speak方法調用");
}
}.say();// 直接調用匿名內部類的方法
}
}
interface Person {
public void speak();
}
補充知識： Java內部類的定義、如何創(chuàng)建內部類、內部類的分類、內部類與外部類的關系
1. 內部類的基本概念
1.1 內部類的定義
內部類： 所謂內部類就是在一個類內部進行其他類結構的嵌套操作。
class Outer{
private String str ="外部類中的字符串";
//**************************
//定義一個內部類
class Inner{
private String inStr= "內部類中的字符串";
//定義一個普通方法
public void print(){
//調用外部類的str屬性
System.out.println(str);
}
}
//**************************
//在外部類中定義一個方法，該方法負責產生內部類對象并調用print()方法
public void fun(){
//內部類對象
Inner in = new Inner();
//內部類對象提供的print
in.print();
}
}
public class Test{
public static void main(String[] args)
{
//創(chuàng)建外部類對象
Outer out = new Outer();
//外部類方法
out.fun();
}
}
運行結果：外部類中的字符串
但是如果去掉內部類：
class Outer{
private String outStr ="Outer中的字符串";
public String getOutStr()
{
return outStr;
}
public void fun(){ //2
//this表示當前對象
Inner in = new Inner(this); //3
in.print(); //5
}
}
class Inner{
private String inStr= "Inner中的字符串";
private Outer out;
//構造注入
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í)行結果：Outer中的字符串
但是去掉內部類之后發(fā)現(xiàn)程序更加難以理解。
1.2 內部類的優(yōu)缺點
內部類的優(yōu)點:
內部類與外部類可以方便的訪問彼此的私有域（包括私有方法、私有屬性）。
內部類是另外一種封裝，對外部的其他類隱藏。
內部類可以實現(xiàn)java的單繼承局限。
內部類的缺點:
結構復雜。
記錄：使用內部類實現(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)建內部類
2.1 在外部類外部 創(chuàng)建非靜態(tài)內部類
語法： 外部類.內部類 內部類對象 = new 外部類().new 內部類();
舉例： Outer.Inner in = new Outer().new Inner();
2.2 在外部類外部 創(chuàng)建靜態(tài)內部類
語法： 外部類.內部類 內部類對象 = new 外部類.內部類();
舉例： Outer.Inner in = new Outer.Inner();
2.3 在外部類內部創(chuàng)建內部類語法
在外部類內部創(chuàng)建內部類，就像普通對象一樣直接創(chuàng)建：Inner in = new Inner();
3. 內部類的分類
在Java中內部類主要分為成員內部類、靜態(tài)內部類、方法內部類、匿名內部類
3.1 成員內部類
類比成員方法
成員內部類內部不允許存在任何static變量或方法 正如成員方法中不能有任何靜態(tài)屬性 （成員方法與對象相關、靜態(tài)屬性與類有關）
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. 成員內部類是依附外部類的，只有創(chuàng)建了外部類才能創(chuàng)建內部類。
3.2 靜態(tài)內部類
關鍵字static可以修飾成員變量、方法、代碼塊、其實還可以修飾內部類，使用static修飾的內部類我們稱之為靜態(tài)內部類，靜態(tài)內部類和非靜態(tài)內部類之間存在一個最大的區(qū)別，非靜態(tài)內部類在編譯完成之后會隱含的保存著一個引用，該引用是指向創(chuàng)建它的外圍類，但是靜態(tài)類沒有。沒有這個引用就意味著：
1.靜態(tài)內部類的創(chuàng)建不需要依賴外部類可以直接創(chuàng)建。
2.靜態(tà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 方法內部類
方法內部類顧名思義就是定義在方法里的類
1.方法內部類不允許使用訪問權限修飾符（public、private、protected）均不允許。
class Outer{
private int num =5;
public void dispaly(final int temp)
{
//方法內部類即嵌套在方法里面
public class Inner{
}
}
}
public class Test{
public static void main(String[] args)
{}
}
2. 方法內部類對外部完全隱藏，除了創(chuàng)建這個類的方法可以訪問它以外，其他地方均不能訪問 (換句話說其他方法或者類都不知道有這個類的存在)方法內部類對外部完全隱藏，出了創(chuàng)建這個類的方法可以訪問它，其他地方均不能訪問。
3. 方法內部類如果想要使用方法形參，該形參必須使用final聲明（JDK8形參變?yōu)殡[式final聲明）
class Outer{
private int num =5;
//普通方法
public void dispaly(int temp)
{
//方法內部類即嵌套在方法里面
class Inner{
public void fun()
{
System.out.println(num);
temp++;
System.out.println(temp);
}
}
//方法內部類在方法里面創(chuàng)建
new Inner().fun();
}
}
public class Test{
public static void main(String[] args)
{
Outer out = new Outer();
out.dispaly(2);
}
}
3.4 匿名內部類
匿名內部類就是一個沒有名字的方法內部類，因此特點和方法與方法內部類完全一致，除此之外，還有自己的特點：
1.匿名內部類必須繼承一個抽象類或者實現(xiàn)一個接口。
2.匿名內部類沒有類名，因此沒有構造方法。
//匿名內部類
//聲明一個接口
interface MyInterface {
//接口中方法沒有方法體
void test();
}
class Outer{
private int num = 5;
public void dispaly(int temp)
{
//匿名內部類，匿名的實現(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. 內部類與外部類的關系
對于非靜態(tài)的內部類，內部類的創(chuàng)建依賴外部類的實例對象，在沒有外部類實例之前是無法創(chuàng)建內部類的。內部類可以直接訪問外部類的元素（包括私有域）—外部類在內部類之前創(chuàng)建，創(chuàng)建內部類時會將外部類的對象傳入
class Outer{
//成員變量 與對象有關
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();
}
}
外部類可以通過內部類的引用間接訪問內部類元素 – -要想訪問內部類屬性，必須先創(chuàng)建內部類對象
class Outer{
public void dispaly()
{
//外部類通過創(chuàng)建內部類的對象間接訪問內部類元素
Inner in = new Inner();
in.dispaly();
}
class Inner{
public void dispaly()
{
System.out.println("內部類");
}
}
}
public class Test1{
public static void main(String[] args)
{
Outer out = new Outer();
out.dispaly();
}
}
內部類是一個相對獨立的個體，與外部類沒有關系。
以上這篇Java內部類和匿名內部類的用法說明就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持腳本之家。
相關文章
TimedCache是一個泛型類,它的主要作用通常是在一定時間范圍內對特定鍵值對進行緩存,并且能夠根據(jù)設定的時間策略來自動清理過期的緩存項,本文給大家介紹了Java中TimedCache緩存對象的詳細使用教程,需要的朋友可以參考下2024-12-12
簡單了解Spring中BeanFactory與FactoryBean的區(qū)別
這篇文章主要介紹了簡單了解Spring中BeanFactory與FactoryBean的區(qū)別,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-12-12
這篇文章主要介紹了基于Jasypt對SpringBoot配置文件加密,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-11-11
這篇文章主要為大家詳細介紹了java實現(xiàn)簡單的小超市程序，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-02-02
Java中LinkedHashSet、LinkedHashMap源碼詳解
這篇文章主要介紹了Java中LinkedHashSet、LinkedHashMap源碼詳解,LinkedHashMap是一個以雙向鏈表的方式將Entry節(jié)點鏈接起來的HashMap子類,它在HashMap的基礎上實現(xiàn)了更多的功能,具有順序存儲和遍歷的特性,需要的朋友可以參考下2023-09-09
Java中有一維數(shù)組，二維數(shù)組以及多維數(shù)組，在這篇文章中，將給大家詳細介紹一下如何正確使用Java中的二維數(shù)組，感興趣的小伙伴跟著小編一起學習吧2023-05-05
這篇文章討論了Java面向對象概念中一個基本的概念–Field Hiding（隱藏成員變量），文中給大家介紹了java中的重寫知識，非常不錯，具有參考借鑒價值，需要的朋友參考下吧2017-11-11
這篇文章主要為大家分享了最值得Java開發(fā)者收藏的11個網站，幫助Java開發(fā)者提升編程能力2016-11-11
詳解Java數(shù)據(jù)結構和算法（有序數(shù)組和二分查找）
本篇文章主要介紹了詳解Java數(shù)據(jù)結構和算法（有序數(shù)組和二分查找），具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-09-09
springboot tomcat最大線程數(shù)與最大連接數(shù)解析
這篇文章主要介紹了springboot tomcat最大線程數(shù)與最大連接數(shù)解析，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-06-06