面向对象------多态

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量879 收藏 34
点赞数 38
文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80826557/article/details/139203423
版权

1.多态的定义

通俗来说，当同一种行为或者事情发生在不同的对象上，这些行为或者事情最终得到的结果不同。

注意：多态要发生在继承的基础上。

例如：彩色打印机和黑白打印机。

彩色打印机和黑白打印机是不同的对象，但打印（行为）这件事分别发生在它们身上的时候，彩色打印机打印的是彩色的，而黑白打印机最终打印的结果却是黑白色的。

9d2c6dfbc7b140c69b09ee67f3d2d610.jpeg

对应到Java中就是相同的方法对应到不同的对象中有不同的结果。

 2.多态的使用

2.1 向上转型

向上转型发生在继承的基础上，所谓向上转型，就是由子类类型向父类类型转换。向上转型的方式由3中，分别为：直接赋值、方法的传参和方法的返回值形式。

cd27b6ff42c54f478357c0f945739ffd.png

1.直接传参

class Animal{
    
}
class Dog extends Animal{
    
}
public class Test {
    public static void main(String[] args) {
        //直接赋值，发生向上转型
        Animal animal=new Dog();
    }
}

2. 方法的传参

class Animal{

}
class Dog extends Animal{

}
public class Test {
    public static void func(Animal animal){
        
    }
    public static void main(String[] args) {
        Dog dog=new Dog();
        //方法的传参实现向上转型
        func(dog);
    }
}

3.方法的返回值

class Animal{

}
class Dog extends Animal{

}
public class Test {
    public static Animal func(){
        Dog dog=new Dog();
        return dog;
    }
    public static void main(String[] args) {
        Animal animal=func();   
    }
}

4 向上转型的缺点

当我们进行了向上转型，我们就不能通过父类的引用（转型之后的引用）去访问子类特有的属性或者方法。 

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    public void bark(){
        System.out.println(this.name+"在汪汪叫");
    }
}
class Animal{
    public String name;
    public int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog("旺财",18);
        animal.bark();
        
    }
}

运行以上代码会报错

3a35aad63445466885f9c1362e88f5fe.png

 2.2 动态绑定

动态绑定是理解多态的基础。

 1.方法的重写

当子类和父类中有一个方法名字一样，参数列表一样和返回值类型一样，但是方法内不得具体实现不一样，则子类对应的方法构成了方法的重写。

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    @Override  //编译器中方法重写的默认注释
    public void eat() {
        System.out.println(this.name+"在吃狗粮");
    }
}
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(this.name+"在吃饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog("旺财",18);
    }
}

576d89fe0853486e98df4213b8c9be63.png

如上图，红框框里面就是构成重写的部分。

2.方法重写的注意事项

1.重写的方法不能是一个静态的方法（被static修饰的方法）。

28c19be6474e4253a98792d78ccb6458.png

2.被final修饰的方法无法被重写

f62da0c70ea540acabba5dd3c82d2a38.png

3.如果子类重写父类的方法时，子类重写方法时的访问权限要大于等于父类方法的权限。

                                    访问权限大小比较
                          public>protected>default>private

bb77810d585141edb5bb2f574fc883d7.png

如图，因为父类要被重写的方法得访问权限为public，而子类中重写的方法的访问权限为private，所以运行代码时，编译器会报错。

4.父类中被private修饰的方法无法被重写

1b6abd7d39a849839ceeb30887da433e.png

5.重写的方法的返回值类型可以不相同，但是返回值类型必须构成父子类的关系。

b86f870320124880b8e861f5bc099294.png

                         

3. 方法的重写和重载的区别

                         重载                      重写
   参数列表中的数据类型，顺序和个priv数可以不一样 参数列表中的数据类型，顺序和个数必须一样
   返回值的类型不一样  返回值类型必须一样
   方法名必须一样   方法名必须一样

4.动态绑定

当运行代码时，我们通过父类的引用去调用在子类和父类中重写的方法，结果实际调用了子类的方法，这种情况就被称为动态绑定。

 代码演示

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    @Override  //编译器中方法重写的默认注释
    public void eat() {
        System.out.println(this.name+"在吃狗粮");
    }
}
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(this.name+"在吃饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog("旺财",18);
        animal.eat();
    }
}

运行代码

3131275c2b1940e5a641801a54ebc4f8.png

通过上面代码，我们发现，当我们完成了向上转型之后，我们通过父类的引用去调用重写的方法时，程序在编译时，调用的确实是父类的eat( )方法。但是由于动态绑定，最终我们看到的是Dog类中的eat( )方法。

 2.3 向下转型

向下转型也是发生在继承的继承的基础上，向下转型就是父类向子类转换。

019109a214b24964aa6670dc6a75a062.png

 1.向下转型的优点

通过向下转型，我们就可以访问子类中特有的属性和方法。

代码演示

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    @Override  //编译器中方法重写的默认注释
    public void eat() {
        System.out.println(this.name+"在吃狗粮");
    }
    public void run(){
        System.out.println(this.name+"会跑");
    }
}
class Bird extends Animal{
    public Bird(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(this.name+"在吃鸟粮");
    }
    public void fly(){
        System.out.println(this.name+"会飞");
    }
}
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(this.name+"在吃饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog("旺财",18);
        Dog dog=(Dog)animal;//要强转类型
        dog.run();//Dog类中特有的方法
        System.out.println("=======");
        Animal animal2=new Bird("小鸟",12);
        Bird bird=(Bird) animal2;//要强转类型
        bird.fly();//Bird类中特有的方法
    }
}

运行代码 

21281240949c45d1bad4775eb2eb84a9.png

