面试被问super原理答不上？图解原理帮你Java中super彻底避坑
面试官盯着你的简历，问：“Java里的super关键字，底层到底怎么实现的？为什么有时候会报错？”你脑子里一片空白，只能支支吾吾说“就是调用父类方法”。这种尴尬，我见过太多次了。很多开发者觉得super很简单，不就是个前缀吗？但一旦涉及构造器链、字段遮蔽、或者在匿名内部类里用super，立马就懵。
其实，super的本质是编译期确定的引用，指向当前对象创建时的直接父类实例。它不是运行时动态查找，而是Java编译器帮你插了一根“线”，直接连到父类的代码块。为了把这事说透，我用图解原理的方式，把super的底层逻辑、常见报错场景、正确写法对比，一次性讲清楚。看完这篇，你不仅能应付面试，还能在代码里避开那些让人抓狂的NPE和编译错误。
坑的现象：super调用报错，到底怪谁？
先来看一个真实场景。你在维护一个老项目，重构时把父类的一个字段从protected改成了private，然后子类里有一行代码：super.name = new;。编译直接报错：super.name has private access in Parent。
别慌，这不是super坏了，是访问权限卡住了你。super关键字只能访问父类中非私有的字段和方法。如果父类字段是private，子类通过super是够不着的，必须通过getter/setter，或者把字段改成protected/public。
更隐蔽的坑在构造器里。很多新手写：
public class Child extends Parent {public Child() {super.name = child; // 编译错误！}
}这个错误不是权限问题，而是构造器执行顺序问题。Java规定，子类的构造器第一行必须是super(...)或this(...)。如果你在super()之前访问super.name，此时父类对象还没初始化，字段还是默认值（null或0），编译器直接拒绝你这种“越级”操作。
另一个高频坑是匿名内部类里的super。比如你在一个匿名Runnable里想调用外部类的方法：
new Runnable() {public void run() {super.run(); // 编译错误！}
}这里super指向的是Object类，因为匿名类直接继承Object。你想调外部类的方法，得用OuterClass.this.method()，而不是super。这个错误在回调、监听器场景里特别常见，很多人栽在这里。
根本原因：super是编译期绑定，不是运行时查找
要彻底搞懂super，得先撕掉“super是个运行时对象”的错觉。根据Java语言规范（JLS）第8.11节，super是一个限定名（qualified name），在编译阶段就确定了它指向哪个父类。
图解一下：类加载阶段：JVM加载Child类时，会记录它的直接父类是Parent。
编译阶段：javac看到super.method()，会检查Parent类里是否有method，并把调用指令编译成invokevirtual Parent.method。
运行阶段：JVM执行字节码时，直接调用Parent的方法，不会再去查Child有没有覆盖，也不会查更上层的祖父类。关键点来了：super不能用于静态成员。因为静态方法属于类，不属于实例，而super指向的是“父类实例”，静态方法根本没有“实例”的概念。所以super.staticMethod()是编译错误，必须用Parent.staticMethod()。
还有一个容易被忽略的点：super调用的是父类中未被覆盖的方法。如果Parent的method被GrandParent覆盖，而Child没有覆盖，那么super.method()调用的是Parent的版本，而不是GrandParent的。这和动态绑定（多态）完全不同。
我在CSDN上看到过不少帖子讨论这个问题，很多开发者混淆了super和this的区别。简单说：this指向当前对象，super指向当前对象的父类部分。在单继承体系下，这个父类部分是唯一的，所以super是明确的。
正确写法对比：避开这些坑，代码才稳
下面用两段代码对比，左边是典型错误写法，右边是正确写法。注意看注释里的关键点。
错误写法：构造器里过早访问super字段
class Parent {protected String name;public Parent(String name) {this.name = name;}
}class Child extends Parent {public Child() {// 错误1：在super()之前访问super.name，此时父类未初始化super.name = child; super(parent); // 错误2：super()必须在第一行，且不能带参数（除非父类有对应构造器）}
}这段代码有两个致命问题：super.name在super()之前访问，编译器报错：Cannot reference a field before super() call。
即使父类有带参构造器，super(parent)也必须在第一行，且不能和其他语句混合。正确写法：严格遵循构造器顺序
class Parent {protected String name;public Parent(String name) {this.name = name;System.out.println(Parent constructor called);}
}class Child extends Parent {public Child() {// 正确：super()必须是第一行，调用父类构造器super(parent);// 现在可以安全访问super.name，因为父类已初始化super.name = child;System.out.println(Child constructor called);}
}执行顺序：调用super(parent)，执行Parent构造器，name被设为parent。
回到Child构造器，super.name = child，name被覆盖为child。
输出：Parent constructor called → Child constructor called。匿名内部类里的super陷阱
class Outer {public void doSomething() {System.out.println(Outer.doSomething);}public void run() {new Runnable() {@Overridepublic void run() {// 错误：super指向Object，Object没有doSomethingsuper.doSomething(); }}.run();}
}正确写法：
class Outer {public void doSomething() {System.out.println(Outer.doSomething);}public void run() {new Runnable() {@Overridepublic void run() {// 正确：用Outer.this调用外部类方法Outer.this.doSomething();}}.run();}
}记住：super在匿名类里永远指向直接父类，如果你想调外部类的方法，必须用Outer.this.method()。这个规则在Java 8的lambda表达式里同样适用，只是lambda没有显式的super，但逻辑一致。
复现与修复代码：一步步搞定super难题
下面给出一个完整的复现案例，包含常见错误和修复方案。你可以直接复制到IDE里运行。
场景：父类字段private，子类想通过super访问
class Base {private int id;public Base(int id) {this.id = id;}// 提供getterpublic int getId() {return id;}
}class Sub extends Base {public Sub(int id) {super(id);}public void printId() {// 错误：super.id无法访问，因为id是private// System.out.println(super.id); // 正确：通过getter访问System.out.println(ID: + super.getId());}
}修复要点：父类字段如果是private，子类必须通过public/protected的getter/setter访问。
如果字段是protected，可以直接用super.id访问。
不要试图用反射去改private字段，这会破坏封装性，而且性能差。场景：构造器链中super和this的冲突
class A {public A() {System.out.println(A());}public A(int x) {System.out.println(A(int));}
}class B extends A {public B() {// 错误：this(1)和super()不能同时存在，且this必须在第一行// this(1); // super(); System.out.println(B());}public B(int x) {super(x); // 正确：调用A(int)System.out.println(B(int));}
}修复方案：如果子类构造器需要调用父类带参构造器，直接用super(args)。
如果需要复用子类其他构造器，用this(args)，但this()必须在第一行，且不能和super()同时出现。
如果父类只有无参构造器，子类不写super时，编译器会默认插入super()。性能陷阱：super调用静态方法
class StaticParent {public static void staticMethod() {System.out.println(Static method called);}
}class StaticChild extends StaticParent {public void test() {// 错误：super.staticMethod()编译报错// super.staticMethod(); // 正确：直接通过类名调用StaticParent.staticMethod();}
}静态方法没有“实例”概念，super指向的是父类实例，所以不能用super调用静态方法。这是Java设计的硬性规定，别试图绕过。
规避建议：把super规则刻进肌肉记忆构造器第一行原则：子类的构造器第一行必须是super(...)或this(...)，否则编译器默认插入super()。养成习惯，写构造器时先写super，再写其他逻辑。
访问权限检查：用super访问父类成员前，先确认该成员不是private。如果是private，要么改权限，要么用getter/setter。
匿名类里别用super调外部类：记住super指向直接父类，调外部类方法用Outer.this.method()。
静态方法不用super：直接通过类名调用，别画蛇添足。
调试时看字节码：如果super行为不符合预期，用javap -c查看字节码，看看编译器到底生成了什么指令。这能帮你确认super指向哪个父类方法。我在实际项目中，遇到过因为super调用顺序不对导致的NPE。当时父类构造器里初始化了一个集合，子类构造器里在super()之前访问这个集合，结果NPE。后来加了日志，发现父类构造器根本没执行完，集合还是null。修复方法很简单：把访问集合的代码移到super()之后。
super虽然是个小关键字，但背后的规则很硬。Java的设计哲学是“显式优于隐式”，super的编译期绑定就是为了让行为可预测。你不需要在运行时担心super指向哪个类，因为编译器已经帮你定死了。
你公司项目里是怎么处理super相关的重构的？有没有遇到过因为super调用顺序或权限问题导致的线上bug？欢迎评论区聊聊，一起避坑。
面试被问super原理答不上？图解原理帮你Java中super彻底避坑
面试官盯着你的简历，问：“Java里的super关键字，底层到底怎么实现的？为什么有时候会报错？”你脑子里一片空白，只能支支吾吾说“就是调用父类方法”。这种尴尬，我见过太多次了。很多开发者觉得super很简单，不就是个前缀吗？但一旦涉及构造器链、字段遮蔽、或者在匿名内部类里用super，立马就懵。
其实，super的本质是编译期确定的引用，指向当前对象创建时的直接父类实例。它不是运行时动态查找，而是Java编译器帮你插了一根“线”，直接连到父类的代码块。为了把这事说透，我用图解原理的方式，把super的底层逻辑、常见报错场景、正确写法对比，一次性讲清楚。看完这篇，你不仅能应付面试，还能在代码里避开那些让人抓狂的NPE和编译错误。
坑的现象：super调用报错，到底怪谁？
先来看一个真实场景。你在维护一个老项目，重构时把父类的一个字段从protected改成了private，然后子类里有一行代码：super.name = new;。编译直接报错：super.name has private access in Parent。
别慌，这不是super坏了，是访问权限卡住了你。super关键字只能访问父类中非私有的字段和方法。如果父类字段是private，子类通过super是够不着的，必须通过getter/setter，或者把字段改成protected/public。
更隐蔽的坑在构造器里。很多新手写：
public class Child extends Parent {public Child() {super.name = child; // 编译错误！}
}这个错误不是权限问题，而是构造器执行顺序问题。Java规定，子类的构造器第一行必须是super(...)或this(...)。如果你在super()之前访问super.name，此时父类对象还没初始化，字段还是默认值（null或0），编译器直接拒绝你这种“越级”操作。
另一个高频坑是匿名内部类里的super。比如你在一个匿名Runnable里想调用外部类的方法：
new Runnable() {public void run() {super.run(); // 编译错误！}
}这里super指向的是Object类，因为匿名类直接继承Object。你想调外部类的方法，得用OuterClass.this.method()，而不是super。这个错误在回调、监听器场景里特别常见，很多人栽在这里。
根本原因：super是编译期绑定，不是运行时查找
要彻底搞懂super，得先撕掉“super是个运行时对象”的错觉。根据Java语言规范（JLS）第8.11节，super是一个限定名（qualified name），在编译阶段就确定了它指向哪个父类。
图解一下：类加载阶段：JVM加载Child类时，会记录它的直接父类是Parent。
编译阶段：javac看到super.method()，会检查Parent类里是否有method，并把调用指令编译成invokevirtual Parent.method。
运行阶段：JVM执行字节码时，直接调用Parent的方法，不会再去查Child有没有覆盖，也不会查更上层的祖父类。关键点来了：super不能用于静态成员。因为静态方法属于类，不属于实例，而super指向的是“父类实例”，静态方法根本没有“实例”的概念。所以super.staticMethod()是编译错误，必须用Parent.staticMethod()。
还有一个容易被忽略的点：super调用的是父类中未被覆盖的方法。如果Parent的method被GrandParent覆盖，而Child没有覆盖，那么super.method()调用的是Parent的版本，而不是GrandParent的。这和动态绑定（多态）完全不同。
我在CSDN上看到过不少帖子讨论这个问题，很多开发者混淆了super和this的区别。简单说：this指向当前对象，super指向当前对象的父类部分。在单继承体系下，这个父类部分是唯一的，所以super是明确的。
正确写法对比：避开这些坑，代码才稳
下面用两段代码对比，左边是典型错误写法，右边是正确写法。注意看注释里的关键点。
错误写法：构造器里过早访问super字段
class Parent {protected String name;public Parent(String name) {this.name = name;}
}class Child extends Parent {public Child() {// 错误1：在super()之前访问super.name，此时父类未初始化super.name = child; super(parent); // 错误2：super()必须在第一行，且不能带参数（除非父类有对应构造器）}
}这段代码有两个致命问题：super.name在super()之前访问，编译器报错：Cannot reference a field before super() call。
即使父类有带参构造器，super(parent)也必须在第一行，且不能和其他语句混合。正确写法：严格遵循构造器顺序
class Parent {protected String name;public Parent(String name) {this.name = name;System.out.println(Parent constructor called);}
}class Child extends Parent {public Child() {// 正确：super()必须是第一行，调用父类构造器super(parent);// 现在可以安全访问super.name，因为父类已初始化super.name = child;System.out.println(Child constructor called);}
}执行顺序：调用super(parent)，执行Parent构造器，name被设为parent。
回到Child构造器，super.name = child，name被覆盖为child。
输出：Parent constructor called → Child constructor called。匿名内部类里的super陷阱
class Outer {public void doSomething() {System.out.println(Outer.doSomething);}public void run() {new Runnable() {@Overridepublic void run() {// 错误：super指向Object，Object没有doSomethingsuper.doSomething(); }}.run();}
}正确写法：
class Outer {public void doSomething() {System.out.println(Outer.doSomething);}public void run() {new Runnable() {@Overridepublic void run() {// 正确：用Outer.this调用外部类方法Outer.this.doSomething();}}.run();}
}记住：super在匿名类里永远指向直接父类，如果你想调外部类的方法，必须用Outer.this.method()。这个规则在Java 8的lambda表达式里同样适用，只是lambda没有显式的super，但逻辑一致。
复现与修复代码：一步步搞定super难题
下面给出一个完整的复现案例，包含常见错误和修复方案。你可以直接复制到IDE里运行。
场景：父类字段private，子类想通过super访问
class Base {private int id;public Base(int id) {this.id = id;}// 提供getterpublic int getId() {return id;}
}class Sub extends Base {public Sub(int id) {super(id);}public void printId() {// 错误：super.id无法访问，因为id是private// System.out.println(super.id); // 正确：通过getter访问System.out.println(ID: + super.getId());}
}修复要点：父类字段如果是private，子类必须通过public/protected的getter/setter访问。
如果字段是protected，可以直接用super.id访问。
不要试图用反射去改private字段，这会破坏封装性，而且性能差。场景：构造器链中super和this的冲突
class A {public A() {System.out.println(A());}public A(int x) {System.out.println(A(int));}
}class B extends A {public B() {// 错误：this(1)和super()不能同时存在，且this必须在第一行// this(1); // super(); System.out.println(B());}public B(int x) {super(x); // 正确：调用A(int)System.out.println(B(int));}
}修复方案：如果子类构造器需要调用父类带参构造器，直接用super(args)。
如果需要复用子类其他构造器，用this(args)，但this()必须在第一行，且不能和super()同时出现。
如果父类只有无参构造器，子类不写super时，编译器会默认插入super()。性能陷阱：super调用静态方法
class StaticParent {public static void staticMethod() {System.out.println(Static method called);}
}class StaticChild extends StaticParent {public void test() {// 错误：super.staticMethod()编译报错// super.staticMethod(); // 正确：直接通过类名调用StaticParent.staticMethod();}
}静态方法没有“实例”概念，super指向的是父类实例，所以不能用super调用静态方法。这是Java设计的硬性规定，别试图绕过。
规避建议：把super规则刻进肌肉记忆构造器第一行原则：子类的构造器第一行必须是super(...)或this(...)，否则编译器默认插入super()。养成习惯，写构造器时先写super，再写其他逻辑。
访问权限检查：用super访问父类成员前，先确认该成员不是private。如果是private，要么改权限，要么用getter/setter。
匿名类里别用super调外部类：记住super指向直接父类，调外部类方法用Outer.this.method()。
静态方法不用super：直接通过类名调用，别画蛇添足。
调试时看字节码：如果super行为不符合预期，用javap -c查看字节码，看看编译器到底生成了什么指令。这能帮你确认super指向哪个父类方法。我在实际项目中，遇到过因为super调用顺序不对导致的NPE。当时父类构造器里初始化了一个集合，子类构造器里在super()之前访问这个集合，结果NPE。后来加了日志，发现父类构造器根本没执行完，集合还是null。修复方法很简单：把访问集合的代码移到super()之后。
super虽然是个小关键字，但背后的规则很硬。Java的设计哲学是“显式优于隐式”，super的编译期绑定就是为了让行为可预测。你不需要在运行时担心super指向哪个类，因为编译器已经帮你定死了。
你公司项目里是怎么处理super相关的重构的？有没有遇到过因为super调用顺序或权限问题导致的线上bug？欢迎评论区聊聊，一起避坑。
