java Inner class

1.static Inner class(静态成员类)

public class  Outer{
    //just like static method, static member class has public/private/default access privilege levels
    
    //access privilege level: public 
    public static class Inner1 {
        public Inner1() {
            //Static member inner class can access static method of outer class
            staticMethod();    
            //Compile error: static member inner class can not access instance method of outer class
            //instanceMethod();  
        }
    }
    
    //access privilege level: default 
    static class Inner2 {
        
    }
    
    //access privilege level: private 
    private static class Inner3 {
        //define a nested inner class in another inner class 
        public static class Inner4 {    
        }
    }

    private static void staticMethod() {
        //cannot define an inner class in a method
        /*public static class Inner4() {
        }*/
    }
    
    private void instanceMethod() {
        //private static member class can be accessed only in its outer class definition scope
        Inner3 inner3 = new Inner3();
        //how to use nested inner class
        Inner3.Inner4 inner4 = new Inner3.Inner4();
    }
}

class Test {
    Outer.Inner1 inner1 = new Outer.Inner1();
    //Test and Outer are in the same package, so Inner2 can be accessed here
    Outer.Inner2 inner2 = new Outer.Inner2(); 
    //Compile error: Inner3 cannot be accessed here
    //Outer.Inner3 inner3 = new Outer.Inner3(); 
}

1.1   静态成员类特性
         静态成员类可访问外部类的任一静态字段或静态方法
         像静态方法或静态字段一样，静态成员类有public/private/default权限修饰符

1.2     静态成员类约束
         静态成员类不能与外部类重名
         像外部类的静态方法一样，不能直接访问外部类的实例字段和实例方法
         静态成员类只能定义于外部类的顶层代码或外部类其它静态成员类的顶层代码中（嵌套定义）；不能定义于外部类的某个函数中。

1.3      新增语法

         如示例代码所示，可以以“OuterClass.InnerClass”的方式来引用某个内部类。

1.4      什么时候使用静态成员类
B为A的辅助类，且只为A所用时，可将B定义为A的静态成员类。

 

 

2.member class(成员类)

         一个静态成员类，若去掉“static”关键字，就成为成员类。
        

public class Outer {
    //just like instance method, member class has public/private/default access privilege levels
    private int data;
    
    //access privilege level: public 
    public class Inner1 {
        private int data;
        private int data1;
        public Inner1() {
            //member class can access its outer class' instance field directly
            data1 = 1;
            //itself data field
            data = 1;
            //its outer class instance field
            Outer.this.data = 1;
        }
    }
    
    //access privilege level: default
    class Inner2 {
        //can not define static filed, method, class in member class
        //static int j = 1;
        
        //but, "static final" compound is allowed 
        static final int CONSTANT = 1;
    }
    
    //access privilege level: private 
    private class Inner3 {
        public class Inner4 {
            
        }
    }
    
    //in fact, Inner5 is not a member class but a static member class
    interface Inner5 {
    }
    
    private static void staticMethod() {
        //can not create a member class instance directly in outer class' static method
        //Inner1 inner1 = new Inner1();
    }
    
    private void instanceMethod() {
        //can create a member class instance in outer class' instance method
        Inner1 inner1 = new Inner1();
    }
}

class Test {
    public Test() {
        //cannot create member class instance directly in class other than outer class
        //Outer.Inner2 inner2 = new Outer.Inner2();
        
        //create a member class instance outside it's outer class
        Outer outer = new Outer();
        Outer.Inner1 inner1 = outer.new Inner1();
    }
}

2.1      成员类特性
       ·  类似于外部类的实例函数，成员类有public/private/default权限修饰符
       ·  一个成员类实例必然所属一个外部类实例，成员类可访问外部类的任一个实例字段和实例函数。
2.2      成员类约束
          成员类不能与外部类重名 
          不能在成员类中定义static字段、方法和类（static final形式的常量定义除外）。因为一个成员类实例必然与一个外部类实例关联，这个static定义完全可以移到其外部类中去 
          成员类不能是接口（interface）。因为成员类必须能被某个外部类实例实例化，而接口是不能实例化的。事实上，如示例代码所示，如果你以成员类的形式定义一个接口，该接口实际上是一个静态成员类，static关键字对inner interface是内含（implicit）的。

2.3      指定内部类实例所属的外部类实例

          内部类实例可在其外部类的实例方法中创建，此新创建内部类实例所属的外部类实例自然就是创建它的外部类实例方法对应的外部类实例。

          另外，如示例代码所示，对于给定的一个外部类实例outerClass，可以直接创建其内部类实例，语法形式为：
         

OuterClass.InnerClass innerClass = outerClass.new InnerClass();

2.4      新增语法
          一个成员类实例必然所属于其外部类的一个实例，那么如何在成员类内部获得其所属外部类实例呢？如示例代码所示，采用“OuterClass.this”的形式。                                  

2.5      什么时候使用成员类

 成员类的显著特性就是成员类能访问它的外部类实例的任意字段与方法。方便一个类对外提供一个公共接口的实现是成员类的典型应用。