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

文章目录

  • 前言
  • 一、向上转型
    • 1.概念:
    • 2.CODE
  • 二、重写
  • 三.重载
  • 四.动态和静态绑定
  • 总结


前言

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


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

一、向上转型

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.需要注意的是,重写和重载的区别在于方法的签名(包括方法名称和参数列表),而不仅仅是方法名称相同。
好了博客到此结束咯,希望大佬们的三连,欢迎大佬们的评论哇!!

你可能感兴趣的:(java,开发语言)