2.向下转型的缺点

并不是所有的向下转型都是成功的。

655dac7b18a94886b34688831f9dd55f.png

57860363b23b4fd29afafe3141b260cd.png

3.多态的使用

了解了向上转型和多态之后，我们接着来在Java中来体验多态。

代码演示

class Dog extends Animal{
    public Dog(String name,int age){
        super(name, age);
    }
    @Override  //编译器中方法重写的默认注释
    public void eat() {
        System.out.println(this.name+"在吃狗粮");
    }
}
class Bird extends Animal{
    public Bird(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(this.name+"在吃鸟粮");
    }
}
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(this.name+"在吃饭");
    }
}
public class Test {
    public static void func(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog=new Dog("旺财",18);
        func(dog);
        System.out.println("=======");
        Bird bird=new Bird("小鸟",12);
        func(bird);
    }
}

129db2974a1744508bc94abd0bc30893.png

1b615045c53a47a9b98a69f6bbfcd19e.png

我们都是通过animal这个引用去调用父类中的eat( )方法，但是由于eat( )对应的对象不同，就调用了各对应子类中的eat( ) 方法，最终导致了结果的不同。这就是多态在Java语言中的体现。 

徐子童
关注
面向对象-----多态
qq_46652775的博客
12-18 5839
1、多态的概念 （1）多态是面向对象的一个重要特征，指同一类事物同时具有多种形态，即同一类事物，在不同时刻，代表的对象不一样，指的是对象的多种形态。比如，对于笔记本电脑，它可以是苹果笔记本、华硕笔记本、弘基笔记本、神州笔记本。 （2）多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如鸟类的飞行行为,鸽子,燕子,老鹰它们各自的飞行方式是不同的，再比如动物都有吃这个功能，但是它们吃的食物是不同的,老虎吃肉,牛吃草,猫吃猫粮,狗吃狗粮。 （3）多态就是同一个接口...
JavaScript面向对象-多态
William_fang的博客
06-17 663
文章目录1.多态的概述2.代码展示3.效果展示 1.多态的概述 多态：同一个操作在不同的对象上，出现不同的执行结果。 js的多态性是与生俱来的，就像代码中的形参animal可以传入任何类型的参数，十分灵活。 2.代码展示 <script> var makeSound=function(animal){ //执行了同一个操作 animal.sound(); } var Duck=function(){ } Duck.prototype.
Java面向对象-多态详解
weixin_58016347的博客
03-20 934
Java面向对象之多态详解
JAVA面向对象--封装继承和多态
qq_57936953的博客
03-30 1043
不同类型的对象，相互间经常有一定数量的共同点。比如不同职业的人，他们都属于人类；不同种类的动物，他们都属于动物类；不同品牌的衣服，它们都属于服装类。将这些不同对象中的共有属性和共有方法抽取出来，就可以组成他们的父类。多态就是一个对象具有的多种状态，具体表现为父类引用指向子类实例。// 当前事物, 是一只猫c.eat();// 当前事物, 是一只动物a.eat();System.out.println("动物吃饭");@OverrideSystem.out.println("猫吃鱼");
java面向对象 --- 多态
火车头的博客
05-08 997
目录 多态 多态的由来 多态的分类 转型技术 基本数据类型之间的转换 引用数据类型也能做强转或自动转 引用数据类型转换的本质 父类引用指向子类对象有何特点？ 父类引用指向子类对象后的弊端 instanceof 多态的应用 多态参数 异构集合 多态 多态的由来 多态在面向对象中的含义：相同的行为，不同的实现。 相同的行为的体现： 1、多态是描述行为的，也就是方法； 2、相同行为其实在本质上就是“同名”方法。 不同的实现： 同名的方法，但是个各自有各自的方法实现体，也就是
面向对象特征-多态
编程鸟
08-01 3321
1、多态的相关概念 多态的意思是：一个事物有多种形态。从系统实现的角度看，多态性分为两类：静态多态和动态的多态。函数的重载和运算符的重载都属于静态的多态，在程序编译时系统就能决定调用的是哪一个函数，因此静态的多态又称为编译时的多态性；动态的多态性是在程序运行过程中才动态的确定操作所针对的对象，因此又称为运行时的多态。动态的多态性是通过虚函数实现的。 2、构成多态的条件： （1）必须要使用关键字v
面向对象---多态
qq_49290616的博客
02-28 5563
这次是2021年01月19日的学习成果，总结于此，以便于之后的学习查漏补缺 多态（重点） 多态概述 生活实例 实例1： 水果：苹果，香蕉，西瓜 实例2： 动物：老虎，狮子，大象 实例3： 动物叫：猫叫，牛叫，羊叫 总结：多态即为多种形态，状态 多态的实现条件 Java实现多态的必要条件:继承、重写。 当编译时类型和运行时类型不一致，就会出现多态(Polymorphism) 多态实现基础 父类声明的变量可以引用所有子类的对象，这是多态实现的基础。 我们只有在 运行 的时候才会知道引用变量所指向的具体实例对象
面向对象-多态-引出
2303_80050865的博客
03-27 96
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
面向对象--多态.md
06-26
面向对象--多态.md
JAVA面向对象-多态（完结）
12-13
JAVA面向对象---多态（完结）
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2022
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 835
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 432
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 534
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 794
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
深入探索Objective-C面向对象编程
在面向对象编程（Object-Oriented Programming, OOP）中，有四个核心概念：封装、继承、多态和抽象。Objective-C 支持这些特性，并通过其特有的语法来实现。 1. 封装：Objective-C 通过定义类（Class）来实现封装，...
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值