作者简介： zoro-1，目前大一，正在学习Java，数据结构等

作者主页：zoro-1的主页

欢迎大家点赞 👍 收藏 ⭐ 加关注哦！💖💖

多态的实现条件

1. 1.继承关系向上转型或向下转型
2. 2.子类重写父类的方法
3. 3.通过父类对象的引用调用这个重写的方法
   （完成上面三部分，就会发生动态绑定，动态绑定是多态基础）

重写

重写的定义

Java中，重写（override）是指在子类中对父类中已有的方法重新实现，以达到覆盖父类中的方法的效果，即在子类中重新定义一个方法与父类中的方法具有相同的方法名、返回值类型和参数列表。重写方法的访问权限不能低于父类中同名方法的访问权限。通过重写，子类可以改变继承来的方法的行为，从而实现自己的特殊需求。

重写的例子

以下是一个Java重写public父类方法的例子：

public class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The cat meows");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Cat cat = new Cat();
        animal.makeSound(); // Output: The animal makes a sound
        cat.makeSound(); // Output: The cat meows
    }
}

在上面的例子中，我们定义了一个父类 Animal 和一个子类 Cat，并在子类中重写了父类中的 makeSound() 方法。在 Main 类中，我们创建了一个 Animal 对象和一个 Cat 对象，并分别调用了它们的 makeSound() 方法。

由于 Cat 类重写了 makeSound() 方法，所以当我们调用 cat.makeSound() 方法时，输出的是 “The cat meows”。而当我们调用 animal.makeSound() 方法时，输出的是 “The animal makes a sound”，因为 Animal 类中的 makeSound() 方法没有被重写。

方法重写的条件

在Java中，方法被重写的条件包括：

1. 1.方法名必须相同。
2. 2.参数列表必须相同。
3. 3.返回类型可以是相同的或者是子类。
4. 4.方法的修饰符必须允许它被重写，即public、protected和不写修饰符的方法可以被重写。私有方法不能被重写。
5. 5.重写方法不能抛出比被重写方法更多的异常，或者抛出与被重写方法不兼容的异常。
6. 6.重写方法的访问修饰符不能比被重写方法的访问修饰符更严格。例如，如果被重写方法是public，则重写方法不能是protected。
7. 7.静态方法（static修饰，因为他不依赖类）不能被重写。

需要注意的是，重写方法的返回类型可以是被重写方法返回类型的子类，但是参数列表必须和被重写方法的参数列表完全相同。这是因为Java使用参数列表来匹配方法调用，在重写方法时参数列表不一致会导致编译错误。

多态思想

动态绑定与静态绑定

动态绑定（Dynamic Binding）是指在程序运行时确定对象的类型及所要调用的方法，在编译时无法确定。在面向对象编程中，动态绑定是实现多态性的一种机制。

在静态绑定中，程序在编译时就确定了要调用的方法，而在动态绑定中，程序在运行时根据对象的实际类型来确定要调用的方法。这使得程序具有更高的灵活性和扩展性，因为程序可以在运行时动态地适应不同的对象和场景。

在Java中，动态绑定是通过关键字“extends”和“implements”实现的。当一个类继承或实现了一个接口时，可以使用父类或接口类型的变量来引用子类或实现类的对象，从而实现动态绑定。例如：

interface Vehicle{
    void drive();
}
class Car implements Vehicle{
    public void drive(){
        System.out.println("Driving a car");
    }
}
class Bike implements Vehicle{
    public void drive(){
        System.out.println("Riding a bike");
    }
}
public class Main{
    public static void main(String[] args){
        Vehicle v1 = new Car();
        Vehicle v2 = new Bike();
        v1.drive(); //输出 "Driving a car"
        v2.drive(); //输出 "Riding a bike"
    }
}

在上面的例子中，接口Vehicle定义了一个drive()方法，而Car和Bike分别实现了该接口并实现了自己的drive()方法。在main方法中，v1和v2变量的类型都是Vehicle，但它们分别引用了一个Car对象和一个Bike对象。在调用drive()方法时，程序会根据实际对象类型来确定要调用哪个drive()方法，从而实现动态绑定。

（编译时调用Vehicle的 drive()，运行时调用子类drive()，编译看左边运行看右边）

今天的分享到这里就结束了，感谢大家支持，创作不易，希望大家能给博主个三连