JAVA多态的实现方式（继承，接口，方法重载）

多态是面向对象编程中的一个重要概念，它可以通过以下几种方式来实现：

1. 继承（Inheritance）：通过继承关系，子类可以继承父类的属性和方法，并且可以对父类的方法进行重写（覆盖）。通过父类引用指向子类对象，可以实现多态。例如：

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

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

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

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        
        animal1.makeSound(); // 输出 "Dog barks"
        animal2.makeSound(); // 输出 "Cat meows"
    }
}

2. 接口（Interface）：通过接口定义一组方法的规范，具体的类实现接口并实现接口中的方法。通过接口的引用指向实现类的对象，可以实现多态。例如：
 

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        
        shape1.draw(); // 输出 "Drawing a circle"
        shape2.draw(); // 输出 "Drawing a rectangle"
    }
}

3. 方法重载（Method Overloading）：在一个类中定义多个同名方法，但参数类型和/或个数不同。通过方法的重载，可以根据传入的参数类型和个数来选择调用不同的方法。这也可以看作是一种多态的实现方式。例如：

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

public class PolymorphismExample {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        
        int result1 = calculator.add(1, 2); // 调用 int 参数的 add 方法
        double result2 = calculator.add(1.5, 2.5); // 调用 double 参数的 add 方法
        
        System.out.println(result1); // 输出 3
        System.out.println(result2); // 输出 4.0
    }
}

这些是实现多态的常见方式，它们允许我们通过父类引用指向子类对象，从而在运行时根据实际对象的类型来调用相应的方法。这种灵活性和扩展性是面向对象编程的重要特性之一。