17370845950

多态允许同一接口调用不同实现，通过继承与方法重写实现。1. 子类重写父类方法，如Animal的makeSound被Dog和Cat重写；2. 父类引用指向子类对象，运行时动态绑定，如Animal myPet = new Dog()调用Woof；3. 方法参数使用父类类型，提升代码复用，如playWithPet(Animal)可接受任意子类；4. 抽象类或接口定义规范，如Flyable接口由Bird和Airplane实现，f1.fly()根据实际对象执行对应逻辑。核心是“编译看左边，运行看右边”，即引用类型决定方法签名，实际对象决定具体行为。多态增强扩展性，新增类无需修改原有代码，只需遵循相同接口。

Java中的多态是面向对象编程的重要特性之一，它允许同一个接口用于不同的实现方式。多态的核心思想是“一个对象，多种形态”，主要通过继承和方法重写来实现。

1. 继承与方法重写

多态的基础是类之间的继承关系。子类继承父类后，可以重写父类的方法，从而提供不同的实现逻辑。

定义一个父类 Animal，并在其中声明一个方法 makeSound()，然后让 Dog 和 Cat 类继承 Animal 并重写该方法。

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

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

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

2. 父类引用指向子类对象

这是实现多态的关键：使用父类的引用变量来指向子类的对象。运行时会根据实际对象类型调用相应的方法。

例如：

Animal myPet = new Dog();
myPet.makeSound(); // 输出: Woof!

myPet = new Cat();
myPet.makeSound(); // 输出: Meow!

虽然引用类型是 Animal，但实际执行的是 Dog 或 Cat 的 makeSound 方法，这就是动态绑定（运行时多态）。

3. 结合方法参数实现通用性

多态常用于方法参数中，提高代码的可扩展性和复用性。

例如：

void playWithPet(Animal animal) {
    animal.makeSound();
}

playWithPet(new Dog()); // 输出: Woof!
playWithPet(new Cat()); // 输出: Meow!

同一个方法可以处理不同类型的动物，无需为每种动物写单独的方法。

4. 抽象类和接口的应用

更进一步，可以使用 abstract class 或 interface 来定义规范，强制子类实现特定方法，增强多态的灵活性。

比如定义一个接口 Flyable：

interface Flyable {
    void fly();
}

class Bird implements Flyable {
    public void fly() {
        System.out.println("Bird is flying");
    }
}

class Airplane implements Flyable {
    public void fly() {
        System.out.println("Airplane is flying");
    }
}

// 使用多态
Flyable f1 = new Bird();
Flyable f2 = new Airplane();
f1.fly(); // 输出: Bird is flying
f2.fly(); // 输出: Airplane is flying

基本上就这些。多态让程序更容易扩展，新增类型时不需要修改原有调用逻辑，只要符合约定即可无缝接入。关键是理解“编译看左边，运行看右边”的原则：引用类型决定可用方法，实际对象决定执行哪个版本。不复杂但容易忽略细节。