精通 Java 多态：核心概念、实战示例与最佳实践

Java 多态

通过清晰解释和实战代码示例探索 Java 多态，理解其如何增强代码灵活性与复用性。

多态 —— 面向对象编程的核心支柱 —— 意味着单一实体可呈现多种形态。

即同一实体（方法、运算符或对象）可根据上下文执行不同操作。

示例：Java 多态

class Polygon { // 渲染形状的方法 public void render() { System.out.println("Rendering Polygon..."); } } class Square extends Polygon { // 渲染正方形 public void render() { System.out.println("Rendering Square..."); } } class Circle extends Polygon { // 渲染圆形 public void render() { System.out.println("Rendering Circle..."); } } class Main { public static void main(String[] args) { // 创建 Square 对象 Square s1 = new Square(); s1.render(); // 创建 Circle 对象 Circle c1 = new Circle(); c1.render(); } }

输出

Rendering Square... Rendering Circle...

上例创建父类 Polygon 和两个子类 Square、Circle。render() 方法被两个子类继承，但各自重写以提供形状专属渲染逻辑。

核心要点：render() 根据实际对象类型表现不同行为，这就是多态的本质。

为何需要多态？

多态让开发者编写整洁、一致的代码。无需定义 renderSquare() 或 renderCircle() 等单独方法，单一 render() 方法即可适配各形状，减少冗余、提升可维护性。

虽然单独方法也能工作，但会迅速导致代码重复和 API 碎片化。多态在统一契约下统一行为，确保新形状只需重写 render() 即可集成。

注意：print() 方法也体现多态 —— 它可输出 char、int、String 等，无需多个重载。

Java 中通过以下技术实现多态：

1. 方法重写
2. 方法重载
3. 运算符重载

Java 方法重写

子类定义与父类同签名方法时，子类方法重写父类方法。这使同名方法可根据对象运行时类型执行不同操作。

示例 1：使用方法重写实现多态

class Language { public void displayInfo() { System.out.println("Common English Language"); } } class Java extends Language { @Override public void displayInfo() { System.out.println("Java Programming Language"); } } class Main { public static void main(String[] args) { // 创建 Java 类对象 Java j1 = new Java(); j1.displayInfo(); // 创建 Language 类对象 Language l1 = new Language(); l1.displayInfo(); } }

输出：

Java Programming Language Common English Language

此处 Language 为基类，Java 为子类。displayInfo() 在两个类中均定义，但各自实现提供上下文相关信息。

执行哪个方法在运行时确定，故此模式称为 运行时多态。

注意：调用的方法在程序执行期间确定。因此方法重写属于 运行时多态。

2. Java 方法重载

方法重载允许类拥有同名但参数列表不同的多个方法。编译器根据提供的参数决定调用哪个方法。

void func() { ... } void func(int a) { ... } float func(double a) { ... } float func(int a, float b) { ... }

此技术让同一逻辑操作接受不同输入。

示例 3：使用方法重载实现多态

class Pattern { // 无参方法 public void display() { for (int i = 0; i < 10; i++) { System.out.print("*"); } } // 单参数方法 public void display(char symbol) { for (int i = 0; i < 10; i++) { System.out.print(symbol); } } } class Main { public static void main(String[] args) { Pattern d1 = new Pattern(); // 调用无参方法 d1.display(); System.out.println("\n"); // 调用单参数方法 d1.display('#'); } }

输出：

********** ##########

此例中 Pattern 类包含两个重载的 display() 方法。无参版本打印十个星号，接受 char 的版本打印十个指定符号。

因编译器在编译期选择方法，这种多态常称为 编译时多态。

注意：调用的方法由编译器确定。因此也称编译时多态。

3. Java 运算符重载

Java 运算符可根据操作数类型表现不同行为。例如 + 用于数字时执行加法，用于字符串时执行拼接。

• + 可加数或拼接字符串。
• 逻辑和位运算符如 &、|、! 也随操作数类型行为不同。

以下片段展示 + 如何适配操作数。

1. 用于数字：

int a = 5; int b = 6; // + 用于数字 int sum = a + b; // 输出 = 11

2. 用于字符串：

String first = "Java "; String second = "Programming"; // + 用于字符串 String name = first + second; // 输出 = Java Programming

因此 + 在 Java 中被重载为同时执行加法和拼接。

注意：C++ 等语言允许用户自定义运算符重载，Java 仅限内置运算符重载。

多态变量

变量在程序执行期间可引用不同类型对象时，称之为多态变量。Java 中对象引用支持此行为，允许基类类型的引用指向子类实例。

示例：多态变量

class ProgrammingLanguage { public void display() { System.out.println("I am Programming Language."); } } class Java extends ProgrammingLanguage { @Override public void display() { System.out.println("I am Object-Oriented Programming Language."); } } class Main { public static void main(String[] args) { // 声明对象变量 ProgrammingLanguage pl; // 创建 ProgrammingLanguage 对象 pl = new ProgrammingLanguage(); pl.display(); // 创建 Java 类对象 pl = new Java(); pl.display(); } }

输出：

I am Programming Language. I am Object-Oriented Programming Language.

此例中，引用 pl 声明为基类型 ProgrammingLanguage，却被赋值为基类和子类对象。这演示了向上转型和运行时多态。