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

你的名字 2023-10-10 19:32 43阅读 0赞

#### 文章目录 ####

*  前言
 *  一、向上转型
 *   *  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.需要注意的是，重写和重载的区别在于方法的签名（包括方法名称和参数列表），而不仅仅是方法名称相同。  
好了博客到此结束咯，希望大佬们的三连，欢迎大佬们的评论哇！！