先问大家一个问题如果在子类里写一行代码System.out.println(name)而name这个字段在父类、子类里都出现过你觉得打印的是哪一个这是很多 Java 基础题和面试八股里最容易翻车的一个点。它背后就是 Java 继承体系中非常经典的成员变量访问问题绕不开三个东西就近原则、this、super。这篇文章把这块彻底掰开揉碎。我会先讲清楚变量查找的优先级再分别拆解 this 和 super 的本质区别接着把“字段隐藏”和“方法重写”这对容易混淆的兄弟放在一起对比最后用真实场景、经典笔试题和调试经验帮你把知识钉进脑子里。不管你是正在准备面试还是写业务代码时经常被同名变量恶心到这篇内容都值得读完。1. 就近原则Java 变量查找的默认逻辑1.1 最经典的“形参遮蔽成员变量”场景很多人第一次接触 this都是因为构造器或 setter 方法的形参和成员变量重名。比如下面这段代码public class NumberBox { private int value 100; public void printValue(int value) { System.out.println(value); // 输出参数200 System.out.println(this.value); // 输出成员100 } public static void main(String[] args) { NumberBox box new NumberBox(); box.printValue(200); } }运行结果分别是200和100。第一个value之所以输出 200是因为方法体内离它最近的是形参变量形参本质上是方法级的局部变量第二个用this.value强制绕开了形参直接去访问实例成员变量。这就是就近原则最直观的体现Java 在方法体里解析变量名时会优先选择“当前作用域内最近”的那个名字。不要小看这个规则很多线上 bug 都源于大家对它的理解停留在“好像是这样”真到了代码里却不知道哪一层局部变量把字段盖住了。1.2 完整的变量查找优先级清单在子类方法内部如果你直接写一个变量名而不加任何修饰实际查找顺序是这样的当前方法体内的局部变量包括参数、循环变量、catch 块参数当前类的成员变量相当于隐式this.父类继承下来的成员变量再继续向上找直到找到一个可访问的同名变量为止我见过不少初学者把就近原则理解为“离得近的成员变量优先”这其实不完整。真正优先级最高的是局部变量。下面这个例子能帮你把层级拉开class GrandFather { protected String color 金色; } class Father extends GrandFather { protected String color 红色; } class Son extends Father { public void test(String color) { System.out.println(color); // 局部参数 System.out.println(this.color); // 当前类没有找 Father红色 System.out.println(super.color); // 直接去父类找 Father红色 } }注意这里Son自己并没有声明color字段所以this.color会沿继承链向上到Father去拿拿到的就是红色。而super.color也是从父类开始查最终也在Father找到红色。假如Father本身没有这个字段两者还会继续往上到GrandFather里找。只有当父类字段是private时子类才会因为不可访问而编译报错。为了方便记忆可以把它简化成一张表写法查找方向直接写变量名局部变量 - 当前类成员 - 父类成员逐级向上this.变量名当前类成员 - 父类成员逐级向上super.变量名父类成员 - 爷爷类成员逐级向上但不能碰不可访问的1.3 为什么 Java 允许“遮蔽”存在很多人会问既然同名变量这么容易搞乱Java 为什么不直接禁止局部变量和字段重名答案是——完全禁止反而更难受。想象你写了一个带 5 个参数的构造器为了表达清晰你特别希望参数名就叫name、age、address如果 Java 强制你不能和成员变量重名你就得写成nameParam、ageParam代码会变得非常啰嗦。允许遮蔽给了你一定的自由度代价就是你必须知道 this 的存在并且在需要成员变量时主动说出来。从语言设计角度看就近原则也符合人类阅读习惯我在一个小范围内看到变量value第一反应就是它大概率属于这个小范围。局部变量是临时数据成员变量是对象状态默认偏向“局部优先”更直观。问题是这个“默认”在继承场景里会诱导出不少隐蔽错误这也是后面要重点聊的部分。2. this 关键字当前对象的“身份证”2.1 从 JVM 视角理解 this你可能已经会用了但未必清楚 this 到底是什么。简单说this 是当前正在执行实例方法的那个对象的引用。Java 虚拟机调用实例方法时会暗中把当前对象作为参数传进去方法体里就可以用 this 访问到这个对象自身的成员。这个解释能帮你理解两件事静态方法里为什么不能用this因为静态方法不依赖任何具体对象根本不存在“当前对象”所以编译直接报错。为什么继承里this.字段可能找到父类字段因为 this 代表的始终是这个对象本身字段查找是从当前类开始找不到才往上走。它只负责起点不负责终点。看一个多态的例子class Animal { void who() { System.out.println(动物); } } class Dog extends Animal { Override void who() { System.out.println(狗); } } // 调用场景 Animal a new Dog(); a.who(); // 输出狗这里执行who()的是Dog对象虽然引用变量类型是Animal方法调用仍然会分派给Dog重写后的版本。理解这个之后再看后面的字段隐藏就会清晰很多字段和方法的绑定机制截然不同方法走动态绑定字段走静态绑定。2.2 this 的四种典型用法第一种区分同名变量。这是最常见的用途构造器和 setter 里遍地都是。public class User { private String name; public User(String name) { this.name name; } public void setName(String name) { this.name name; } }这里如果把this.name name顺手写成name name编译器会认为是把局部变量赋值给局部变量成员变量的值一点没变bug 就悄悄出现了。第二种this()调用本类的其他构造器。用这种方式可以避免构造器代码重复。public class Student { private String name; private int age; public Student() { this(未知, 0); // 调用双参构造器 } public Student(String name, int age) { this.name name; this.age age; } }要注意this()和super()一样都必须在构造器的第一行出现并且两者不能同时出现。原因后面讲构造器调用链时详说。第三种return this做链式调用。很多流式 API 就是这么实现的。public class QueryBuilder { private String table; private String condition; public QueryBuilder table(String table) { this.table table; return this; } public QueryBuilder where(String condition) { this.condition condition; return this; } public String build() { return SELECT * FROM table WHERE condition; } } // 使用 QueryBuilder builder new QueryBuilder(); String sql builder.table(user).where(age 18).build();第四种把当前对象传给外部方法。比如在事件监听器或者观察者模式里经常能看到register(this)这种写法这里的 this 代表“当前这个对象实例”。2.3 继承场景下 this 的查找规则正因为 this 是真正的对象所以在子类对象里用this.字段如果子类自己有就优先用子类的没有才向父类找。但这里有一个让人头痛的细节当父类和子类有同名字段时this.字段拿到的通常是子类自己的字段而不是父类的。class Person { String name 人; } class Teacher extends Person { String name 老师; void printName() { System.out.println(this.name); } }输出是老师。在这个对象里其实同时存在着两个name字段一个属于Person一个属于Teacher肉眼看不见但内存里它们各占一份。用this.name时Java 从Teacher类开始找直接命中子类字段要拿父类的那个就得请super出场了。3. super 关键字沿着继承链向上查找3.1 先纠正一个常见的误解很多人把super理解成“父类对象的引用”这个理解不完全对。Java 创建子类对象时并不会额外创建一个独立的父类对象。你new Teacher()时虚拟机只创建了一个对象这个对象里包含了完整的状态继承下来的字段和方法都在同一块内存空间里。super更像是一个语法指令它告诉编译器从我父类这一层开始往上找字段或方法。它不是引用变量不能把它赋值给别的变量也不能把它当作方法参数传出去。如果你尝试写Object obj super;编译直接失败。用一句话区分this是对象视角super是类层级视角。3.2 用 super 访问成员变量和实例方法还是上面的例子现在让子类同时输出三类值class Animal { String name 动物; void speak() { System.out.println(发出声音); } } class Dog extends Animal { String name 小狗; void show() { System.out.println(name); // 小狗优先当前类成员 System.out.println(this.name); // 小狗this 从当前类开始 System.out.println(super.name); // 动物super 从父类开始 } Override void speak() { super.speak(); // 先复用父类逻辑 System.out.println(汪汪); } }这段代码还展示了super的第二种典型用法调用父类实例方法。这在重写方法时很实用比如你重写了speak()但希望先执行父类的通用逻辑再附加自己的内容就可以用super.speak()把父类版本调出来。3.3 构造器里的 super()为什么必须第一行这可能是 Java 继承里被问得最多的问题之一。当你创建子类对象时子类构造器的第一行会隐式调用super()哪怕你什么都没写。这意味着每次创建子类对象父类都会先完成初始化。class Person { String name; Person(String name) { this.name name; } } class Student extends Person { int grade; Student(String name, int grade) { super(name); // 显式调用父类构造器必须第一行 this.grade grade; } }如果父类没有无参构造器子类里不写super(参数)就会编译报错这也是很多新手一开始看不懂的报错信息。为什么super()必须放在第一行本质上是一个安全策略子类构造器后面还可能访问父类的字段或方法如果父类状态还没初始化完毕后面这些访问就是在使用一个半成品。Java 干脆规定先用super()把父类收拾利索再干子类的活。同理this()调用兄弟构造器也必须在第一行因为兄弟构造器执行完当前对象才算完整可用这也是this()和super()不能同时出现的原因——第一行只能容纳一个调用。3.4 静态上下文里为什么不能碰 this/super静态方法属于类本身不依赖实例所以静态方法内部没有this自然也没有基于this的super。如果你在静态方法里写super.xxx或this.xxx编译器会直接拒绝。class A { int x 1; } class B extends A { static void test() { // System.out.println(this.x); // 编译错误 // System.out.println(super.x); // 编译错误 } }但这里有个小细节子类静态方法里是可以直接访问父类的静态字段的因为静态成员本身可以按照类层级关系直接引用不需要实例。只是这种访问不经过 this/super 这两个关键字。4. 成员变量隐藏与方法重写一对常被混淆的兄弟4.1 为什么字段没有“重写”在面向对象里子类可以对父类的实例方法进行重写然后实现多态。但字段没有这个待遇字段只能“隐藏”英文叫 hiding。所谓隐藏就是子类声明了一个和父类同名的字段父类的那个字段在子类里被“盖上”了但它并没有消失只是不能直接用名字访问。两者最大的区别在于绑定时机对比维度成员变量隐藏实例方法重写绑定机制编译期静态绑定运行期动态绑定依据什么决定引用变量的声明类型对象的实际运行类型子类是否共存父子两字段同时存在子类方法覆盖父类方法父类引用访问访问父类字段调用子类方法实际开发建议尽量避免面向对象核心能力打个生活化比方你有一部手机和一个手机壳手机壳上印着“iPhone 15”但手机本身可能是 iPhone 14。字段就像手机壳上的标签你站在哪个壳面前看到的就是哪个标签方法则更像手机的实际硬件翻到背面敲一下敲出来的还是它真实的型号。4.2 经典易错题父类引用指向子类对象这道题几乎可以当作“字段隐藏”的试金石class Parent { String name 父类字段; } class Child extends Parent { String name 子类字段; } // 测试 Child child new Child(); Parent parent child; // 父类引用指向同一个子类对象 System.out.println(child.name); // 子类字段 System.out.println(parent.name); // 父类字段 System.out.println(((Child) parent).name); // 子类字段同一个对象child通过不同的引用类型去访问同名字段结果完全不同。因为字段在编译期就根据引用的声明类型敲定了parent被声明成Parent于是parent.name读取的是Parent里那一个child被声明成Child读取的就是Child里那一个。换成方法就完全反过来class Parent { void say() { System.out.println(父类方法); } } class Child extends Parent { Override void say() { System.out.println(子类方法); } } Parent p new Child(); p.say(); // 子类方法因为方法运行期看实际对象类型这就是我前面说的“字段看类型方法看对象”。搞不清这一点面试时很容易在前面那道题上栽跟头。4.3 什么情况下强烈推荐用 super 和 this当你确实遇到了同名字段别犹豫用关键字把意图写明确想要子类字段this.字段想要父类字段super.字段比如在子类方法里既要统计子类自己的 bonus又要拿父类的 bonus 做对比那代码里就必须出现this.bonus和super.bonus。少写关键字全部裸写bonus结果大概率不是你想要的。不过这里也想提前给大家提个醒能用关键字把坑填平不等于这个坑就值得踩。更推荐的方案是用封装来消灭同名字段这部分到第 7 章我再细说。5. 综合实战一个带继承的“员工工资”场景5.1 子类同名字段对父类方法的“无感”普通字段隐藏在单类里可能只是小麻烦一旦牵涉到父类方法内部逻辑就会变成很隐蔽的 bug。我用一个员工工资的例子演示。公司定义了员工类和经理类经理是员工的一种所以用继承public class Employee { protected String role 员工; protected double baseSalary 8000; protected double bonus 1000; public double getSalary() { return baseSalary bonus; // bonus 在编译期绑定为 Employee.bonus } } public class Manager extends Employee { protected double bonus 5000; // 和父类字段同名形成隐藏 public double getSelfBonus() { return bonus; // 就近原则5000 } public double getParentBonus() { return super.bonus; // 1000 } public double getManagerSalary() { return baseSalary bonus; // 8000 5000 13000 } }执行结果Manager manager new Manager(); System.out.println(manager.getSalary()); // 9000 System.out.println(manager.getManagerSalary()); // 13000 System.out.println(manager.getSelfBonus()); // 5000 System.out.println(manager.getParentBonus()); // 1000你可能会觉得奇怪经理明明已经被赋予了 5000 的 bonus为什么父类里的getSalary()只算出 9000而不是 13000原因还是那四个字字段隐藏。getSalary()这个方法体是在Employee类里写死的baseSalary bonus里的bonus在编译期就绑定了Employee.bonus。即使运行时执行方法的对象是Manager方法体里读到的字段依然是按照定义这个方法的类来解析的它感知不到子类里那个同名的 5000。这是一个真实项目里很容易踩的坑。比如你在子类里覆盖了某个字段期望所有逻辑都把这个覆盖后的值当作标准结果父类一堆方法根本不认最后数据对不上排查半天才发现是字段隐藏。5.2 构造器调用顺序与字段初始化时机再叠加一个更容易出错的因素构造器顺序。创建Manager对象时内部执行顺序大致是为对象分配内存所有字段先赋默认值数字是 0引用是 null调用父类构造器执行父类字段初始化和构造器代码回到子类执行子类字段初始化和构造器代码这意味着在父类构造器执行期间子类字段还没有被正式赋值仍处于默认状态。如果这时候父类构造器里调用了一个被子类重写的方法而且这个方法直接访问了子类字段你看到的就很可能是 null 或 0。class Parent { String info 父类信息; Parent() { printInfo(); // 这里会调用被子类重写的方法 } void printInfo() { System.out.println(父类 info); } } class Child extends Parent { String info 子类信息; Override void printInfo() { System.out.println(子类 info); } } // 测试 new Child(); // 输出子类null这里很多人会以为是“子类字段值丢了”其实不是。动态绑定让父类构造器里的printInfo()调用到了子类的重写版本但此时子类字段还没走到初始化那一步所以读到的还是默认值null。这也是很多团队规范里强调“避免在构造器中调用可重写方法”的原因。无论是面试还是实际编码这个知识点都值得记牢。5.3 消除隐患用方法代替直接字段访问上面工资场景的正确设计思路不是靠super.bonus到处补救而是把字段访问收口到方法里然后利用方法的动态绑定来实现多态public class Employee { private double bonus 1000; public double getBonus() { return bonus; } public double getSalary() { return baseSalary getBonus(); // 方法调用动态绑定 } } public class Manager extends Employee { private double bonus 5000; Override public double getBonus() { return bonus; // 子类重写方法 } } // 测试 Manager manager new Manager(); System.out.println(manager.getSalary()); // 13000动态绑定到子类 getBonus()改成getBonus()方法之后getSalary()内部是通过方法获取奖金Java 的实例方法天然支持动态绑定所以Manager对象调用时会命中子类重写的getBonus()拿到 5000。这个设计既保留了多态能力又彻底绕开了字段隐藏的泥潭。6. 高频面试题把继承成员变量访问的坑一次讲全6.1 常见问题速查表面试官翻来覆去问的基本就这些问题答案本质原因子类和父类有同名字段子类直接打印子类字段就近原则当前类成员优先父类引用指向子类对象访问字段父类字段字段编译期静态绑定看声明类型子类方法想强制访问父类字段用super.字段显式告诉编译器从父类开始查找this()和super()能同时写吗不能都必须第一行第一行只能有一个静态方法里能用 this/super 吗不能静态方法没有当前实例对象父类构造器能调用被重写的子类方法吗能有风险方法动态绑定但子类字段未初始化父类中访问子类隐藏字段访问不到字段已经绑定父类声明的那个6.2 一道典型的连环笔试题把前面几个知识点叠起来就成了一道经典笔试题class A { String text A; A() { show(); } void show() { System.out.println(text); } } class B extends A { String text B; Override void show() { System.out.println(text); } } // 测试 new B();输出是什么答案是null。拆解一下new B()先进入B构造器B构造器第一行隐式调用super()进入A构造器A构造器里的show()因为动态绑定实际执行B.show()B.show()访问B.text但此时B的字段还没有执行初始化赋值所以打印null如果你把B.show()改成System.out.println(super.text)输出就不是null而是A因为super.text绑定的是已经完成初始化的A.text。这个题目把“构造顺序 动态绑定 字段隐藏 初始化时机”四个考点全串起来值得多刷几遍。6.3 追问把方法改成字段访问会怎样面试官通常会再追问一句“既然super.text能用那super.show()呢”super.show()的语义是“从父类开始找我这个方法的实现”但 Java 方法调用仍然受动态绑定约束。如果子类重写了show()super.show()在子类内部被调用时只有第一层使用的是父类实现如果父类实现内部又调用了其他虚方法还是会分派到子类。所以不能把super看作“强制调用父类方法”的万能钥匙它只是告诉编译器“查找起点从父类开始”。7. 编码规范与调试经验我踩过的那几个坑7.1 团队里为什么普遍禁用字段隐藏字段隐藏虽然语法合法但在实际项目里多是麻烦制造者。代码评审时如果看到子类里出现了父类同名字段我一般都会建议改掉理由很现实可读性差读代码的人看到bonus这个变量很难判断到底指哪个版本必须反复往上找继承关系。容易改错你在子类里写了一行this.bonus 5000本来只想改子类的字段结果同事接手后照着这个模式在别处写了裸bonus两个字段被搅在一起。父类方法隐患父类已有的方法不会感知到子类隐藏的字段行为会和你直觉完全相反。这不是说this和super没用而是说它们应该被当成“最后手段”。正常业务代码里绝大多数同名字段完全可以通过封装设计避免。7.2 规避同名字段的三个具体做法第一个做法父类字段尽量改成private并提供受保护的 getter/setter。子类需要时通过方法访问而不是直接声明同名字段去覆盖。public class BaseConfig { private int timeout 3000; protected int getTimeout() { return timeout; } }第二个做法子类里如果真的要表示新的业务含义那就起一个语义完全不同的字段名不要复用父类的名字。比如Manager里的奖金字段可以叫managerBonus或者specialBonus。第三个做法字段用final修饰从语言层面禁止被子类重新赋值或覆盖。如果父类说这个字段是初始配置子类不要动它final就是很好的约束。7.3 调试技巧断点里怎么区分父子同名字段真遇到字段隐藏问题IDE 断点调试是最高效的方式。以 IntelliJ IDEA 为例如果你在子类方法里打了断点Variables 面板通常只会显示当前局部变量和子类字段。想看父类的同名字段可以把表达式写在 Evaluate 表达式求值框里查看父类的字段((Parent) this).field查看子类的字段((Child) this).field注意强转时必须保证实际对象确实是父子关系否则会抛类型转换异常。有时候直接在断点窗口输入super.field是不被支持的用强转表达式反而稳妥。另外IDEA 会在子类出现同名字段时给出黄色警告Field name hides field name in superclass。很多新手看到警告就忽略了我建议把它当作错误级处理因为这条警告背后藏着的就是今天讲的这一整篇问题。7.4 一个真实产品的 debug 故事最后分享一段我自己的经历。有一年我们在做薪酬系统的改造员工类Employee里保存了基础工资和奖金奖金用一个bonus字段表示经理类Manager继承了员工业务上经理的奖金构成更复杂于是同事在 Manager 里又加了一个bonus字段以为这样天然就“覆盖”了旧逻辑。结果上线后经理的薪资报表总是差一截。单看Manager的新方法能算出正确的 13000但历史计算逻辑跑一遍却出来 9000。大家一开始以为是数据库问题排查了半天最后把断点打进去才发现旧逻辑里有一个getSalary()方法定义在Employee类中它根本读不到Manager自己新加的那个bonus字段两个对象眼睁睁站在同一个内存里却各看各的数据。这件事之后我给自己定了一条规矩看到字段隐藏的警告先解决再继续写代码。能抽到父类方法里的逻辑就抽到方法里用动态绑定不能抽的就把字段私有化并收口访问。别等 line 上的数值对不上再回头来翻这几行代码。如果你正在写一个类层次比较深的项目尤其要记住继承不是复制粘贴父类方法里引用的字段永远以它定义时所在的那个类为准。理解这一点你对 Java 继承的认知就超过一大半人了。