面向对象编程（五）多态

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量1k 收藏 22
点赞数 23
文章标签： java 算法 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68441705/article/details/135431144
版权

目录

1.多[多种]态[状态]基本介绍

2.多态的具体表现

3.注意事项

4.Java 重要特性: 动态绑定机制

5.多态的应用

1.多[多种]态[状态]基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

2.多态的具体表现

  • 方法的多态：重写和重载就体现多态

public class demo01 {
    public static void main(String[] args) {
        //方法重载体现多态
        A a = new A();
​
        //这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态
        System.out.println(a.sum(10, 20));
        System.out.println(a.sum(10, 20, 30));
        //方法重写体现多态
        B b = new B();
        a.say();
        b.say();
    }
}
class B { //父类
    public void say() {
        System.out.println("B say() 方法被调用...");
    }
}
class A extends B {//子类
​
    public int sum(int n1, int n2) {//和下面 sum 构成重载
        return n1 + n2;
    }
​
    public int sum(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }
}

  • 对象的多态

    • 一个对象的编译类型和运行类型可以不一致（可一致）

    • 编译类型在定义对象，就确定了，不能改变

    • 运行类型是可以变化的

    • 编译类型看定义时 = 号的左边，运行类型看 = 号的右边

Animal animal = new Dog();  //animal 编译类型就是 Animal , 运行类型 Dog
animal = new Cat();   //animal 编译类型 Animal,运行类型就是 Cat  

3.注意事项

  • 多态的前提是：两个对象(类)存在继承关系

  • 多态的向上转型

    • 本质：父类的引用指向了子类的对象

    • 语法：父类类型 引用名 = new 子类类型（）；

    • 特点：编译类型看左边，运行类型看右边。可以调用父类中的所有成员（遵守访问权限），不能调用子类的特有成员；运行效果看子类的具体实现。即调用方法时，按照从子类(运行类型)开始查找方法后调用

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("hello,你好");
    }
}
public class Cat extends Animal{
    public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){//Cat 特有方法
        System.out.println("猫抓老鼠");
    }
}

public class TestAniaml {
    public static void main(String[] args) {
        //向上转型: 父类的引用指向了子类的对象
//语法：父类类型引用名 = new 子类类型();
        Animal animal = new Cat();
        Object obj = new Cat();
        //可以吗? 可以 Object 也是 Cat 的父类
//animal.catchMouse();错误
        animal.eat();//猫吃鱼.. animal.run();//跑
        animal.show();//hello,你好
        animal.sleep();//睡
​
    }
​
}

  • 多态的向下转型

    • 语法：子类类型 引用名 =（子类类型）父类引用;

    • 只能强转父类的引用，不能强转父类的对象

    • 要求父类的引用必须指向的是当前目标类型的对象

    • 可以调用子类类型中所有成员

    //多态的向下转型
//(1)语法：子类类型 引用名 =（子类类型）父类引用;
// cat 的编译类型 Cat,运行类型是 Cat
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠
//(2)要求父类的引用必须指向的是当前目标类型的对象
        Dog dog = (Dog) animal; //可以吗？  不可以，相当于将猫强转为一个狗
        System.out.println("ok~~");

  • 属性没有重写之说！属性的值看编译类型

public class bianyi {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);// 看编译类型 10
        Sub sub = new Sub();
        System.out.println(sub.count);// 20
    }
}
​
class Base { //父类
    int count = 10;//属性
}
class Sub extends Base {//子类
    int count = 20;//属性
}

  • instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型

public class instanceOf {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);// true
        System.out.println(bb instanceof AA);// true
​
        //aa 编译类型 AA, 运行类型是 BB
        //BB 是 AA 子类
        AA aa = new BB();
        System.out.println(aa instanceof AA);// true
        System.out.println(aa instanceof BB);// true
​
    }
}
​
class AA { }
class BB extends AA { }

4.Java 重要特性: 动态绑定机制

  • 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

  • 当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

5.多态的应用

  • 多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

eg： 应用实例:现有一个继承结构如下：要求创建 1 个 Person 对象、2 个Student 对象和 2 个 Teacher 对象, 统一放在数组中，并调用每个对象say 方法. 并且实现调用子类特有的方法，比如Teacher 有一个 teach , Student 有一个 study

定义父类实体类Person

public class Person {
    private String name;
    private int age;
​
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String say() {//返回名字和年龄
        return name + "\t" + age;
    }
}

定义学生类子类

