当前位置：首页 > news >正文

Java——多态

news 来源：原创 2025/4/29 23:42:03

在Java中，多态（Polymorphism） 是面向对象编程（OOP）的四大特性之一（其他三个是封装、继承和抽象）。多态允许同一个方法在不同的对象中表现出不同的行为，从而提高了代码的灵活性和可扩展性。

1. 多态的定义

多态是指同一个方法调用可以根据对象的不同而表现出不同的行为。它分为两种类型：

编译时多态（静态多态）：通过方法重载实现。
运行时多态（动态多态）：通过方法重写和向上转型实现。

2. 多态的实现方式

2.1 方法重载（Overload）

定义：在同一个类中，允许存在多个同名方法，但参数列表必须不同（参数类型、数量或顺序不同）。
特点：
- 编译时确定调用哪个方法。
- 属于静态多态。

示例：

public class Calculator {
    // 方法重载
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));           // 调用int add(int, int)
        System.out.println(calc.add(2.5, 3.5));       // 调用double add(double, double)
        System.out.println(calc.add(2, 3, 4));        // 调用int add(int, int, int)
    }
}

2.2 方法重写（Override）

定义：子类可以重写父类的方法，提供不同的实现。
特点：
- 运行时确定调用哪个方法。
- 属于动态多态。

示例：

class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking: Woof! Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing: Meow! Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型
        myAnimal.makeSound();       // 输出: Dog is barking: Woof! Woof!

        myAnimal = new Cat();       // 向上转型
        myAnimal.makeSound();       // 输出: Cat is meowing: Meow! Meow!
    }
}

2.3 向上转型（Upcasting）

定义：将子类对象赋值给父类引用。
特点：
- 通过父类引用调用子类重写的方法时，实际执行的是子类的方法。
- 这是实现运行时多态的关键。

示例：

Animal myAnimal = new Dog(); // 向上转型
myAnimal.makeSound();        // 调用Dog类的makeSound方法

3. 多态的优点

代码复用：
- 通过继承和方法重写，可以减少重复代码。
灵活性：
- 同一个方法可以根据对象的不同表现出不同的行为。
可扩展性：
- 新增子类时，无需修改现有代码，只需重写父类方法即可。
解耦合：
- 程序的设计更加模块化，降低了模块之间的耦合度。

4. 多态的实现条件

继承关系：
- 多态必须基于类的继承关系。
方法重写：
- 子类必须重写父类的方法。
向上转型：
- 父类引用指向子类对象。

5. 多态的应用场景

方法参数多态：
- 将父类类型作为方法参数，可以接受任意子类对象。

示例：

public class Zoo {
    public void animalSound(Animal animal) {
        animal.makeSound(); // 根据传入的对象调用不同的方法
    }
}

public class Main {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.animalSound(new Dog()); // 输出: Dog is barking: Woof! Woof!
        zoo.animalSound(new Cat()); // 输出: Cat is meowing: Meow! Meow!
    }
}

集合中的多态：
- 使用父类类型存储子类对象，实现统一管理。

示例：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Dog());
        animals.add(new Cat());

        for (Animal animal : animals) {
            animal.makeSound(); // 根据具体对象调用不同的方法
        }
    }
}

6. 注意事项

不能调用子类特有的方法：
- 通过父类引用调用方法时，只能调用父类中定义的方法。如果需要调用子类特有的方法，必须进行向下转型。

示例：

Animal myAnimal = new Dog();
// myAnimal.bark(); // 编译错误，Animal类中没有bark方法

if (myAnimal instanceof Dog) {
    Dog myDog = (Dog) myAnimal; // 向下转型
    myDog.bark(); // 调用Dog类特有的方法
}