【JAVA SE】多态

Celia～

已于 2024-05-30 15:51:34 修改

阅读量1k

点赞数 28

分类专栏： JAVA 文章标签： java 开发语言

于 2024-05-30 15:50:20 首次发布

本文链接：https://blog.csdn.net/2302_81149370/article/details/139323783

版权

JAVA 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

✨✨欢迎大家来到Celia的博客✨✨

🎉🎉创作不易，请点赞关注，多多支持哦🎉🎉

所属专栏：JAVA

个人主页：Celia's blog~

引言

上一个篇章中，我们已经初步了解了继承的概念以及使用，在本篇文章中，将会介绍在Java中依赖于继承的一种新的现象：多态。

一、多态

1.1 多态的概念

多态，是指不同的对象，面对同一个事物时，会展现出不同的反应。

1.2 多态的实现条件

必须在继承体系下
子类必须重写父类的方法
通过父类的引用来调用重写的方法

1.3 关于向上转型、向下转型

在继承体系中，如果创建了一个子类对象，是可以用父类类型来接收的。假设有如下代码：

class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("正在吃饭...");
    }
}

class Dog extends Animal{
    public String flag;
    public Dog(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println("正在吃狗粮...");
    }
}

我们创建一个dog对象，是可以用Animal类型来接收的：

Animal animal = new Dog("小黑", 10);

那么为什么要这样做呢？

父类的类型可以接收所有继承于这个父类的子类的对象，这有助于统一标准。此时这种情况就叫做向上转型。

向上转型的三种方式：

在创建新对象时用父类类型接收
利用传参，传入子类，用父类接收
利用方法返回值，返回子类，用父类接收

注意事项：

在继承过程中，如果实现了向上转型，该对象只能使用父类的成员变量或成员方法，这是由类型所局限的。

如果想要访问子类的成员变量和成员方法，则需要向下转型：

((Dog) animal).flag//向下转型访问子类成员

1.4 关于重写

重写，也称为覆盖。是子类对父类的非静态、非private、非final、非构造方法进行的重新编写。返回值和形参列表（种类、顺序）必须一样。只有内容可以改变。我们来看下面的代码：

class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("正在吃饭...");
    }
}

class Dog extends Animal{
    public String flag;
    public Dog(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println("正在吃狗粮...");
    }
}


public class Text {
    public static void main(String[] args) {
        Animal animal = new Dog("小黑", 10);/向上转型
        animal.eat();//会输出什么呢？？？
    }
}
我们仔细观察，发现子类Dog和父类Animal都有一个相同的方法：eat，它们的返回值相同，参数列表相同，此时，子类中的eat方法就对父类中的eat方法进行了重写。当我们调用父类的eat方法时，实际上调用的是子类的eat方法。

实际上，调用的确实是父类的eat方法，但是在程序运行的过程中，实际上调用的是子类的eat方法，这种在继承体系下，运行时才确定具体调用哪个方法的现象叫做动态绑定。

1.5 实现多态

class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("正在吃饭...");
    }
}

class Dog extends Animal{
    public String flag;
    public Dog(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println("正在吃狗粮...");
    }
}

class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("正在吃猫粮...");
    }
}

public class Text {
    public static void main(String[] args) {
        Animal animal = new Dog("小黑", 10);
        Animal animal1 = new Cat("小白",5);
        animal.eat();
        animal1.eat();
    }
}

在以上代码中，定义了两个子类Cat和Dog，进行向上转型，并且调用父类的eat方法：