【Java基础篇 | 面向对象】--- 聊聊什么是多态（上篇）

平行线也会相交2023-09-14 1:02

个人主页：兜里有颗棉花糖

欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 兜里有颗棉花糖 原创

收录于专栏【JavaSE_primary】

本专栏旨在分享学习JavaSE的一点学习心得，欢迎大家在评论区讨论💌

目录

一、什么是多态

多态的概念：简单来说，多态就是指同一个方法名在不同的对象上有不同的行为。

多态实现的核心概念是方法的重写和动态绑定。当子类继承父类并重写了父类的方法时，可以通过父类引用指向子类对象，并调用该方法，此时会根据对象的实际类型来决定调用哪个类的方法，从而实现多态性。

二、多态的实现条件

在java中，要实现多态的话有3个条件且这三个条件缺一不可：

1.必须是在继承体系下

2.子类必须要对父类中的方法进行重写

3.通过父类的引用调用重写的方法

那多态具体是如何体现的呢：

当传递不同类对象时，会调用对应类中的方法。

三、重写

重写概念：允许子类重新定义父类中已经存在的方法，并提供自己特定的实现。

方法重写的规则如下：

  • 子类在重写父类方法时，返回值类型、方法名、参数列表要完全相同。
  • 被重写的方法返回值类型可以不同，但是必须是具有父子类关系的。
  • 重写是子类对父类非private修饰、非final修饰、非构造方法等的实现过程进行重新编写。（所以如果父类的方法被private、final、static修饰的话，子类就无法对父类的方法重写。被final修饰的方法称为密封方法，不能被重写）
  • 访问权限不能比父类中被重写的方法的访问权限更低。
  • 构造方法不能被重写（构造方法只能被重载）。
  • 当子类重写父类的方法时，可以使用@Override注解来提醒编译器进行检查，确保方法名和参数正确地覆盖了父类的方法。

下面是方法重写的代码演示，请看：

java 复制代码 
class Person{
    public String name;
    public int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person(String name,int age)");
    }

    public void fun(){
        System.out.println(name+",你今天开不开心");
    }
}
class Student extends Person {
    public int mark;

    public Student(String name,int age,int mark){
        super(name,age);
        this.mark = mark;
        System.out.println("Student(String name,int age,int mark)");
    }

    @Override
    public void fun(){
        System.out.println(name+"今天的作业太多了,不是很开心");
    }
}
class Teacher extends Person{
    public int wages;

    public Teacher(String name,int age,int wages){
        super(name,age);
        this.wages = wages;
        System.out.println("Teacher(String name,int age,int wages");
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("Daming",18,100);
        s1.fun();
    }
}

运行结果如下：

重载和重写的方法

重载 重写
方法名称 必须相同 必须相同
返回值类型 返回值类型不做要求 返回值可以相同，但是不同时必须构成父子类关系
参数列表 参数列表不同（个数、数据类型、顺序） 参数列表相同
范围 重载的方法要在同一个类中 被重写的类和要重写的类必须构成继承关系

四、向上转型和向下转型

4.1向上转型

向上转型：创建一个子类对象，将其当成父类对象来进行使用。

语法格式：父类类型 对象名 = new 子类类型();

向上转型的使用场景有三种：直接赋值、方法传参、方法返回。

这里直接以代码进行举例了：

java 复制代码 
class Person{
    public String name;
    public int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person(String name,int age)");
    }

    public void fun(){
        System.out.println(name+",你今天开不开心");
    }
}
class Student extends Person {
    public int mark;

    public Student(String name,int age,int mark){
        super(name,age);
        this.mark = mark;
        System.out.println("Student(String name,int age,int mark)");
    }

    @Override
    public void fun(){
        System.out.println(name+"今天的作业太多了,不是很开心");
    }
}
class Teacher extends Person{
    public int wages;

    public Teacher(String name,int age,int wages){
        super(name,age);
        this.wages = wages;
        System.out.println("Teacher(String name,int age,int wages");
    }
}

public class Test {

    public static void main(String[] args) {
        Student s1 = new Student("Lihua",21,150);
        // p1引用指向了s1
        Person p1 = s1;

        // p1.mark;  // error 无法访问，因为Person中没有mark这个属性

        // 这里编译的时候编译器认为是访问的Person类中的fun(),但是
        // 程序运行的时候访问的是子类Student中的fun()
        // 此过程成为动态绑定
        s1.fun();
    }
}

这里要补充动态绑定和静态绑定两个概念。

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

下面代码就是向上转型的三种使用场景，请看：

java 复制代码 
class Person{
    public String name;
    public int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person(String name,int age)");
    }

    public void fun(){
        System.out.println(name+",你今天开不开心");
    }
}
class Student extends Person {
    public int mark;

    public Student(String name,int age,int mark){
        super(name,age);
        this.mark = mark;
        System.out.println("Student(String name,int age,int mark)");
    }

    @Override
    public void fun(){
        System.out.println(name+"今天的作业太多了,不是很开心");
    }
}
class Teacher extends Person{
    public int wages;

    public Teacher(String name,int age,int wages){
        super(name,age);
        this.wages = wages;
        System.out.println("Teacher(String name,int age,int wages)");
    }

    public void fun(){
        System.out.println(name+"很开心,因为今天发工资了");
    }
}

public class Test {
    public static void function(Person p){
        p.fun();
    }

    // 向上转型方式三:返回任意子类对象
    public static Person function3(){
        return new Teacher("Simon",21,120);
    }

