1. 程式人生 > 程式設計 >Java內部類詳解

Java內部類詳解

內部類

(一) 概述

把類定義在另一個類的內部,該類就被稱為內部類。

舉例:把類Inner定義在類Outer中,類Inner就被稱為內部類。

class Outer {
  class Inner {
  }
}

(二) 內部類的訪問規則
​ A:可以直接訪問外部類的成員,包括私有

​ B:外部類要想訪問內部類成員,必須建立物件

(三) 內部類的分類

A:成員內部類

​ B:區域性內部類

​ C:靜態內部類

​ D:匿名內部類

(1) 成員內部類
成員內部類——就是位於外部類成員位置的類
特點:可以使用外部類中所有的成員變數和成員方法(包括private的)

A:格式:

class Outer {
  private int age = 20;
  //成員位置
  class Inner {
    public void show() {
      System.out.println(age);
    }
  }
}

class Test {
  public static void main(String[] ages) {
    //成員內部類是非靜態的演示
    Outer.Inner oi = new Outer.new Inner();
    oi.show();
  }
}

B:建立物件時:
//成員內部類不是靜態的:
外部類名.內部類名 物件名 = new 外部類名.new 內部類名();

//成員內部類是靜態的:
外部類名.內部類名 物件名 = new 外部類名.內部類名();
C:成員內部類常見修飾符:
A:private

如果我們的內部類不想輕易被任何人訪問,可以選擇使用private修飾內部類,這樣我們就無法通過建立物件的方法來訪問,想要訪問只需要在外部類中定義一個public修飾的方法,間接呼叫。這樣做的好處就是,我們可以在這個public方法中增加一些判斷語句,起到資料安全的作用。

class Outer {
  private class Inner {
    public void show() {
      System.out.println(“密碼備份檔案”);
    }
  }
  
  public void method() {
    if(你是管理員){
      Inner i = new Inner();
      i.show();
    }else {
      System.out.println(“你沒有許可權訪問”);
    }
    }
}

下面我們給出一個更加規範的寫法

class Outer {
  private class Inner {
    public void show() {
      System.out.println(“密碼備份檔案”);
    }
  }
  //使用getXxx()獲取成員內部類,可以增加校驗語句(文中省略)
  public void getInner() {
    return new Inner();
    }
  
  public static void main(String[] args) {
    Outer outer = new Outer();
    Outer.Inner inner = outer.getInner();
    inner.show();
  }
}

B:static
這種被 static 所修飾的內部類,按位置分,屬於成員內部類,但也可以稱作靜態內部類,也常叫做巢狀內部類。具體內容我們在下面詳細講解。

D:成員內部類經典題(填空)

請在三個println 後括號中填空使得輸出25,20,18

class Outer {
  public int age = 18;  
  class Inner {
    public int age = 20;  
    public viod showAge() {
      int age = 25;
      System.out.println(age);//空1
      System.out.println(this.age);//空2
      System.out.println(Outer.this.age);//空3
    }
  }
} 

(2) 區域性內部類
區域性內部類——就是定義在一個方法或者一個作用域裡面的類
特點:主要是作用域發生了變化,只能在自身所在方法和屬性中被使用

A 格式:

class Outer {
  public void method(){
    class Inner {
    }
  }
}

B:訪問時:

//在區域性位置,可以建立內部類物件,通過物件呼叫和內部類方法
class Outer {
  private int age = 20;
  public void method() {
    final int age2 = 30;
    class Inner {
      public void show() {
          System.out.println(age);
        //從內部類中訪問方法內變數age2,需要將變數宣告為最終型別。
        System.out.println(age2);
      }
    }
    
    Inner i = new Inner();
    i.show();
  }
}

C: 為什麼區域性內部類訪問區域性變數必須加final修飾呢?

因為區域性變數是隨著方法的呼叫而呼叫,使用完畢就消失,而堆記憶體的資料並不會立即消失。

所以,堆記憶體還是用該變數,而該變數已經沒有了。為了讓該值還存在,就加final修飾。

原因是,當我們使用final修飾變數後,堆記憶體直接儲存的是值,而不是變數名。

(即上例 age2 的位置儲存著常量30 而不是 age2 這個變數名)

(3) 靜態內部類

我們所知道static是不能用來修飾類的,但是成員內部類可以看做外部類中的一個成員,所以可以用static修飾,這種用static修飾的內部類我們稱作靜態內部類,也稱作巢狀內部類.
特點:不能使用外部類的非static成員變數和成員方法

解釋:非靜態內部類編譯後會預設的儲存一個指向外部類的引用,而靜態類卻沒有。

簡單理解:

即使沒有外部類物件,也可以建立靜態內部類物件,而外部類的非static成員必須依賴於物件的呼叫,靜態成員則可以直接使用類呼叫,不必依賴於外部類的物件,所以靜態內部類只能訪問靜態的外部屬性和方法。

class Outter {
  int age = 10;
  static age2 = 20;
  public Outter() {    
  }
   
  static class Inner {
    public method() {
      System.out.println(age);//錯誤
      System.out.println(age2);//正確
    }
  }
}

public class Test {
  public static void main(String[] args) {
    Outter.Inner inner = new Outter.Inner();
    inner.method();
  }
}

(4) 匿名內部類
一個沒有名字的類,是內部類的簡化寫法
A 格式:

new 類名或者介面名() {
重寫方法();
}
本質:其實是繼承該類或者實現介面的子類匿名物件

這也就是下例中,可以直接使用 new Inner() {}.show(); 的原因 == 子類物件.show();

interface Inter {
  public abstract void show();
}

class Outer {
  public void method(){
    new Inner() {
      public void show() {
        System.out.println("HelloWorld");
      }
    }.show();
  }
}

class Test {
  public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
  }
}  

如果匿名內部類中有多個方法又該如何呼叫呢?

Inter i = new Inner() { //多型,因為new Inner(){}代表的是介面的子類物件
  public void show() {
  System.out.println("HelloWorld");
  }
};

B:匿名內部類在開發中的使用

​我們在開發的時候,會看到抽象類,或者介面作為引數。

而這個時候,實際需要的是一個子類物件。

如果該方法僅僅呼叫一次,我們就可以使用匿名內部類的格式簡化。