面向对象多态详细讲解

面向对象多态是指同一种操作或方法在不同的对象上有不同的实现方式。多态的实现方式有多种，包括重载、重写和接口实现。

重载多态：重载是指在一个类中定义了多个同名的方法，但参数类型或个数不同。当调用这个方法时，根据传入的参数类型和个数的不同，会自动选择对应的方法进行调用。这种多态可以在编译时确定。

例如，一个计算器类中定义了两个add方法，一个是用于两个整数相加，一个是用于两个浮点数相加：

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

在调用add方法时，根据传入的参数类型的不同，会选择对应的方法进行调用：

Calculator calculator = new Calculator();
int result1 = calculator.add(1, 2);
double result2 = calculator.add(1.5, 2.5);

重写多态：重写是指子类重新定义了父类中已经存在的方法。当通过父类的引用调用这个方法时，会根据实际引用对象的类型，选择调用子类的方法。这种多态在运行时确定。

例如，定义一个动物类Animal，其中有一个eat方法：

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

在调用eat方法时，可以根据实际引用对象的类型选择调用对应的方法：

Animal animal = new Animal();
Dog dog = new Dog();

animal.eat();  // 输出：Animal is eating
dog.eat();  // 输出：Dog is eating

Animal animal2 = new Dog();
animal2.eat();  // 输出：Dog is eating

接口实现多态：接口实现多态是指一个类实现了多个接口，然后根据实际对象的类型，选择调用对应接口的方法。这种多态在运行时确定。

例如，定义两个接口Flyable和Swimable，分别有fly和swim方法：

public interface Flyable {
    void fly();
}

public interface Swimable {
    void swim();
}

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

public class Fish implements Swimable {
    @Override
    public void swim() {
        System.out.println("Fish is swimming");
    }
}

public class Duck implements Flyable, Swimable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }
    
    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }
}

在调用fly和swim方法时，可以根据实际对象的类型选择调用对应接口的方法：

Flyable flyable = new Bird();
Swimable swimable = new Fish();
Flyable swimAndFly = new Duck();

flyable.fly();  // 输出：Bird is flying
swimable.swim();  // 输出：Fish is swimming
swimAndFly.fly();  // 输出：Duck is flying
swimAndFly.swim();  // 输出：Duck is swimming

总的来说，面向对象多态可以提高代码的可扩展性和可维护性，使代码更加灵活和可复用。通过不同的实现方式，可以根据实际对象的类型，选择合适的方法进行调用