Java 教程《語法說明》Inner Classes 與 Nested Classes

■ Inner Classes 與 Nested Classes
[class-modifiers] class OuterClassName {
　　‥‥
　　[inner-class-modifiers] class InnerClassName {
　　　　‥‥
　　}
　　[nested-class-modifiers] static class StaticClassName {
　　　　‥‥
　　}
　　‥‥
}

[說明]
定義 inner class，inner class 內的 methods 允許存取 outer class 的 members。

[範例]
class SomeClass { .... }
class SuperClass { .... }
public class MyClass extends SuperClass {
　　‥‥
　　private class MyInnerClass extends SomeClass {
　　　　‥‥
　　}
}

[註] Inner Class
Java 將 Inner Class 分為下列 3 類
‧ 一般的 Inner Class
指的是將 class 宣告在 class 內
[語法]
[class-modifiers] class EnclosingClass {
　　[inner-class-modifiers] class InnerClass {
　　　　// Write Codes Here
　　}
}
　inner-class-modifiers 可以是 public、protected、private、final、strictfp、abstract、static（會變成static nested class）

1. 若在 enclosing class 之外建立 inner class 的 instance，必須先建立 enclosing class 的 instance。
　[範例]
　EnclosingClass.InnerClass obj = new EnclosingClass( ).new InnerClass( );
　或是
　EnclosingClass objX = new EnclosingClass( );
　EnclosingClass.InnerClass objY = objX.new InnerClass( );

2. 所有的 inner class 會隱性參考(reference) 其 enclosing class，其型式為 "EnclosingClass.this"
　[範例]
　public class MyEnclosingClass {
　　　private String someMember = "Some Member";  
　　　private class MyInnerClass {
　　　　　private String someMember = "Inner Member";
　　　　　public void doIt( ) {
　　　　　　　System.out.println(someMember);　　// 印出 Inner Member
　　　　　　　System.out.println( MyEnclosingClass.this.someMember );　　// 印出 Some Member
　　　　　}
　　　}
  
　　　public static void main(String[ ] args) {
　　　　　new MyEnclosingClass( ).new MyInnerClass( ).doIt( );
　　　}
　}

3. non-static inner class 可存取包含該 inner class 的所有的 members。
4. inner class 內不能宣告 static members，inner class 內所有 members 必須是 instance members，但是 inner classes 可
　存取 enclosing class 的 static members。
　唯一的例外是，inner classes 內可宣告 static 和 final 的 fields(compile-time constant)。
      
[範例]
class HasStatic {
     static int j = 100;
}
class Outer  {
     class Inner extends HasStatic {
          static final int x = 3;      // ok - compile-time constant
          static int y = 4;       // compile-time error, an inner class
     }
     static class NestedButNotInner {
          static int z = 5;       // ok, not an inner class
     }
     interface NeverInner  {  }      // interfaces are never inner
}


‧ Method local Inner Class
1. local class 為定義在 method 內的 class，其 scope 在該 method 內
2. 當 inner class 定義在 method 內，則該 class 只可以存取 enclosing class 宣告為 final 的 variables(或稱為 automatic 或 local variables)

[範例]
public class MyInnerClass {
    static String msg = "Hello";

    public static void main(String[ ] av) {
        class Inner {
            public void doSomeWork( ) {      // print member of enclosing class
                System.out.println(msg);
           }
        }
        Inner p = new Inner( );
        p.doSomeWork( );
    }
}


‧ Anonymous Inner Class
1. anonymous nested class 必須實作某個 interface 或是繼承某個 class，但是不使用 implements 或 extends 關鍵字做宣告。
2. anonymous class 內不能宣告 constructor，可宣告 instance initializer 做初值設定
[註] anonymous class 的類別名稱可用 this.getClass( ).getName( ) 觀察

[範例]
return new SomeClass( ) { 　/*body of the anonymous class goes here*/ 　};

[範例]
someMethod(new SomeClass( ) {　 /*body of the anonymous class goes here*/ 　} );



Nested Class
Nested Classes 也是 inner class 的一種型式，但是 Java 將宣告為 static 的 inner class 稱為 Nested Class
‧ Static Nested Classes
1. nested classes 即為所謂的 static inner classes  
　nested classes 有點像似 top-level classes，enclosing class 提供這種類型的 class 一個 package-like 的架構，nested classes 可
　存取 enclosing class 所有的 members。但是 nested class 比 inner class 有更多的限制。
2. static nested class 可以合用修飾字 abstract。
　[註] 注意，一般而言，在 class 內你不能宣告 static methods 為 abstract。
3. 可直接建立 nested class 的 instance，不需先建立 enclosing class 的 instance。
　EnclosingClass.NestedClass obj = new EnclosingClass.NestedClass( );
4. nested class 只能存取 enclosing class 的 static members(private 權限的 members 亦可)  
　
[範例]
public class MyEnclosingClass {
　　private static String staticMember = "Static Member";
　　private String someMember = "Some Member";      
　　static class MyNestedClass {
　　　　public void doIt( ) {
　　　　　　System.out.println(staticMember);  
　　　　}
　　}

　　public static void main(String[ ] args) {
　　　　new MyNestedClass( ).doIt( );
　　　　// new MyInnerClass( );  // ERROR
　　}

　　class MyInnerClass {   
　　　　// static String InnerStaticMember = "Inner Static Member";　// Error：inner classes cannot have static declarations
　　　　public void doIt( ) {
　　　　　　System.out.println(staticMember + ", " +myStaticFinalConstant);
　　　　}     
　　　　static final int myStaticFinalConstant = 0;      // OK
　　}
}


※ inner interface 與 inner class 混用  
1. interface 內的 inner interface 預設為 public static，class 內的 inner interface 預設為 static，存取權限可以為 private/protected/public/default
2. class 的 inner class 內不能再有 inner interface，否則會出現編譯錯誤：inner classes cannot have static declarations  
3. Interface 的 Inner Class 內可以有 Inner Interface  
4. Interface 內可以有 Inner class  
5. Inner Interface 可以繼承 Outer Intreface  
6. Inner Class 可以繼承 Outer Class 或 implments Outer Interface

[範例]
public class X {   
　　class Y {
　　　　private void f( ) {        }        
　　}                                        
　　class Z extends Y {
　　　　{　// initializer
　　　　　　f( );　　　　// 編譯錯誤
　　　　　　this.f( );　　// 編譯錯誤
　　　　　　((Y)this).f( );    // 可過編譯
　　　　　　super.f( );       // 可過編譯
　　　　}  //end initializer
　　}
}  // end class X