Java之多态

﹏ヽ暗。殇╰゛Y 2024-04-20 04:36 0阅读 0赞

#### 多态 ####

*  多态的实现条件
 *  重写
 *   *  重写的定义
     *  重写的例子
     *  方法重写的条件
 *  多态思想
 *  动态绑定与静态绑定

![在这里插入图片描述][7b4cea31e0dc4ea9a128e671943d2532.png_pic_center]

> 作者简介： zoro-1，目前大一，正在学习Java，数据结构等  
> 作者主页：[zoro-1的主页][zoro-1]  
> 欢迎大家点赞 👍 收藏 ⭐ 加关注哦！💖💖

## 多态的实现条件 ##

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

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

## 多态思想 ##

![在这里插入图片描述][dabac2febd0143ff88de5cf80e1b00d0.png]

## 动态绑定与静态绑定 ##

**动态绑定**（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()，编译看左边运行看右边）

> 今天的分享到这里就结束了，感谢大家支持，创作不易，希望大家能给博主个三连![在这里插入图片描述][89a0059ba7174a06bb12c1b087db4b0f.png_pic_center]

[7b4cea31e0dc4ea9a128e671943d2532.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/adeb5a10512b4616a4a4f1f3ed9a9ca4.png
[zoro-1]: https://blog.csdn.net/ltzoro?type=blog
[dabac2febd0143ff88de5cf80e1b00d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/847ef8b353f84be3956183a6456db154.png
[89a0059ba7174a06bb12c1b087db4b0f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9a22d76d418d4a0081387836ee6a5229.png