多态性的定义

在Java中，多态性是面向对象编程的三大特性之一（另外两个是封装和继承），它允许不同类的对象对同一消息做出不同的响应。简单来说，多态性就是“一个接口，多种实现”。通过多态，我们可以编写更具通用性和可扩展性的代码，提高代码的复用性和可维护性。

多态性的实现条件

要在Java中实现多态性，需要满足以下三个条件：

  1. 继承关系：多态性通常基于继承来实现，子类继承父类，从而拥有父类的属性和方法。
  2. 方法重写：子类需要重写父类中的某些方法，以提供自己的实现逻辑。
  3. 父类引用指向子类对象：使用父类类型的引用变量来引用子类的对象，这样在调用重写的方法时，会根据实际引用的对象类型来决定调用哪个类的方法。

多态性的实现方式

1. 方法重载（编译时多态）

方法重载是指在同一个类中定义多个具有相同名称但参数列表不同的方法。编译器会根据调用方法时传递的参数类型和数量来决定调用哪个方法。这种多态性在编译阶段就已经确定，因此也称为编译时多态。

示例代码：

public class Calculator {
    // 加法方法，两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 加法方法，三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 加法方法，两个双精度浮点数相加
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.add(1, 2)); // 调用 add(int a, int b)
        System.out.println(calculator.add(1, 2, 3)); // 调用 add(int a, int b, int c)
        System.out.println(calculator.add(1.5, 2.5)); // 调用 add(double a, double b)
    }
}

2. 方法重写（运行时多态）

方法重写是指子类重新定义父类中已有的方法，方法名、参数列表和返回类型都要与父类中的方法相同。当使用父类引用指向子类对象时，调用重写的方法会根据实际引用的对象类型来决定调用哪个类的方法。这种多态性在运行阶段才能确定，因此也称为运行时多态。

示例代码：

// 父类
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类 Dog 继承自 Animal
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

// 子类 Cat 继承自 Animal
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // 调用 Dog 类的 makeSound 方法
        cat.makeSound(); // 调用 Cat 类的 makeSound 方法
    }
}

多态性的体现形式

  • 对象多态：通过父类引用指向子类对象，在运行时根据实际对象的类型调用相应的方法，如上述方法重写的示例。
  • 参数多态：在方法的参数列表中使用父类类型作为参数，调用该方法时可以传入任何子类对象，从而实现不同的行为。

示例代码：

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

public class ParameterPolymorphism {
    public static void animalSound(Animal animal) {
        animal.makeSound();
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        animalSound(dog); // 传入 Dog 对象
        animalSound(cat); // 传入 Cat 对象
    }
}

通过以上方式，Java的多态性使得代码更加灵活、可扩展和易于维护。