Java中抽象内部类 Abstract Inner Class 怎么被继承扩展-java教程-PHP中文网

java中抽象内部类可被继承，但必须通过外部类实例调用outer.super()构造，子类需依附外部类作用域，非静态时无法脱离外部实例存在。

java中抽象内部类 abstract inner class 怎么被继承扩展

Java中抽象内部类可以被继承，但必须注意外部类作用域、构造器调用方式和访问权限这三个关键点。不能像普通类那样直接写 class Sub extends Outer.Inner 就完事——编译器会报错，因为抽象内部类天然依赖外部类实例。

必须通过外部类实例创建子类对象

抽象内部类不是静态的，它隐式持有一个指向外部类实例的引用（Outer.this）。所以任何非静态子类在构造时，都必须显式传入一个外部类对象，并用 outerInstance.super() 调用其构造器。

子类不能是顶级类，通常定义为外部类的成员类或独立的顶层类（此时需手动传参）
构造器第一行必须是 外类实例.super()，否则编译失败
如果外部类有私有成员，子类可通过外部类提供的 public 方法间接访问，或把内部类设为包内可见

两种常见继承写法

方式一：子类定义在外部类内部（推荐）
逻辑内聚，访问自然，无需暴露构造细节：

class Outer {
    private int data = 100;
    abstract class AbstractInner {
        abstract void doWork();
    }
    class ConcreteInner extends AbstractInner {
        @Override
        void doWork() {
            System.out.println("访问外部类数据: " + data); // ✅ 直接访问
        }
    }
}

方式二：子类定义为独立顶层类
适合跨包复用，但需显式管理外部类引用：

Java Maven Code Review

审查Java Maven项目（ZIP压缩包或GitLab仓库URL），检查代码规范、命名、模块边界、可维护性问题以及重复代码。

下载

class OuterExtendsInner extends Outer.AbstractInner {
    OuterExtendsInner(Outer outer) {
        outer.super(); // ⚠️ 必须这样调用
    }
    @Override
    void doWork() {
        // 无法直接访问 outer.data（private），需 outer 提供 getter
        System.out.println("data = " + getOuterData());
    }
    private int getOuterData() {
        return ((Outer) this.getClass().getEnclosingClass().getDeclaredConstructors()[0]
            .getAnnotatedReturnType().getType()).data; // ❌ 不推荐 —— 应由 Outer 提供 public 方法
    }
}

更合理的做法是让 Outer 暴露必要方法：

class Outer {
    private int data = 100;
    public int getData() { return data; } // ✅ 提供访问入口
    abstract class AbstractInner { abstract void doWork(); }
}
class OuterExtendsInner extends Outer.AbstractInner {
    private final Outer outer;
    OuterExtendsInner(Outer outer) {
        outer.super();
        this.outer = outer;
    }
    @Override
    void doWork() {
        System.out.println("data = " + outer.getData()); // ✅ 安全访问
    }
}

静态抽象内部类可绕过实例依赖

如果不需要访问外部类非静态成员，可将内部类声明为 static abstract。这时它就退化为普通抽象类，继承方式与顶层抽象类完全一致：

class Outer {
    static abstract class StaticAbstractInner {
        abstract void run();
    }
}
class ConcreteStatic extends Outer.StaticAbstractInner {
    @Override
    void run() {
        System.out.println("静态抽象内部类可自由继承");
    }
}

注意：static 内部类无法访问外部类的实例变量，只能访问静态成员。