1. 项目概述从一道面试题看Java继承的本质“Father fs new Son(); fs想调用子类的方法怎么整” 这个问题相信不少在准备Java面试的朋友都见过尤其是在一些大厂的面试题里。它像一把钥匙直接捅到了Java面向对象核心机制——继承和多态——最让人迷惑的那个锁眼上。表面看这只是一个关于引用类型和对象类型的调用问题但往深了挖它牵扯出的是整个Java继承体系中子类到底能从父类那里“拿到”什么以及拿到的这些东西到底该怎么用、什么时候能用。我自己带团队面试时也特别喜欢用这类问题开场。它能快速区分出候选人是背了八股文还是真理解了底层原理。很多人能脱口而出“编译看左边运行看右边”但再追问一句“为什么这么设计private方法能被继承吗static方法呢子类对象在内存里到底长啥样” 能清晰回答的人就少了一大半。所以今天我们不只聊那道题的标准答案更要把“子类继承父类哪些内容”这个事彻底掰开揉碎。我会结合JVM内存模型、字节码以及我实际开发中踩过的坑带你从根上理解它。理解透了无论是应付面试还是写出更健壮、更易维护的代码都会轻松很多。2. 继承的核心子类从父类“获得”了什么很多人对继承的理解停留在“子类拥有父类的一切”这其实是个非常危险的误解。继承不是“复制粘贴”而是一种“访问权限和结构关系”的建立。子类对象在内存中确实包含了一个完整的父类结构但你能通过子类引用访问到哪些部分则完全取决于访问权限修饰符和成员类型。2.1 确定能继承的成员可访问的这部分是子类可以像使用自己成员一样直接使用的。1. 非私有的实例变量字段只要不是private子类就可以直接访问或通过继承的公共方法间接操作。public class Father { protected String familyName 张; public int age 40; String defaultHobby 钓鱼; // 包级私有同包子类可访问 private String secret 私房钱; // 子类不可直接访问 } public class Son extends Father { public void printInfo() { System.out.println(familyName); // OK protected System.out.println(age); // OK, public System.out.println(defaultHobby); // 同包下 OK 不同包则编译错误 // System.out.println(secret); // 编译错误private成员对子类不可见 } }注意protected是一个关键点。它允许子类访问即使跨包但仅限于通过继承关系而不能通过父类引用来访问其他对象的protected成员。这是面试常考点。2. 非私有的实例方法这是实现“多态”的基石。子类可以调用更重要的是可以重写(Override)。public class Father { public void speak() { System.out.println(我是父亲); } protected void teach() { System.out.println(传授经验); } private void think() { System.out.println(内心活动); } } public class Son extends Father { Override public void speak() { System.out.println(我是儿子); } Override protected void teach() { super.teach(); // 可以调用父类实现 System.out.println(并加入了新方法); } // 无法重写 think(), 因为它在子类不可见 }3. 嵌套类内部类/静态嵌套类如果父类的嵌套类不是private的子类也可以使用和继承它们。public class Father { public static class StaticNested {} protected class Inner {} } public class Son extends Father { StaticNested nested new StaticNested(); // 可以使用 Inner inner new Inner(); // 可以使用 }2.2 确定不能继承的成员1. 构造方法 (Constructors)这是最重要的一个“不能继承”。子类不能继承父类的构造方法但必须调用父类的构造方法隐式或显式来初始化从父类继承来的部分。这就是为什么子类构造方法的第一行要么是super(...)要么是this(...)要么编译器帮你隐式加上super()。public class Father { public Father(String name) { System.out.println(Father constructor: name); } } public class Son extends Father { public Son() { super(默认名); // 必须显式调用因为父类没有无参构造 System.out.println(Son constructor); } // 如果写 public Son() {} 会编译错误因为找不到父类无参构造 }2. 被private修饰的成员private意味着“仅对本类可见”。这是封装性的核心体现。子类对象在内存中有这块数据但没有任何直接访问的途径。只能通过父类提供的非私有方法如getter/setter间接访问。public class Father { private int secretWealth; public int getWealth() { return secretWealth; } // 子类可通过此方法访问 }3. 初始化块 (Initializer Blocks)静态初始化块和实例初始化块会随着类的加载和对象的创建而执行但它们本身不是成员谈不上继承。子类对象创建时会触发父类对应的初始化块执行。public class Father { { System.out.println(Father instance block); } static { System.out.println(Father static block); } } public class Son extends Father { { System.out.println(Son instance block); } static { System.out.println(Son static block); } public static void main(String[] args) { new Son(); // 输出顺序 // Father static block // Son static block // Father instance block // Son instance block } }4. 被final修饰的方法但变量可继承final方法不能被重写但可以被继承和调用。这里容易混淆。“不能继承”指的是不能重写其行为而不是不能使用。final变量尤其是静态常量public static final是可以被继承准确说是访问的。2.3 特殊成员静态成员与继承的错觉这是一个超级大坑。静态成员变量和方法属于类本身不属于任何实例。因此不存在静态成员的“重写”只存在“隐藏”。public class Father { public static String staticField Father Static; public static void staticMethod() { System.out.println(Father Static Method); } public void instanceMethod() { System.out.println(Father Instance Method); } } public class Son extends Father { public static String staticField Son Static; // 隐藏不是重写 public static void staticMethod() { System.out.println(Son Static Method); } Override public void instanceMethod() { System.out.println(Son Instance Method); } } public class Test { public static void main(String[] args) { Father f new Son(); System.out.println(f.staticField); // 输出: Father Static f.staticMethod(); // 输出: Father Static Method f.instanceMethod(); // 输出: Son Instance Method (多态) Son s new Son(); System.out.println(s.staticField); // 输出: Son Static s.staticMethod(); // 输出: Son Static Method } }关键点对于静态成员引用类型是什么就调用哪个类的静态成员。它不参与多态。Father fs new Son(); fs.staticMethod()永远调用的是Father.staticMethod()。这是和实例方法最根本的区别。3. 内存模型与JVM视角子类对象如何构建理解了规则我们还得看看底层是怎么实现的。这能帮你从根本上消除疑惑。当你执行Son son new Son()时JVM在堆中创建了一个对象。这个对象并非简单的“一个Son对象”而是一个复合结构堆中开辟一块连续内存。首先包含一个完整的Father对象实例数据包括从Father的父类Object继承来的部分如对象头。即使Father的某些成员是private的这块内存里也为其分配了空间。紧接着在Father的数据后面存放Son类自己独有的实例数据。对象头中有一个指针指向方法区元空间中的Son类的类型信息。方法区中的Son类类型信息包含了整个继承链上所有可访问的方法信息。这里就引出了虚方法表Virtual Method Table, vtable的概念。每个类都有一个vtable里面列出了所有虚方法非private、非static、非final的实例方法的实际可调用入口地址。Father类的vtable包含speak(),teach()等方法的地址指向Father自己的实现。Son类的vtable也包含speak(),teach()。但是对于被重写的方法如speak()Son的vtable中speak()的地址指向的是Son类自己的实现。对于未被重写的方法或不可继承的方法则可能指向父类实现或为空。当通过引用调用方法时如fs.instanceMethod()编译器检查语法和访问权限编译期。运行时JVM根据对象的实际类型Son找到其vtable。根据方法签名在vtable中找到对应的条目。调用该条目指向的代码地址。这就是“运行看右边”的底层原理。而静态方法调用在编译期就确定了具体要调用哪个类的方法直接写入字节码的invokestatic指令中不经过vtable所以没有多态。4. 破解经典面试题Father fs new Son();现在我们回到那个最经典的面试题。通常它会以几种形式出现题目一以下代码输出什么class Father { public String name Father; public void method() { System.out.println(Father method); } } class Son extends Father { public String name Son; Override public void method() { System.out.println(Son method); } } public class Test { public static void main(String[] args) { Father fs new Son(); System.out.println(fs.name); fs.method(); } }输出Father Son method解析fs.name访问字段变量。字段没有多态性访问哪个字段取决于引用类型Father。所以输出Father。fs.method()调用实例方法。实例方法有多态性调用哪个方法取决于对象实际类型Son。所以输出Son method。题目二进阶如果方法是静态的或私有的呢class Father { private void privateMethod() { System.out.println(Father private); } public static void staticMethod() { System.out.println(Father static); } public void publicMethod() { System.out.println(Father public); } } class Son extends Father { // 这不是重写只是Son自己的一个同名私有方法 private void privateMethod() { System.out.println(Son private); } // 这是隐藏不是重写 public static void staticMethod() { System.out.println(Son static); } Override public void publicMethod() { System.out.println(Son public); } } public class Test { public static void main(String[] args) { Father fs new Son(); // fs.privateMethod(); // 编译错误Father中privateMethod不可见 fs.staticMethod(); // 输出: Father static (静态方法看左边) fs.publicMethod(); // 输出: Son public (实例方法看右边) } }题目三坑爹版涉及转型和ClassCastExceptionFather fs new Son(); // Son son fs; // 编译错误需要强制转型 Son son (Son) fs; // OK fs实际就是Son对象 son.sonSpecificMethod(); // 可以调用子类特有方法 Father f new Father(); // Son s (Son) f; // 运行时抛出 ClassCastException实操心得在进行向下转型(Son) fatherRef前一定要用instanceof进行判断这是避免ClassCastException的黄金法则。if (fatherRef instanceof Son) { Son s (Son) fatherRef; }5. 大厂面试真题实战与源码解析光说不练假把式。我们来看几道融合了继承、多态、甚至设计模式的大厂真题并附上可运行的源码和深度解析。5.1 真题一阿里巴巴-继承与初始化顺序题目写出下面代码的输出顺序并解释原因。public class Base { private String name base; public Base() { this.print(); } public void print() { System.out.println(Base print: name); } } public class Derived extends Base { private String name derived; public Derived() { // 隐含 super(); this.print(); } Override public void print() { System.out.println(Derived print: name); } public static void main(String[] args) { new Derived(); } }源码解析与输出Derived print: null Derived print: derived深度解析new Derived()触发Derived构造器。构造器第一行隐式调用super()即Base()构造器。进入Base()构造器此时Base的实例变量name已完成初始化 base。执行this.print()。关键点来了this指的是当前正在创建的对象其运行时类型是Derived。因此这里调用的是被重写的Derived.print()方法。在Derived.print()中打印name。但此时Derived的实例变量name初始化 derived还未执行因为父类构造器还未执行完。实例变量在构造器代码执行前进行默认初始化null和显式初始化。此时Derived的name还处于默认初始化的null状态。所以第一次打印Derived print: null。Base()构造器执行完毕返回Derived构造器。接着执行Derived的实例变量初始化name derived。执行Derived构造器中的this.print()此时name已初始化所以打印Derived print: derived。避坑指南永远不要在构造器中调用可被重写的方法。这会导致子类重写的方法在子类实例变量初始化之前被调用可能访问到未初始化的状态引发难以调试的bug。这是一条非常重要的实践经验。5.2 真题二腾讯-继承与多态在集合中的应用题目分析以下代码中list.add()和for循环输出的结果阐述原理。import java.util.ArrayList; import java.util.List; class Animal { public void eat() { System.out.println(Animal eats); } } class Dog extends Animal { Override public void eat() { System.out.println(Dog eats bone); } public void bark() { System.out.println(Dog barks); } } class Cat extends Animal { Override public void eat() { System.out.println(Cat eats fish); } } public class TestPolymorphism { public static void main(String[] args) { ListAnimal list new ArrayList(); list.add(new Dog()); list.add(new Cat()); list.add(new Animal()); for (Animal a : list) { a.eat(); // a.bark(); // 编译错误为什么 if (a instanceof Dog) { Dog d (Dog) a; d.bark(); } } } }源码解析与输出Dog eats bone Cat eats fish Animal eats Dog barks深度解析ListAnimal list声明了一个可以存放Animal及其子类对象的列表。这是多态和向上转型的典型应用提高了代码的通用性。在for循环中a.eat()实现了多态调用。尽管a的编译时类型是Animal但运行时根据实际对象类型调用对应的方法。a.bark()编译错误因为bark()是Dog特有的方法而a的编译时类型是AnimalAnimal类中没有bark()方法。编译器只认编译时类型。通过instanceof检查后进行向下转型(Dog) a就可以安全地调用bark()方法了。设计启示这种“父类引用指向子类对象”并结合instanceof检查的设计在需要统一处理一组具有共同父类、但行为各异的对象时非常有用例如事件处理、插件系统等。但过度使用instanceof可能意味着设计有瑕疵可以考虑用访问者模式等重构。5.3 真题三字节跳动-继承与访问权限的陷阱题目以下代码能否编译通过如果能输出什么如果不能指出错误并说明原因。package p1; public class A { protected void protectMethod() { System.out.println(A protected); } }package p2; import p1.A; public class B extends A { public void test() { A a new A(); // a.protectMethod(); // 行1: 编译错误 this.protectMethod(); // 行2: OK super.protectMethod(); // 行3: OK B b new B(); b.protectMethod(); // 行4: OK A aRef new B(); // aRef.protectMethod(); // 行5: 编译错误 } } class C { public void test() { B b new B(); // b.protectMethod(); // 行6: 编译错误 } }深度解析 这道题精准考察了protected访问权限的细微之处。protected的含义是允许同包内的其他类以及任何地方的子类访问。行1错误在子类B中通过父类引用a该引用指向一个独立的A对象访问protected方法是不允许的。protected允许子类访问从父类继承来的protected成员但不是允许子类随意访问其他父类实例的protected成员。行2、行3 OK通过this当前子类对象自身和super调用父类实现访问继承来的protected方法是允许的。行4 OK通过子类引用b访问其继承的protected方法是允许的。行5错误同行1即使aRef实际指向B对象但其编译时类型是A通过它访问protected方法同样受限于A类的访问规则。行6错误类C与B同包但不是B的父类或子类因此不能访问B从父类继承来的protected方法。面试要点protected的访问规则是“允许子类访问继承的成员而非访问任意父类对象的该成员”。这是很多资深面试官喜欢深挖的点因为它涉及到对继承和封装关系的深刻理解。6. 继承设计的最佳实践与避坑指南理解了原理和考题最终还是要落到怎么写好代码上。滥用继承是导致系统僵化、难以维护的常见原因。1. 优先使用组合而非继承 (Favor Composition Over Inheritance)这是GoF设计模式中的一条黄金准则。除非你明确需要“是一个(is-a)”的关系并且子类真的是父类的一种特殊化否则考虑使用组合将类作为另一个类的字段。继承的缺点破坏了封装性子类依赖父类实现细节导致脆弱的基类问题父类修改可能意外破坏子类限制了灵活性Java单继承。组合的优点更松散的耦合可以在运行时动态改变行为更易于测试。2. 为继承而设计否则就禁止它如果一个类不是专门为了被继承而设计的就将其声明为final。或者至少遵循以下原则构造器中绝不调用可被重写的方法前面已强调。谨慎使用clone()和readObject()它们可能绕过构造器调用可重写方法。在文档中明确说明可重写方法的自用模式即父类方法如何调用其他可重写方法。3. 正确使用Override注解在重写父类方法时总是加上Override注解。这可以让编译器帮你检查方法签名是否正确避免因拼写错误或参数列表不同而意外创建新方法而不是重写。4. 理解super关键字的两种用途super.method()调用父类被重写的方法的具体实现。super()或super(...)在子类构造器中调用父类构造器必须是第一行语句。5. 关于final关键字final类不能被继承。如String,Integer。final方法不能被重写。常用于明确禁止子类改变其行为或用于优化早期某些JVM版本会对final方法进行内联调用优化。final变量基本类型值不可变引用类型引用不可变但对象内部状态可能可变。7. 总结与个人体会Java的继承机制初看简单深究起来门道很多。从“子类能继承什么”这个基本问题出发我们一路探讨了访问权限、静态绑定与动态绑定、内存模型、初始化顺序直到protected访问的陷阱和继承的设计原则。我个人的体会是面试官问“Father fs new Son();”这类问题绝不仅仅是想听一句“编译看左运行看右”。他们是想考察你是否能串联起这些知识点基础概念字段与方法的访问区别static、final、private的影响。JVM原理对象内存布局、方法表、绑定的过程。设计意识继承的利弊何时该用继承何时该用组合。实践能力能否识别并避免“构造器中调用可重写方法”这类经典陷阱。所以下次再遇到这类问题你可以尝试从浅到深去回答先给出直接结果再解释语言规则最后能引申到底层原理和设计考量这样才是一个让面试官眼前一亮的答案。理解这些不仅是为了通过面试更是为了在实际开发中能写出更符合面向对象设计思想、更健壮、更易维护的代码。毕竟代码最终是写给人看的清晰的逻辑和合理的结构比任何奇技淫巧都重要。