如何在Java中实现多态性

在Java中，多态性（Polymorphism）是面向对象编程的三大特性之一，它允许一个接口或父类被不同的子类实现或继承，从而使得同一个方法调用在不同的上下文中表现出不同的行为。以下是在Java中实现多态性的几种常见方式：

1. 方法重写（Override）

方法重写是子类重新定义继承自父类的方法。当通过父类引用调用该方法时，实际执行的是子类中的版本。

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

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

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

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.makeSound(); // 输出: Dog barks

        myAnimal = new Cat();
        myAnimal.makeSound(); // 输出: Cat meows
    }
}

2. 方法重载（Overload）

方法重载是在同一个类中定义多个同名但参数列表不同的方法。编译器根据调用时传递的参数类型和数量来决定调用哪个方法。

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

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

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

public class OverloadingExample {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3)); // 输出: 8
        System.out.println(calc.add(5.5, 3.3)); // 输出: 8.8
        System.out.println(calc.add(5, 3, 2)); // 输出: 10
    }
}

3. 接口实现

通过实现接口，不同的类可以提供接口方法的不同实现。

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 InterfacePolymorphismExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        shape1.draw(); // 输出: Drawing a circle

        Shape shape2 = new Rectangle();
        shape2.draw(); // 输出: Drawing a rectangle
    }
}

4. 抽象类和抽象方法

抽象类可以包含抽象方法，子类必须实现这些抽象方法。

abstract class Shape {
    abstract void draw();
}

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

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

public class AbstractClassPolymorphismExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        shape1.draw(); // 输出: Drawing a circle

        Shape shape2 = new Rectangle();
        shape2.draw(); // 输出: Drawing a rectangle
    }
}

5. 使用泛型

泛型允许你在编译时指定类型参数，从而在运行时实现多态性。

class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

public class GenericPolymorphismExample {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.set(10);
        System.out.println(integerBox.get()); // 输出: 10

        Box<String> stringBox = new Box<>();
        stringBox.set("Hello");
        System.out.println(stringBox.get()); // 输出: Hello
    }
}

通过这些方式，Java中的多态性使得代码更加灵活和可扩展。