多态重写重载

多态（Polymorphism）

Java中的多态是面向对象编程的一个重要特性，它允许使用一个接口来表示不同的类型或行为。多态性（Polymorphism）这个词来源于希腊语，意为“多种形态”。在Java中，多态主要通过方法重写（Overriding）和方法重载（Overloading）来实现。

方法重写 (Overriding)

当子类重新定义了父类的方法，这就是方法重写。在运行时，Java虚拟机会根据对象的实际类型来调用相应的方法，而不是根据引用变量的类型。这使得同一个方法调用可以表现出不同的行为，即实现了运行时多态。

方法重载 (Overloading)

方法重载是指在一个类中可以有多个同名的方法，但是这些方法的参数列表必须不同（参数的数量、类型或者顺序不同）。方法重载是在编译时期决定的，属于静态多态的一种形式。

示例代码

父类引用指向子类对象：

Animal myDog = new Dog();：这里 myDog 是一个 Animal 类型的引用，但它实际上指向的是一个 Dog 对象。

Animal myCat = new Cat();：这里 myCat 是一个 Animal 类型的引用，但它实际上指向的是一个 Cat 对象。

调用子类重写的方法：

myDog.sound();：尽管 myDog 是 Animal 类型的引用，但由于它实际上指向的是 Dog 对象，所以调用的是 Dog 类中重写的 sound 方法，输出 Dog barks。

myCat.sound();：同样，尽管 myCat 是 Animal 类型的引用，但由于它实际上指向的是 Cat 对象，所以调用的是 Cat 类中重写的 sound 方法，输出 Cat meows。

访问子类特有的方法：

如果需要访问 Dog 类特有的 wagTail 方法，需要先进行类型转换：((Dog) myDog).wagTail();。

同样，如果需要访问 Cat 类特有的 purr 方法，需要先进行类型转换：((Cat) myCat).purr();。

// 定义一个父类 Animal
class Animal {
    void sound() {
        System.out.println("This animal makes a sound");
    }
}

// 定义一个子类 Dog，继承自 Animal
class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }

    void wagTail() {
        System.out.println("Dog wags its tail");
    }
}

// 定义一个子类 Cat，继承自 Animal
class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Cat meows");
    }

    void purr() {
        System.out.println("Cat purrs");
    }
}

// 主类 Test
public class Test {
    public static void main(String[] args) {
        // 使用父类类型的引用
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 调用 sound 方法
        myDog.sound();  // 输出: Dog barks
        myCat.sound();  // 输出: Cat meows

        // 如果需要访问子类特有的方法，需要进行类型转换
        if (myDog instanceof Dog) {
            ((Dog) myDog).wagTail();  // 输出: Dog wags its tail
        }

        if (myCat instanceof Cat) {
            ((Cat) myCat).purr();     // 输出: Cat purrs
        }
    }
}

总结

方法重写是对继承的父类方法的重写。

方法重载是对不同参数对应不同的，具有相同名字的方法的调用。

多态能方便更改调用不同的子类重写出的方法。（调用子类特有的方法不能多态化）