深入理解Java三大核心特性：封装、继承与多态

拾光

发布时间：2026-10-13 | 4人浏览过

原创

Java作为主流面向对象语言，其核心优势建立在封装、继承和多态三大特性之上。理解这些概念不仅是编写可维护代码的基础，更是应对复杂系统设计的关键。本文将逐一拆解这三者的实现逻辑、关键语法及常见的运行时行为。

封装：隐藏细节与控制访问

封装的核心目的是将数据（属性）和操作数据的行为（方法）结合成整体，并对外部隐藏内部实现的复杂性。在Java中，这通常通过以下标准操作实现：

属性私有化：使用 private 修饰符声明成员变量，防止外部直接修改，确保安全性。
提供访问接口：为每个私有属性生成公共的 Getter（获取值）和 Setter（设置值）方法。在 Setter 中可以加入逻辑校验，如判断数据的合法性。
构造器管理：如果定义了带参构造器，建议同时保留一个无参构造器，以便框架或反射调用时使用。

这种设计让使用者只需关注类的公共 API（Application Programming Interface），而无需关心内部如何存储或计算数据。

继承：代码复用与类层次结构

继承允许子类复用父类的属性和方法，减少重复代码。Java 中的继承遵循严格的规则：

单继承原则：使用 extends 关键字。Java 不支持多重继承（即一个类只能有一个直接父类），这避免了复杂的菱形继承问题。
不可继承性：父类的私有成员（private）和构造方法不能被子类继承，但可以通过公共方法间接访问父类的私有状态。
方法覆盖（Override）：当子类需要改变父类方法的行为时，可以定义签名完全相同的方法。此时必须注意：
- 访问权限不能更低（例如父类是 public，子类不能改为 protected）。
- 抛出的异常不能比父类更宽泛。

所有 Java 类最终都隐式继承自 java.lang.Object，因此 Object 中定义的 toString()、equals() 等方法常被重写以提供更友好的调试输出。

多态：同一行为，多种形态

多态是指允许不同类的对象对同一消息做出响应。在 Java 中，它分为两个阶段：

编译时多态（Overload）

即方法重载。在同一类中，存在多个同名方法，但参数列表（类型、个数、顺序）不同。编译器在编译阶段根据传入的参数类型确定具体调用哪个方法。

运行时多态（Override & Polymorphism）

这是动态绑定的体现。当父类引用指向子类对象时，程序在运行时才确定调用子类还是父类的方法。其核心判定逻辑如下：

看左边（引用类型）：决定该引用能调用哪些方法。如果子类重写了方法但引入了新方法，父类引用无法调用子类独有的新方法。
看右边（对象类型）：决定执行哪个版本的方法体。只要调用的方法在父类中存在，运行时系统会优先查找最贴近当前对象的子类实现（即“虚方法调用”）。

以下代码展示了这一过程，重点关注编译期选择方法与运行期执行方法的差异：

public class A {
    // 定义接收D类型参数的方法
    public String show(D obj) {
        return ("A and D");
    }
    // 定义接收A类型参数的方法
    public String show(A obj) {
        return ("A and A");
    } 
}

public class B extends A {
    // 子类特有的方法，重载了show但不影响父类引用
    public String show(B obj){
        return ("B and B");
    }
    // 重写父类的show(A)，这是多态的关键
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B { }
public class D extends B { }

public class Test {
    public static void main(String[] args) {
        A a1 = new A();           // 引用A，对象A
        A a2 = new B();           // 引用A，对象B（多态实例）
        B b = new B();            // 引用B，对象B
        
        System.out.println("1--" + a1.show(b));   // 1: A and A
        System.out.println("2--" + a1.show(c));   // 2: A and A
        System.out.println("3--" + a1.show(d));   // 3: A and D
        
        System.out.println("4--" + a2.show(b));   // 4: B and A
        System.out.println("5--" + a2.show(c));   // 5: B and A
        System.out.println("6--" + a2.show(d));   // 6: A and D
        
        System.out.println("7--" + b.show(b));    // 7: B and B
        System.out.println("8--" + b.show(c));    // 8: B and B
        System.out.println("9--" + b.show(d));    // 9: A and D
    }
}

结果解析：

输出 1, 2, 4, 5：虽然 a2 指向的是 B 对象，但在调用 show(B) 时，因为父类 A 中不存在 show(B) 方法，所以编译器向上寻找，发现 A 中有 show(A)。由于 B 是 A 的子类，符合重载匹配。而在运行期，B 重写了 show(A)，因此执行 B 中的逻辑，返回 "B and A"。
输出 3, 6, 9：D 不是 A 或 B 的直接祖先，因此在 A 中找到精确匹配的 show(D)。因为 B 没有重写此方法，所以沿继承链向上查找，最终执行 A 中的逻辑（若 B 有 show(D) 则会执行 B 的版本）。
输出 7, 8：b 的引用类型是 B，可以直接调用 show(B)。此处是精确匹配，不涉及向上查找逻辑。