Java 内部类

Java的内部类包括四种类型：

Static member classes

Member classes

Local classes

Anonymous classes

1. Static member class

Static member class是类的一个静态成员，它只能访问上层类中的静态成员和静态方法

第一：Static member class访问Outer class的成员变量或方法的时候，必须先new 一个Outer的对象，而无法通过Outer.this.xxx或Outer.this.xxx()来访问

2. Member class

类似于Static member class，它也是类的一个成员，但是它跟实例关联的，所以能访问所有的方法和成员变量，甚至是父类的this指针

类前面的修饰符有public > protected > package > private 和其它是一样的。

在成员内部类中要注意两点，

第一：成员内部类中不能存在任何static的变量和方法；

第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。所以外部类的静态方法中要访问内部类的方法要先new Outer对象再new Inner对象才能访问

第三：在Inner类中声明的变量或方法如果跟Outer类重名或函数签名一致的话，是会覆盖外部类的变量或方法。此时必须通过Outer.this.xxx 或Outer.this.xxx() 来访问外部类的变量或方法

package edu.sjtu.se.dclab.code;

public class Outer {
    
    private String a;
    private String c;
    private static String b = "Outer static String";
    
    public static void staticPrint(){
        System.out.println("Outer static method: staticPrint");
    }
    
    public void print(){
        System.out.println("Outer class method : print");
    }
    
    public Outer() {
        a = "Outer String a";
        c = "Outer String c";
    }
    
    class Inner{
        private String a;
        //private static String b= "xx";   //不能创建静态变量
        
        Inner(){
            a = "Inner String a";
        }
        
        public void print(){   //覆盖外部类的方法
            System.out.println("Inner class method : print");
        }
        
        public void test(){
            //Access Outer Member
            System.out.println("Outer.this.c = " + Outer.this.c);   //访问外部类的成员
            //Access Outer Member
            System.out.println("c = " + c);   //不重名，访问外部类的成员
            //Access Outer Static Member
            System.out.println("Outer.b = " + Outer.b);  //访问外部类的静态成员
            //Access Inner Member
            System.out.println("a = " + a);   //重名，默认访问内部类的成员
            //Access Outer static method
            staticPrint();   //访问外部类的静态方法
            //Access Inner method
            print();   //重名，访问内部类的方法
            //Access Outer method  
            Outer.this.print();  //重名，访问外部类的方法
        }
    }
    
    static class StaticInner{
        public void test(){
            System.out.println(new Outer().a);   //在静态内部类中，必须先new一个外部类的对象
            staticPrint();   //直接访问外部类的静态方法
        }
    }
    
    public Inner getInner(){
        return new Inner();
    }
    
    public StaticInner getStaticInner(){
        return new StaticInner();
    }
    
    public static void staticTest(){
        new Outer().getInner().print();   //外部类静态方法要访问内部类的方法，要先创建外部类对象，再获取内部类的对象，再调用方法
    }

}

3. Local class 

Local class是只在某个code block中可见的类，类似于方法中定义的变量

注意local class只能访问code block中是final的变量（内部的原因还不太懂）

4. Anonymous class

Anonymous class是一种没有名字的Local Class