Java多态性

Java多态性是Java编程中的一个重要概念。它是指同一操作作用于不同的对象时，可以有不同的行为。具体来说，它有三种形式：

• 方法重载
• 方法重写（也称为方法覆盖）
• 对象多态（也称为动态绑定）

方法重载

方法重载是指在一个类中声明多个同名的方法，但它们的参数列表不同。Java编译器会根据传递的参数类型来选择相应的方法，从而实现方法重载。例如：

public class MethodOverload {
    public void print() {
        System.out.println("print without parameter");
    }

    public void print(int num) {
        System.out.println("print with parameter: " + num);
    }

    public void print(String str) {
        System.out.println("print with parameter: " + str);
    }
}

在上述代码中，我们在MethodOverload类中定义了三个名字相同的print方法，它们分别具有不同的参数列表，即不同的方法签名。我们在调用这些方法的时候，编译器会根据方法参数的类型来选择相应的方法：

MethodOverload overload = new MethodOverload();
overload.print(); // "print without parameter"
overload.print(1); // "print with parameter: 1"
overload.print("hello"); // "print with parameter: hello"

方法重写

方法重写是指子类写一个与父类方法具有相同名称和参数列表的方法，但是子类的方法可能会有不同的实现。Java编译器在运行时会根据实际对象类型调用相应的方法。例如：

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

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

在上面的代码中，我们定义了一个Animal类和Cat类，其中Cat类继承自Animal类。我们在Cat类中重写了eat方法，并给出了不同于Animal类中的实现。当我们调用eat方法时，用一个Cat对象来调用：

Cat cat = new Cat();
cat.eat(); // "Cat is eating"

这时，运行时会根据实际对象类型调用相应的方法，即调用Cat类中的eat方法。

对象多态

对象多态也称为动态绑定。它是指对象在运行时执行的方法，与对象的声明类型无关。具体来说，它有两个关键点：

• 对象的实际类型确定具体执行的方法
• 对象的声明类型决定了对象可以调用哪些方法

例如：

public class Vehicle {
    public void run() {
        System.out.println("Vehicle is running");
    }
}

public class Car extends Vehicle {
    @Override
    public void run() {
        System.out.println("Car is running");
    }

    public void start() {
        System.out.println("Car is starting");
    }
}

public class Motorcycle extends Vehicle {
    @Override
    public void run() {
        System.out.println("Motorcycle is running");
    }

    public void repair() {
        System.out.println("Motorcycle is being repaired");
    }
}

在上述代码中，我们分别定义了Vehicle类、Car类和Motorcycle类。其中Car类和Motorcycle类都继承自Vehicle类，并重写了run方法，并定义了一些特有的方法。我们可以用下面的代码来测试这个多态性：

Vehicle vehicle1 = new Vehicle();
vehicle1.run(); // "Vehicle is running"

Vehicle vehicle2 = new Car();
vehicle2.run(); // "Car is running"
((Car)vehicle2).start(); // "Car is starting"

Vehicle vehicle3 = new Motorcycle();
vehicle3.run(); // "Motorcycle is running"
((Motorcycle)vehicle3).repair(); // "Motorcycle is being repaired"

我们定义了三个不同类型的对象，并用其声明类型分别进行初始化。当我们依次调用它们的run方法时，对象的实际类型会决定 "xxx is running"这个语句的执行。同时，虽然对象的声明类型不同，但它们都是Vehicle类型，所以我们可以在所有对象中都调用run方法。而对于start方法和repair方法，编译器会提示无法解析方法，因为这些方法是特定类中的方法，而对象的声明类型不是该类或其子类。因此，我们需要将对象强制转型为相应的子类，才能调用这些方法。

Java多态性提供了一种灵活的设计方式，使我们可以根据不同的需求，编写出具有多种形态的代码。