📌 目录

  1. 什么是多态？
  2. 多态的实现方式
  3. 多态的类型
  4. 多态的优势
  5. 多态的应用场景
  6. 多态的注意事项
  7. 示例代码
  8. 参考资料
  9. 出站链接

1. 什么是多态？

多态（Polymorphism） 是面向对象编程的一个核心特性，允许不同的对象以相同的方式调用不同的方法。简单来说，多态让我们可以通过相同的接口调用不同类的行为。

Java 中的多态可以通过方法重载和方法重写实现。

多态的主要特点是：

  • 同一操作作用于不同的对象，产生不同的执行结果。
  • 方法具有不同的实现，依赖于对象的实际类型。

2. 多态的实现方式

2.1 方法重写（Override）

方法重写是实现多态的最常见方式。子类可以重写父类的某个方法，使其具有不同的行为。运行时，Java 会根据对象的实际类型来决定调用哪个方法。

2.2 方法重载（Overload）

方法重载是另一种形式的多态。通过在同一类中使用相同的方法名，但参数不同（类型、数量、顺序等）来实现多态。在编译时根据方法签名来决定调用哪个方法。

3. 多态的类型

3.1 编译时多态（静态多态）

编译时多态是指在编译阶段确定方法调用的版本，也就是通过方法重载来实现多态。编译器在编译时会根据方法签名来决定调用哪个方法。

示例：方法重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Printer {
    // 方法重载：打印整数
    void print(int a) {
        System.out.println("打印整数：" + a);
    }
 
    // 方法重载：打印字符串
    void print(String str) {
        System.out.println("打印字符串：" + str);
    }
}
 
public class StaticPolymorphism {
    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print(100);    // 调用 print(int a)
        printer.print("Hello"); // 调用 print(String str)
    }
}

输出：

1
2
打印整数：100
打印字符串：Hello

3.2 运行时多态（动态多态）

运行时多态是在运行阶段根据对象的实际类型来决定调用哪个方法，通常通过方法重写来实现。多态性依赖于父类引用指向子类对象的特性。

示例：方法重写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Animal {
    void sound() {
        System.out.println("动物发出声音");
    }
}
 
class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("狗叫：汪汪");
    }
}
 
class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("猫叫：喵喵");
    }
}
 
public class DynamicPolymorphism {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
 
        animal1.sound();  // 调用 Dog 类的 sound 方法
        animal2.sound();  // 调用 Cat 类的 sound 方法
    }
}

输出：

1
2
狗叫：汪汪
猫叫：喵喵

4. 多态的优势

  1. 提高代码的可扩展性：新增加子类时，父类方法无需修改。
  2. 代码重用性高：通过父类引用指向不同子类对象，可以复用相同的代码逻辑。
  3. 增强系统的灵活性：可以动态决定执行哪个方法，增强了系统的灵活性和可维护性。

5. 多态的应用场景

  1. GUI 组件：例如 Swing 或 AWT 中的各种控件，都使用多态来处理不同类型的事件。
  2. 图形绘制：如 Shape 类有多个子类（Circle、Rectangle 等），父类引用可以指向不同的子类，通过多态绘制不同的图形。
  3. 策略模式：通过使用多态，可以根据不同的策略行为在运行时选择合适的执行逻辑。

6. 多态的注意事项

  1. 多态性依赖于继承和方法重写，必须有继承关系，且父类方法被子类重写。
  2. 不能通过多态来调用子类中独有的方法，因为父类引用只能访问父类的成员。
  3. 静态方法和构造方法无法被重写，它们不具有多态性。

7. 示例代码

示例：多态应用（动物发声）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
abstract class Animal {
    abstract void makeSound();
}
 
class Dog extends Animal {
    void makeSound() {
        System.out.println("狗叫：汪汪！");
    }
}
 
class Cat extends Animal {
    void makeSound() {
        System.out.println("猫叫：喵喵！");
    }
}
 
public class AnimalSound {
    public static void main(String[] args) {
        Animal dog = new Dog();  // 多态：父类引用指向子类对象
        Animal cat = new Cat();
         
        dog.makeSound();  // 调用 Dog 的 makeSound 方法
        cat.makeSound();  // 调用 Cat 的 makeSound 方法
    }
}

输出：

1
2
狗叫：汪汪！
猫叫：喵喵！

8. 参考资料

9. 出站链接