java 普通内部类和静态内部类

java普通内部类和静态内部类

在以下例子当中，Outer是外部类，class Inner是一个普通的内部类
static class Sinner是一个静态内部类，也可以说是嵌套类
普通内部类，相当于外部类的一个普通的成员变量，内部类的构造必须要外部类先构造出，不能定义静态变量和方法。
（1）系统自动为普通内部类建立一个指向外部对象的引用，所以内部类可以访问外部类的方法，比如下面class Inner的printIn函数可以通过Outer.this.printOut()调用外部类的方法。
（2）只有static内部类可以定义static变量，静态类又叫做嵌套类,可以看作外部类的静态成员，可以直接访问外部类的静态属性和方法，需要构造一个外部类对象才能访问外部类的普通成员变量。
比如下面class Sinner的printSin函数
（3）外部类的对象访问内部类的成员分为三种情况：
1）外部类成员访问普通内部类的普通成员：需要构造一个内部类的实例对象
2）外部类成员访问嵌套类的普通成员：需要构造一个嵌套类的实例对象
3）外部类成员访问嵌套类的静态成员：通过类名和点直接访问
4）普通内部类不能定义静态成员
在下面的例子中，Outer的一个成员函数printOut实现了上述三种情况的内部成员的访问。
（4）Outer内部还写了一个成员函数是create函数，这个函数里实例一个Inner对象，对其成员进行访问。

public class Outer {
    public static int d = 200;
    private static int f = 100;
    class Inner{
        protected int b = 20;
        private int c =2000;
        public void printIn(){
            Outer.this.printOut();//利用Outer.this直接访问外部类的方法
        }
    }
    void create(){
        System.out.println(new Inner().c);
    }
    static class Sinner{//
        public static int d = 1000;
        protected int e = 3000;
        public void printSin(){
            System.out.println(f);//外部类的私有静态变量
            new Outer().create();
            //嵌套类对外部类普通成员变量的访问，需要构造一个外部类实例
            System.out.println(Outer.d);
            //嵌套类对外部类静态成员的访问，可以用类名点直接访问
        }
        public static void printSin1(){
            System.out.println(d);
        }
    }
    void printOut(){
        System.out.println(Sinner.d);//静态内部类的静态变量可以直接使用类名点访问
        System.out.println(new Sinner().e);//静态内部类的非静态变量需要用该类的对象来访问
        System.out.println(new Inner().b);//访问普通内部类的成员
    }

    public static void main(String[] args) {
        //访问普通内部类
        new Outer().new Inner().printIn();//1000,3000,20
        new Outer().create();//2000
        //访问嵌套类
        Outer.Sinner.printSin1();//可以用类名直接访问静态方法和变量
        new Sinner().printSin();//可以不构造外部类，直接构造嵌套类，来使用嵌套类的非静态方法和变量
    }
}