Java內部類

標籤：關係   .data   extend   builder   this   clear   put   var   tin   

　　Java內部類或嵌套類是在類或介面中聲明的類。我們使用內部類在一個地方邏輯地分組類和介面，以便它更可讀和可維護。此外，它還可以訪問外部類的成員，包括私人資料成員和方法。

內部類的優點：

1. 嵌套類代表了一種特殊的類型關係：能訪問外部類的所有資料成員和方法（包括私人的）
2. 嵌套類用於開發更可讀和可維護的代碼，因為它只在一個地方對類和介面進行邏輯分組。
3. 代碼最佳化：它需要更少的代碼

問題：

1. 編輯器為member inner class(成員內部類)產生的內部代碼是什嗎？
2. 建立annonymous inner class(匿名內部類)的兩種方式是什嗎？
3. 我們可以在local inner class(局部內部類)中訪問非final局部變數嗎？
4. 如何訪問static nested class(靜態嵌套類)？
5. 介面中可以定義類嗎？
6. 類中可以定義介面嗎？

nested class(嵌套類)和inner class(內部類)的區別於聯絡

　　內部類是嵌套類的一部分，非靜態嵌套類被視為內部類

嵌套類的類型

　　有靜態嵌套類和非靜態嵌套類兩種類型。非靜態嵌套類被視為內部類

• Non-static nested class (inner class) 非靜態嵌套類：
  1. member inner class(成員內部類)
  2. annonymous inner class(匿名內部類)
  3. local inner class(局部內部類)
• static nested class靜態嵌套類

1.成員內部類

　　在類內部建立但在方法之外的非靜態類稱為成員內部類。文法：

 1 class TestMemberOuter1{   2  private int data=30;   3  class Inner{   4   void msg(){System.out.println("data is "+data);}   5  }   6  public static void main(String args[]){   7   TestMemberOuter1 obj=new TestMemberOuter1();   8   TestMemberOuter1.Inner in=obj.new Inner();   9   in.msg();  10  }  11 }

　　成員內部類的工作原理：

　　Java編譯器在內部類的情況下建立兩個類檔案。內部類的類檔案名稱是“outer$inner”。如果要執行個體化內部類，則必須建立外部類的執行個體。在這種情況下，內部類的執行個體是在外部類的執行個體中建立的。

　　編譯器產生的內部代碼：

　　java編譯器建立一個名為"outer$inner"的類檔案。成員內部類具有外部類的引用，這就是為什麼成員內部類可以訪問外部類的所有資料成員的原因

import java.io.PrintStream;  class Outer$Inner  {      final Outer this$0;      Outer$Inner()      {   super();          this$0 = Outer.this;      }      void msg()      {          System.out.println((new StringBuilder()).append("data is ")                      .append(Outer.access$000(Outer.this)).toString());      }  }

2.匿名內部類

　　一個沒有名字的類在Java中被稱為匿名內部類。如果您必須重寫類或介面的方法，則應該使用它。可以通過兩種方式建立Java匿名內部類 

1. 類（可以是抽象類別或具體類）
2. 介面

　　java匿名內部類舉例

 1 abstract class Person{   2   abstract void eat();   3 }   4 class TestAnonymousInner{   5  public static void main(String args[]){   6   Person p=new Person(){   7   void eat(){System.out.println("nice fruits");}   8   };   9   p.eat();  10  }  11 }  

　　匿名內部類的工作原理

1. 類被建立，但是它的名稱由編譯器決定，編譯器實現Person類，並實現eat方法
2. 建立匿名類的對象，該對象由Person類型的p引用變數引用。

　　編譯器產生的程式碼

import java.io.PrintStream;  static class TestAnonymousInner$1 extends Person  {     TestAnonymousInner$1(){}     void eat()      {          System.out.println("nice fruits");      }  } 

3. 局部內部類

　　在方法中建立的類稱為Java中的本地內部類。如果要調用本地內部類的方法，必須在該方法中執行個體化該類。 

　　局部內部類舉例

 1 public class localInner1{   2  private int data=30;//instance variable   3  void display(){   4   class Local{   5    void msg(){System.out.println(data);}   6   }   7   Local l=new Local();   8   l.msg();   9  }  10  public static void main(String args[]){  11   localInner1 obj=new localInner1();  12   obj.display();  13  }  14 }

　　編譯器產生的內部類：

 1 import java.io.PrintStream;   2 class localInner1$Local   3 {   4     final localInner1 this$0;   5     localInner1$Local()   6     {      7         super();   8         this$0 = Simple.this;   9     }  10     void msg()  11     {  12         System.out.println(localInner1.access$000(localInner1.this));  13     }  14 } 

　　規則：

1. 局部內部類不能聲明為public、protected、private，只能是預設存取權限
2. 局部內部類不能被外部方法調用
3. 局部內部類不能訪問非final局部變數在JDK1.7之前，但是可以訪問final變數；在JDK1.8以後，局部內部類也可以訪問非final局部變數

4.靜態嵌套類

　　在類中建立的靜態類在Java中稱為靜態嵌套類。它不能訪問非待用資料成員和方法。它可以由外部類名訪問。

1. 它可以訪問包括私人的外部類的待用資料成員。
2. 靜態嵌套類不能訪問非靜態（執行個體）資料成員或方法

　　靜態嵌套類舉例

class TestOuter1{    static int data=30;    static class Inner{     void msg(){System.out.println("data is "+data);}    }    public static void main(String args[]){    TestOuter1.Inner obj=new TestOuter1.Inner();    obj.msg();    }  } 

　　在這個例子中，你需要建立靜態嵌套類的執行個體，因為他含有執行個體方法msg()。但是你不需要建立外部類的執行個體，因為嵌套類是靜態並且靜態屬性、方法、類在沒有對象情況下可以被訪問

　　編譯器產生的程式碼：

1 import java.io.PrintStream;  2 static class TestOuter1$Inner  3 {  4 TestOuter1$Inner(){}  5 void msg(){  6 System.out.println((new StringBuilder()).append("data is ")  7 .append(TestOuter1.data).toString());  8 }    9 }  

5. 嵌套介面

　　在另一個介面或類中聲明的介面稱為嵌套介面。嵌套介面用於對相關介面進行分組，以便它們易於維護。嵌套介面必須由外部介面或類引用。它不能直接存取。

　　嵌套介面要記住的要點

1. 嵌套介面在介面內聲明時必須是公用的，但是如果在類內聲明，則它可以具有任何存取修飾詞。
2. 嵌套介面隱式地聲明為靜態

　　嵌套介面在介面內聲明舉例

interface Showable{    void show();    interface Message{     void msg();    }  }  class TestNestedInterface1 implements Showable.Message{   public void msg(){System.out.println("Hello nested interface");}     public static void main(String args[]){    Showable.Message message=new TestNestedInterface1();//upcasting here    message.msg();   }  }

　　正如您在上面的樣本中看到的，我們通過其外部介面Showable訪問Message介面，因為它不能直接存取。就像房間裡的衣櫥一樣，我們不能直接進入衣櫥，因為我們必須先進入房間。在集合的架構中， sun microsystem提供了嵌套介面Entry，Entry是Map的子介面，可以通過Map.Entry訪問　　java編輯器為嵌套介面產生的程式碼

public static interface Showable$Message  {    public abstract void msg();  }

　　我們能在介面中定義一個類嗎？

　　是的，我們可以在介面中定義一個類，java編譯器將會建立一個靜態嵌套類

原文地址：https://www.javatpoint.com/java-inner-class

　

 

 

 

 

 

Java內部類