还没搞懂重写和重载吗？这篇文章可以帮助你

---

前言

首先，会大致介绍一下什么叫做向上转型，方便后续的理解

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、向上转型

1.概念：

向上转型是Java的一个多态性的表现形式。指的是一个子类的对象赋值给父类类型的引用变量。换句话说，它是将一个对象转换为它的父类类型。

2.CODE

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

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 直接通过子类对象调用父类方法
        dog.bark(); // 调用子类特有的方法

        Animal animal = dog; // 向上转型，将Dog对象赋值给Animal类型的引用变量
        Animal animal1 = new Dog();//也可以这样子
        animal.eat();
        animal.eat(); // 通过父类引用调用父类方法
        // animal.bark(); // 错误，父类引用无法调用子类特有的方法
    }
}

在上述示例中，Dog 类继承自 Animal 类。通过向上转型，我们将 Dog 对象赋值给 Animal 类型的引用变量 animal。虽然 animal 是 Animal 类型的引用，但实际上它引用的是 Dog 类的对象。因此，我们可以通过 animal 调用 Animal 类的方法，但无法调用 Dog 类特有的方法。

二、重写

1.发生在子类和父类之间。
2.子类通过定义一个与父类中具有相同名称、参数列表和返回类型的方法来重写父类的方法。
3.重写方法在运行时动态绑定，即根据实际对象的类型确定调用哪个方法。
4.重写方法可以访问和修改父类中的非私有成员。
5.重写方法可以修改方法的行为，实现自定义的逻辑。

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

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // 输出：Animal makes a sound.

        Cat cat = new Cat();
        cat.makeSound(); // 输出：Cat meows.

        Animal animalCat = new Cat();
        animalCat.makeSound(); // 输出：Cat meows.，动态绑定到 Cat 类的 makeSound() 方法
    }
}

看到虽然向上转型了，但是调用的依然是子类的方法。
动态和静态绑定在文末

三.重载

1.发生在同一个类中，或者在父类和子类之间。
2.同一个类中的方法可以有相同的名称，但参数列表必须不同（参数的类型、顺序或数量）。
3.重载方法在编译时静态绑定，即根据调用方法时传递的参数类型来确定调用哪个方法。
4.重载方法不能修改已有方法的行为，只是提供了更多的方法签名选项，用于处理不同的参数组合

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

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

    public String add(String a, String b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        int result1 = calculator.add(2, 3);
        System.out.println(result1); // 输出：5

        double result2 = calculator.add(2.5, 3.5);
        System.out.println(result2); // 输出：6.0

        String result3 = calculator.add("Hello", "World");
        System.out.println(result3); // 输出：HelloWorld
    }
}

所以只是提供了更多的方法签名选项，用于处理不同的参数组合。

四.动态和静态绑定

1.当说重载方法在编译时静态绑定，是指在编译时期就确定了要调用哪个重载方法，而不是在运行时动态决定。

当我们调用一个重载方法时，编译器会根据我们传递的参数类型来确定要调用哪个重载方法。这个决定是在编译时期完成的，因此称为静态绑定。
比如上述图片中calculator就是根据前面是int还是double类型确定调用哪个方法
2.动态绑定（Dynamic binding）是指在程序运行时根据对象的实际类型确定要调用的方法。在动态绑定中，方法的调用是根据对象的实际类型来决定的，而不是根据变量的声明类型或编译时期的类型来决定。

动态绑定通常与多态性（Polymorphism）相关联。当使用父类类型的引用变量引用子类对象时，如果调用的方法在子类中被重写，那么在运行时会根据对象的实际类型来决定调用的方法。就是仍然调用子类的方法

总结

1.重写是子类对父类方法的重新实现，重载是在同一个类中或父子类之间对方法名称的多次定义。

2.重写关注于继承关系，子类重写父类的方法。

3.重载关注于方法的参数列表，同一个类中的方法可以有不同的参数列表。

4.重写方法在运行时动态绑定，重载方法在编译时静态绑定。

5.需要注意的是，重写和重载的区别在于方法的签名（包括方法名称和参数列表），而不仅仅是方法名称相同。
好了博客到此结束咯，希望大佬们的三连，欢迎大佬们的评论哇！！