当子类对象被向上转型为父类引用时，方法调用遵循动态绑定（运行时多态），而字段访问则基于引用类型（编译时静态绑定）——因此 A a = new B(); a.x 访问的是 A 类中定义的 x，而非 B 中同名字段。

当子类对象被向上转型为父类引用时，方法调用遵循动态绑定（运行时多态），而字段访问则基于引用类型（编译时静态绑定）——因此 `a a = new b(); a.x` 访问的是 `a` 类中定义的 `x`，而非 `b` 中同名字段。

在 Java 中，向上转型（upcasting） 是安全且隐式的操作，例如 A a = new B();。此时变量 a 的编译时类型是 A，而运行时实际对象是 B 的实例。这种双重身份直接影响成员访问行为，但方法与字段的处理机制截然不同：

✅ 方法调用：动态绑定（多态）

• a.show() 调用的是 B 类中重写的 show()，因为 Java 对 public/protected 实例方法采用运行时动态分派（virtual method invocation）。
• JVM 查看实际对象类型（B），找到其 show() 实现并执行 → 输出 "B show"。

❌ 字段访问：静态绑定（无多态）

• a.getX() 返回 10，而非 20，根本原因在于：字段不支持多态，也不会被“重写”（override）。
• 更准确地说，B 类中声明 int x = 20; 并非覆盖（override）父类字段，而是隐藏（field hiding） —— 它在 B 实例中创建了一个全新的、独立的字段 x，与继承自 A 的 x 共存。
• 因此，一个 B 对象内存中实际包含 两个 x 字段：
  • A.x（值为 10，通过 super.x 或父类视角访问）
  • B.x（值为 20，仅通过 B 类型引用或 this.x 在 B 内部访问）

可通过以下代码验证字段共存现象：

class B extends A {
    int x = 20;

    void printX() {
        System.out.println("this.x (B's field): " + this.x);     // → 20
        System.out.println("super.x (A's field): " + super.x); // → 10
    }
}

而当使用父类引用 A a = new B(); 时：

• a.x 编译失败（因 A 引用无法直接访问 B 新增字段）；
• a.getX() 调用的是 A 中定义的 getX()，该方法返回 this.x —— 此处 this 是 B 实例，但 getX() 是 A 类的方法体，其中 this.x 指向的是 A 类继承下来的 x 字段（即 10），而非 B 自己声明的 x。

⚠️ 注意：字段隐藏极易引发歧义和 bug，《Effective Java》明确建议避免在子类中声明与父类同名的字段。若需扩展状态，请使用不同名称（如 bX）或通过受保护的 getter/setter 封装。

javascript-typescript-typescript-scaffold

你是 TypeScript 项目架构专家，专注于脚手架搭建生产就绪的 Node.js 和前端应用。生成包含现代工具链（pnpm、Vite、Next.js）、类型

下载

立即学习“Java免费学习笔记（深入）”；

✅ 正确实践：用继承代替字段隐藏

若希望子类提供不同的初始值，应直接初始化继承的字段：

class B extends A {
    public B() {
        this.x = 20; // 修改继承自 A 的 x 字段
    }
}

此时 A a = new B(); System.out.println(a.getX()); 将输出 20 —— 因为只有一个 x 字段，且已被构造器修改。

总之：Java 的多态只适用于方法，不适用于字段。字段访问由引用声明类型决定，方法调用由实际对象类型决定。 理解这一区别，是写出可维护面向对象代码的关键基础。