带你深入理解Java中的多态

 🎈个人主页：.满船清梦压星河_-CSDN博客

🌂c/java领域新星创作者

🎉欢迎👍点赞✍评论❤️收藏

😛😛😛希望我的文章能对你有所帮助，有不足的地方还请各位看官多多指教，大家一起学习交流！

一、多态的概念 

        通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

 二、实现多态的条件

在Java中实现多态，需要满足几个条件：

• 必须是在继承关系上，因为在继承关系上才能发生向上转型。
• 子类和父类必须有同名的方法。(重写/覆盖的方法)
• 通过父类对象的引用，去调用这个重写的方法。
• 完成以上三部分，就会发生动态绑定，而动态绑定是多态的基础。

那什么是向上转型呢？

 向上转型就是：当我们把子类对象给到父类之后，这个过程就是向上转型。

 向下转型就是：当我们把父类对象给到子类之后，这个过程就是向下转型。

现在假设有Animal类，Dog类继承于Animal。代码如下：

class Animal{
    public String name;
    int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    public void bark(){
        System.out.println(this.name+"正在汪汪叫！");
    }

  
}

现在我们在main方法里面把子类对象给到父类，即把dog类对象让Animal类的对象去引用。

public class Test {
    public static void main(String[] args) {
        //Dog dog=new Dog("大黄",5);
        //Animal animal=dog;和下行代码等价
        Animal animal=new Dog("圆圆",19);
    }
}

这样，animal这个引用就指向了dog这个引用所指向的对象，便发生了向上转型。

当然，向上转型也不只是这一种方法。下面来看：

public class Test {
    public static void func1(Animal animal){
        //...
    }
    public static void main(String[] args) {
        Dog dog =new Dog("圆圆",19);
        func1(dog);
    }
}
//相当于还是让父类引用指向了子类引用所指的对象，只不过是通过方法传参实现

  public static Animal func2(){
        Dog dog=new Dog("圆圆",19);
        return dog;
    }//返回值用Animal类来接收

综上所述，常见的可以发生的向上转型的3个时机：

• 直接赋值
• 方法传参，传参的时候，进行向上转型
• 返回值向上转型

 理解了向上转型之后，我们在Dog类中进行一个小小的修改：

在Dog类里面添加一个eat方法：

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    public void bark(){
        System.out.println(this.name+"正在汪汪叫！");
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃狗粮！");
    }
}

而父类Animal类中也有eat方法，通过下面的对比：

接着，在main方法中，让animal这个对象去调用eat方法。运行结果如下： 

 public static void main(String[] args) {
        Animal animal =new Dog("圆圆",19);
        animal.eat();

    }

通过运行结果发现：animal这个父类引用调用了Dog类里面的eat方法，我们一般会认为animal只能调用自己类里面的eat方法，那这是为什么？ 

原因是：这两个类发生了重写，而在main方法里面，通过父类的引用进行调用这个重写的方法的时候，就会调用子类的eat方法。

我们把这个过程就叫做动态绑定。 

• 注意：被重写的方法的访问限定修饰符，在子类中要大于等于父类的。 
• 被private修饰的方法是不能被重写的。
• 被static修饰的方法是不能被重写的。
• 被final修饰的方法也是不能被重写的。

那怎么理解动态绑定呢？

动态绑定，就是在程序运行的时候绑定到了子类的重写方法上。 

在cmd上运行这段代码：

 下面，我们继续在原来的代码基础上，再加一个Cat类，并且把eat重写，同样继承于Animal类：

class Cat extends Animal{
    public Cat(String name,int age){
        super(name, age);
    }
    public void miaomiao(){
        System.out.println(this.name+"正在咪咪叫！");
    }

    @Override
    public void eat() {
        System.out.println(this.name+"正在吃猫粮！");
    }
}

在main方法中，加入一个func方法：

public static void func(Animal animal){
        animal.eat();
    }

 站在func这个方法的角度看，当给它传的参数不同的时候，它调用的eat方法所能够表现出来的行为也是不一样的。

    public static void main(String[] args) {
        Dog dog =new Dog("圆圆",19);
        func(dog);
        Cat cat=new Cat("猫咪",12);
        func(cat);
    }

运行结果如下:

 

总结：

当父类引用，引用的子类对象不一样的时候，调用这个重写的方法，所表现出来的行为是不一样的！！！我们把这种思想就叫做多态！ 

---

行文至此，相信大家已经对多态理解的很透彻了。今天我也就给大家分享到这里！

✨创作不易，还希望各位大佬支持一下！

👍点赞，你的认可是我创作的动力！

⭐收藏，你的青睐是我努力的方向！

✏️评论：你的意见是我进步的财富！