Java中继承方法的可见性、属性与方法调用机制详解

千涛同学_1100

发布时间：2026-02-15 10:10:02

499人浏览过

来源于php中文网

原创

Java中继承方法的可见性、属性与方法调用机制详解

本文深入解析java继承中方法调用时实际使用的属性、方法及访问权限归属：明确动态绑定如何决定字段访问与方法分派，阐明静态类型与动态类型的协同作用，并澄清“继承方法沿用父类可见性规则”这一关键原则。

本文深入解析java继承中方法调用时实际使用的属性、方法及访问权限归属：明确动态绑定如何决定字段访问与方法分派，阐明静态类型与动态类型的协同作用，并澄清“继承方法沿用父类可见性规则”这一关键原则。

在Java面向对象编程中，继承不仅是代码复用的手段，更是一套严谨的运行时行为规范。一个常被误解的核心问题是：当子类对象调用从父类继承来的方法时，该方法内部访问的字段（field）和调用的其他方法，究竟属于哪个类？其访问权限又依据谁的可见性规则？ 答案并非直觉上的“看方法定义在哪”，而是由字段绑定静态性与方法调用动态性共同决定——二者需分开理解。

一、字段（Field）访问：静态绑定，取决于声明类型（而非运行时类型）

Java中，字段不参与多态。对this.m的访问在编译期即根据当前方法所在类的定义确定具体字段。观察示例中的类B：

public class B extends A {
    private int m; // ← 这是B自己的m（与A中的m同名但完全独立）

    public B(int m, int n) {
        super(n);     // ← 此处super(n)初始化的是A中的private int m
        this.m = m + 1; // ← 此处this.m赋值的是B自己的private int m
    }
}

当执行 b.methodOne(6)（b 是 A 类型引用，实际指向 B 实例）时，methodOne 是在 A 中定义的，因此其中的 m -= i; 访问的是 A 类中定义的 private int m（即通过 super.m 隐式访问），而非 B 中同名的 m。这是关键点：字段访问由方法定义处的类决定，与调用对象的实际类型无关。

✅ 正确理解：A b = new B(...) 中，b.methodOne() 内部的 m 始终指 A 的 m；B 中声明的 private int m 是一个完全隔离的新字段，仅能被 B 自己的方法（如构造器中的 this.m）访问。

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

二、方法（Method）调用：动态绑定，取决于运行时类型（多态核心）

与字段不同，非private、非static、非final的实例方法调用遵循动态绑定（Late Binding）。这意味着：

编译器根据静态类型（A） 检查方法是否可访问（签名存在、权限足够）；
JVM 在运行时根据动态类型（B） 决定最终执行哪个版本的方法。

在示例中：

java-api-doc-generator

分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。

下载

public void methodOne(int i) {
    m -= i;
    increase(i); // ← 此处increase()调用将动态分派！
}

虽然 methodOne 定义在 A 中，但 increase(i) 的实际执行版本取决于 b 的实际类型。由于 b 是 B 的实例，且 B 重写了 increase，因此调用的是 B.increase(i)（m += i;），而非 A.increase(i)（m += 2 * i;）。

✅ 总结规则：继承方法体内调用的可重写方法，总是执行子类重写后的版本（若存在），即“用子类的方法”。

三、可见性（Visibility）规则：继承方法沿用定义类的访问权限

访问控制修饰符（private/protected/public/package-private）的作用域在编译期静态确定。当一个方法在父类中被定义并被子类继承：

该方法体内的所有代码（包括对private字段或方法的访问）均以父类为上下文进行权限检查；
子类对象调用此继承方法时，不切换到子类的可见性视角，而是延续父类的访问能力。

示例中的 visibilityTest()：

public void visilibityTest() {
    n++; // ← n 是 A 的 private 字段，此处合法！
}

n 是 A 的 private int n。尽管 b 是 B 的实例，b.visibilityTest() 仍能成功执行 n++，因为：

visibilityTest() 定义在 A 中；
在 A 的方法体内访问 A 的 private 成员，完全符合封装规则；
继承并未改变该方法的“所属身份”，它始终是 A 的成员，享有 A 的全部访问权限。

⚠️ 注意：子类自身不能直接访问父类的 private 成员（如 B 中写 n++ 会编译错误），但可通过继承来的方法间接操作——这正是封装与继承协同的设计精妙之处。

四、静态类型 vs 动态类型：贯穿全程的双重约束

静态类型（Static Type）：变量声明时的类型（如 A b）。它决定了编译期可调用哪些方法/访问哪些字段（即API边界）。
动态类型（Dynamic Type）：new 创建的实际对象类型（如 new B(...)）。它决定了运行时方法调用的具体实现版本（即行为归属）。

二者共同作用： | 操作 | 依赖类型 | 说明 | |------|----------|------| | 调用 b.methodOne() | 静态类型 A 必须有 methodOne 声明 | 否则编译失败 | | 执行 methodOne 中的 increase(i) | 动态类型 B 的重写版本 | 多态体现 | | methodOne 中访问 m | 静态绑定至 A 的 m（因方法定义在 A） | 字段无多态 | | b.visibilityTest() 访问 A.private n | 静态类型 A 的方法上下文 | 权限检查基于定义处 |