public class Student extends Person{
    private double score;
​
    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
​
    public double getScore() {
        return score;
    }
​
    public void setScore(double score) {
        this.score = score;
    }
​
    @Override  
    public String say() {
        return super.say() + score;
    }
    //特有的方法
    public void study() {
        System.out.println("学生 " + getName() + " 正在学 java...");
    }
}

定义老师类子类

public class Teacher extends Person{
    private double salary;
​
    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }
​
    public double getSalary() {
        return salary;
    }
​
    public void setSalary(double salary) {
        this.salary = salary;
    }
​
    @Override
    public String say() {
        return super.say() + salary;
    }
    //特有方法
    public void teach() {
        System.out.println("老师 " + getName() + " 正在讲 java 课程...");
    }
​
}

测试调用

public class Tset {
    public static void main(String[] args) {
        Person[] person = new Person[5];
        person[0] = new Person("a",11);
        person[1] = new Student("b",12,99);
        person[2] = new Student("c",13,34);
        person[3] = new Teacher("d",14,10000);
        person[4] = new Teacher("e",15,20000);
        //循环遍历多态数组，调用 say
        for (int i = 0; i < person.length; i++) {
            // person[i] 编译类型是 Person ,运行类型是是根据实际              情况有 JVM 来判断
            System.out.println(person[i].say());//动态绑定机制
            // 使用 类型判断 + 向下转型.
            if(person[i] instanceof Student){
                Student student = (Student) person[i];
                student.study();
                // ((Student)person[i]).study();
            }else if(person[i] instanceof Teacher){
                ((Teacher)person[i]).teach();
            }else if(person[i] instanceof Person){
​
            }else{
                System.out.println("false");
            }
​
        }
​
    }
}

  • 多态参数

方法定义的形参为父类类型，实参类型允许子类类型

eg：

测试类

public class employeeTest {
    public static void main(String[] args) {
        Work a = new Work("a",1500);
        Manager b = new Manager("b",10000,125);
        employeeTest et = new employeeTest();
        et.showEmpAnnual(a);
        et.showEmpAnnual(b);
        et.testWork(a);
        et.testWork(b);
​
    }
    //showEmpAnnual(Employee e)
    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());
​
    }
    public void testWork(Employee e){
        if(e instanceof Work){
            ((Work) e).work();
        }else if(e instanceof Manager){
            ((Manager) e).manage();
        }else{
            System.out.println("false");
        }
    }
}

雇员父类

