Java内部类 - 技术栈

内部类

内部类是定义在类内部的类。

Inner Class

在类的内部直接定义一个类就是一个普通的内部类。

java 复制代码

public class InnerClass {
    public static void main(String[] args) {
        Outer outer=new Outer("OuterClass");
        Outer.Inner inner=outer.new Inner();
        inner.func();
    }
}

class Outer {
    private String name;
    Outer(String s) {name=s;}

    class Inner {
        void func(){
            System.out.println("Outer.Inner.func()" + Outer.this.name);
        }
    }
}

从代码中可以看到，要实例化一个内部类，需要先实例化一个外部类对象。在内部类中，可以使用一个特殊的this访问外部类。

Inner Class和普通Class相比，除了能引用Outer实例外，还有一个额外的"特权"，就是可以修改Outer Class的private字段，因为Inner Class的作用域在Outer Class内部，所以能访问Outer Class的private字段和方法。

观察Java编译器编译后的.class文件可以发现，Outer类被编译为Outer.class，而Inner类被编译为Outer$Inner.class。

Anonymous Class

还有一种定义内部类的方法，就是在函数中通过匿名类来定义

java 复制代码

public class AnonymousClass {
    public static void main(String[] args) {
        OuterClass outerClass=new OuterClass("OuterClass");
        outerClass.asyncHello();
    }
}

class OuterClass {
    private String name;

    OuterClass(String name) {
        this.name=name;
    }

    void asyncHello() {
        //匿名类实例化一个接口
        Runnable r=new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello, " + OuterClass.this.name);
            }
        };

        new Thread(r).start();
    }
}

匿名类和Inner Class一样，可以访问Outer Class的private字段和方法。之所以我们要定义匿名类，是因为在这里我们通常不关心类名，比直接定义Inner Class可以少写很多代码。

除了接口外，匿名类也完全可以继承自普通类。

Static Nested Class

静态内部类：

java 复制代码

// Static Nested Class
public class Main {
    public static void main(String[] args) {
        Outer.StaticNested sn = new Outer.StaticNested();
        sn.hello();
    }
}

class Outer {
    private static String NAME = "OUTER";

    private String name;

    Outer(String name) {
        this.name = name;
    }

    static class StaticNested {
        void hello() {
            System.out.println("Hello, " + Outer.NAME);
        }
    }
}