    public static void main(String[] args) {

        // 向上转型方式一:直接赋值(子类对象直接赋值给父类对象)
        // Person p1 = new Student("Amy",22,99);

        // 向上转型方式二:方法的传参过程中，也可以向上转型
        Student s = new Student("Sam",23,25);
        function(s);

        Teacher t = new Teacher("Tom",26,10000);
        function(t);
    }
}

运行结果如下：

解释 ：在function(Person p)方法中，虽然一个引用调用一个方法，但是因为引用所引用的对象不同，导致调用这个方法所表现的行为不同。这种思想就是多态。

下面是向上转型的优缺点：

优点：让代码实现更简单灵活。

缺点：：不能调用到子类特有的方法。

4.2向下转型

重要的事情放前面，向下转型是非常不安全的，所以建议平时不要使用向下转型。

示例一：

java 复制代码 
class Person{
    public String name;
    public int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person(String name,int age)");
    }

    public void fun(){
        System.out.println(name+",你今天开不开心");
    }
}
class Student extends Person {
    public int mark;

    public Student(String name,int age,int mark){
        super(name,age);
        this.mark = mark;
        System.out.println("Student(String name,int age,int mark)");
    }

    public void getScore(){
        System.out.println("今天出成绩了");
    }

    @Override
    public void fun(){
        System.out.println(name+"今天的作业太多了,不是很开心");
    }


}
class Teacher extends Person{
    public int wages;

    public Teacher(String name,int age,int wages){
        super(name,age);
        this.wages = wages;
        System.out.println("Teacher(String name,int age,int wages)");
    }

    public void getWages(){
        System.out.println("今天发工资哈!");
    }

    public void fun(){
        System.out.println(name+"很开心,因为今天发工资了");
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Student("Donghua",21,112);

        // p1.getScore //error 因为这里只能访问Person类自己特有的方法

        Student s1 = (Student)p1;
        s1.getScore(); //这里通过s1可以访问getScore方法
    }
}

这里把Person类型强转为子类Student类型。

示例二：向下转型是指将父类类型的引用转换为子类类型的引用。在向下转型的过程中，需要确保原始对象的实际类型是转换后的子类类型，否则会抛出ClassCastException异常。

请看代码：

java 复制代码 
class Person{
    public String name;
    public int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person(String name,int age)");
    }

    public void fun(){
        System.out.println(name+",你今天开不开心");
    }
}
class Student extends Person {
    public int mark;

    public Student(String name,int age,int mark){
        super(name,age);
        this.mark = mark;
        System.out.println("Student(String name,int age,int mark)");
    }

    public void getScore(){
        System.out.println("今天出成绩了");
    }

    @Override
    public void fun(){
        System.out.println(name+"今天的作业太多了,不是很开心");
    }


}
class Teacher extends Person{
    public int wages;

    public Teacher(String name,int age,int wages){
        super(name,age);
        this.wages = wages;
        System.out.println("Teacher(String name,int age,int wages)");
    }

    public void getWages(){
        System.out.println("今天发工资哈!");
    }

    public void fun(){
        System.out.println(name+"很开心,因为今天发工资了");
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Student("Jame",21,115);
        Teacher t1 = (Teacher)p1;
        t1.getWages();
    }
}

示例二运行结果如下：

示例二解释 ：首先创建了一个Student对象，并将其赋值给了一个Person类型的变量p1。这是一种向上转型的操作，可以安全地进行，因为Student是Person的子类。

接着 ，尝试将p1向下转型为Teacher类型，即将其赋值给一个Teacher类型的变量t1。这是一种不安全的操作，因为p1实际上是Student类型的对象。运行这段代码会抛出ClassCastException异常。

示例二解决方式，请看代码：

java 复制代码 
Person p1 = new Student("Jame", 21, 115);
if (p1 instanceof Teacher) {
    Teacher t1 = (Teacher) p1;
    t1.getWages();
} 
else {
    System.out.println("p1不是Teacher类型的对象");
}

好了，以上就是本文的全部内容啦，就到这里吧！！！
再见啦友友们！！！

相关推荐
新手小袁_J4 分钟前
JDK11下载安装和配置超详细过程
java·spring cloud·jdk·maven·mybatis·jdk11
呆呆小雅5 分钟前
C#关键字volatile
java·redis·c#
Monly216 分钟前
Java(若依)：修改Tomcat的版本
java·开发语言·tomcat
boligongzhu7 分钟前
DALSA工业相机SDK二次开发（图像采集及保存）C#版
开发语言·c#·dalsa
Eric.Lee20217 分钟前
moviepy将图片序列制作成视频并加载字幕 - python 实现
开发语言·python·音视频·moviepy·字幕视频合成·图像制作为视频
Ttang238 分钟前
Tomcat原理（6）——tomcat完整实现
java·tomcat
7yewh9 分钟前
嵌入式Linux QT+OpenCV基于人脸识别的考勤系统 项目
linux·开发语言·arm开发·驱动开发·qt·opencv·嵌入式linux
钱多多_qdd19 分钟前
spring cache源码解析（四）——从@EnableCaching开始来阅读源码
java·spring boot·spring
waicsdn_haha21 分钟前
Java/JDK下载、安装及环境配置超详细教程【Windows10、macOS和Linux图文详解】
java·运维·服务器·开发语言·windows·后端·jdk
_WndProc23 分钟前
C++ 日志输出
开发语言·c++·算法
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10红米手机使用google play