java内部类详解

前言 什么是内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

一、实例内部类

即未被static修饰的，并且位置等同于外部类成员变量的位置

public class OutClass {
    private int a;
    static int b;
    int c;

    public void methodA() {
        a = 10;
        System.out.println(a);
    }

    public static void methodB() {
        System.out.println(b);
    }

    //  实例内部类：未被static修饰
    class InnerClass {
        int c;
        public void methodInner() {
            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b = 200;
            methodA();
            methodB();
            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }

    public static void main(String[] args) {
        // 外部类：对象创建  以及  成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        System.out.println(outClass.a);
        outClass.methodB();
        System.out.println("=============实例内部类的访问=============");
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
        // 创建实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
        System.out.println(outClass.a);//100
        System.out.println(outClass.b);//200
        System.out.println(outClass.c);//400
        System.out.println(innerClass2.c);//300
    }
}

总结
非静态的成员内部类

1. 可以直接访问外部类的所有成员，包含私有的
2. 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。所以外部类对他的访问也受访问修饰符的限制
3. 作用域和外部类的其他成员一样,为整个类体，在外部类的成员方法中创建成员内部类对象,再调用方法.
4. 成员内部类访问外部类成员属性、方法：直接访问
5. 外部类访问成员内部类 :创建对象，再访问（new outClass.new innerClass;innerClass.成员方法、成员变量）
6. 外部其他类访问成员内部类：先遵循外部其他类访问外部类的准则（访问修饰符）、在遵循外部类访问内部类
7. 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

二、静态内部类

即被static修饰的，并且位置等同于外部类静态成员变量的位置

public class OutClass {
    private int a;
    static int b;
    static int c = 0;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }
    // 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        int c = 100;
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            // a = 100;      // 编译失败，因为a不是类成员变量
            b =200;
            // methodA();    // 编译失败，因为methodB()不是类成员方法
            methodB();
            //访问同名静态成员，遵循就近原则
            System.out.println(c);
            //访问外部类的同名静态成员
            System.out.println(OutClass.c);
        }
    }
    public static void main(String[] args) {
        // 静态内部类对象创建  & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
}

静态内部类：

1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2. 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
3. 作用域:同其他的成员，为整个类体
4. 静态内部类访问外部类(比如:静态属性)：直接访问
5. 外部类访问静态内部类访问方式:创建对象（创建的是类对象不是实例化对象），再访问
6. 外部其他类访问静态内部类：遵循外部其他类访问外部类静态成员变量的准则
7. 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

三、匿名内部类

匿名内部类本质是一个类，但是这个类没有名字，本身的位置是在于类方法的局部变量的位置是相同的。

匿名内部类的特殊之处：

1. 匿名内部类从理解上既可以理解为一个列，也可以理解为一个对象，它既有类对象的特性，也有实例对象的特征。
2. 匿名内部类可以使用访问外部类的所有类型的属性
3. 不能添加访问修饰符，因为他实际是方法的一个局部变量
4. 作用域：定义它的方法中
5. 匿名内部类访问外部类：直接访问
6. 外部类和外部其他类都不是不能访问匿名内部类的，因为匿名内部类是方法里面的局部变量，作用域就在方法里，出了方法就销毁了。
7. 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

匿名内部类在实际开发中用的还是比较多的。
最典型的应用就比如线程的创建就可以使用匿名内部类的方式

Thread thread  = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程方法体");
            }
        });

至此内部类就说到这