public class Employee {
    private String name;
    private double mouth;
​
    public Employee(String name, double mouth) {
        this.name = name;
        this.mouth = mouth;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public double getMouth() {
        return mouth;
    }
​
    public void setMouth(double mouth) {
        this.mouth = mouth;
    }
​
    public double getAnnual(){
        return  mouth *12;
    }
}

普通员工子类

public class Work extends Employee{
    public Work(String name, double mouth) {
        super(name, mouth);
    }
    public void work(){
        System.out.println("普通员工" + getName() + "is working");
    }
​
    @Override
    public double getAnnual() {
        return super.getAnnual();
    }
}

经理子类

public class Manager extends Employee{
    private double bonus;
​
    public Manager(String name, double mouth, double bonus) {
        super(name, mouth);
        this.bonus = bonus;
    }
​
    public double getBonus() {
        return bonus;
    }
​
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
​
    @Override
    public double getAnnual() {
        return super.getAnnual()+bonus;
    }
​
    public void manage(){
        System.out.println("经理" + getName() + "is managing");
    }
​
}

熬夜学习行不行
关注
  • 23
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
面向对象编程——多态
m0_68989458的博客
05-01 800
面向对象编程——多态
面向对象-----多态
qq_46652775的博客
12-18 5741
1、多态的概念 （1）多态是面向对象的一个重要特征，指同一类事物同时具有多种形态，即同一类事物，在不同时刻，代表的对象不一样，指的是对象的多种形态。比如，对于笔记本电脑，它可以是苹果笔记本、华硕笔记本、弘基笔记本、神州笔记本。 （2）多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如鸟类的飞行行为,鸽子,燕子,老鹰它们各自的飞行方式是不同的，再比如动物都有吃这个功能，但是它们吃的食物是不同的,老虎吃肉,牛吃草,猫吃猫粮,狗吃狗粮。 （3）多态就是同一个接口...
面向对象编程之多态（JavaScript）
qq_45622114的博客
08-11 612
学会多态，摒弃原来编码风格
Java面向对象编程——多态
WXS153322的博客
04-11 551
多态指的是同一个行为具有多个不同表现形式和形态的能力。多态就像是一个接口一样，使用不同的实例就会执行不同的操作，例如，同样是水的成分，有液态水及固态水(也就是冰)等多种形态；同样是二氧化碳，存在气态及液态等多种形态；同样是猫科动物，有猫和老虎等不同表现形式。 那么Java中实现多态的三个必要条件如下。 继承：在多态中必须存在有继承关系的子类和父类。 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备调用
面向对象——多态
杨思默
05-27 2003
1. 多态概念        多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。        可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。 多态的主要用途 1、提高程序的可扩展性； 2、降低系统耦合度； 3
C#面向对象编程：多态
qq_35320456的博客
02-08 1181
C#面向对象编程：多态
面向对象中多态的理解
向诸位大佬虚心学习
05-27 1140
面向对象三大特征：封装、继承、多态。 今天，我们来了解一下多态。 什么是多态 多态指同一个实体同时具有多种形式，指为不同数据类型的实体提供统一的接口。它是面向对象程序设计（OOP）的一个重要特征。 eg：品鉴师要品菜，一号厨师煮出了淮扬菜，二号厨师炒了东北菜。 多态的好处 主要是利于代码扩展 多态的类型 分为运行时的多态和编译时的多态 运行时的多态：通过覆写虚成员实现。直到系统运行时，才根据实际来决定实现哪种操作 编译时的多态：通过重载来实现。根据传递的参数、返回的类型等信息决定实现何种操作 结合设计模式
面向对象编程中多态的快速理解
吉大秦少游
10-10 1654
1，函数重写回顾： 父类中被重写的函数依然会继承给子类； 子类中重写的函数将覆盖父类中的函数； – 重写父类当中提供的函数是因为父类当中提供的这个函数版本不能满足我们的需求，因此我们要重写； – 期望只要是子类对象，则调用子类当中的版本，而不是父类当中定义的函数版本； 通过作用域分辨符（::）可以访问到父类中的函数； Child c; Parent* p = &c; ...
C语言--面向对象编程之多态
weixin_46185705的博客
03-27 3478
系列文章目录 C语言–面向对象编程之封装 C语言–面向对象编程之继承 文章目录系列文章目录前言一、多态是什么？二、使用步骤1.引入库2.读入数据总结 – 前言 C语言实现面向对象编程的第三篇，在前面两篇里面我们已经讨论了C语言实现面向对象的封装与继承，这篇我们了解，面向对象的最后一个特性，多态，顺便了解一下C++中的虚指针与虚表。 一、多态是什么？ 多态指的是能够根据对象的不同类型调用同一个接口，实现不同的功能。在C++中有一个叫做重载的功能，作用类似，比如下面的函数。 看例子： /*函数重载*/ in
C/C++面向对象编程之多态
sinat_31039061的博客
02-09 1434
C/C++面向对象编程之封装 C/C++面向对象编程之继承 C/C++面向对象编程之多态 1、类型转换 先回忆一下C语言中经常使用数据类型的转换。 数据类型转换的前提是，编译器知道如何对数据进行取舍。例如： int a = 10.9; printf("%d\n", a); 输出结果为 10，编译器会将小数部分直接丢掉（不是四舍五入）。再如： float b = 10; printf("%f\n"...
javascript 面向对象编程基础 多态
10-29
多态是面向对象编程中一种重要的概念，它指的是同一操作作用于不同的对象，可以有不同的解释和不同的执行结果。多态可以分为编译时多态和运行时多态两种，前者通过方法重载实现，后者通过方法重写（覆盖）实现。在...
C#面向对象编程-多态习题[整理].pdf
10-11
C#面向对象编程-多态习题[整理].pdf
C#中面向对象编程机制之多态学习笔记
09-03
在C#中，面向对象编程机制的核心之一就是多态性，它允许我们设计更加灵活和可扩展的代码。多态性主要体现在接口多态和继承多态两个方面。 1. **接口多态性**： 接口多态是指不同的类实现同一个接口，并根据各自的...
Python面向对象编程之继承与多态详解
09-20
总结来说，Python的面向对象编程中的继承和多态是强大的工具，它们帮助开发者构建模块化的、可维护的代码。继承允许我们构建类的层次结构，通过共享和扩展基类的属性和方法，减少代码重复。多态则允许不同的对象以...
JAVA进阶补充
2301_80150315的博客
08-15 751
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 537
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 889
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 556
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 323
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值