【JavaSE】多态（多态实现的条件 重写 向上转移和向下转型 向上转型 向下转型 多态的优缺点 避免在构造方法种调用重写的方法）

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量610 收藏
点赞数
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68800221/article/details/130634479
版权

文章目录

多态

一种事物，多种形态。
多态的概念：去完成某个行为，当不同对象去完成时会产生出不同的状态。

多态实现的条件

1.必须再继承体系下。
2.子类必须要对父类中的方法进行重写。
3.通过父类的引用调用重写的方法。

在这里插入图片描述

当我们发生向上转型之后，此时通过父类引用只能访问父类自己的成员，不能访问到子类特有的成员。

重写

重写需要满足三个条件：

  1. 方法名称相同。
  2. 参数列表相同。
  3. 返回值相同。
class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫！");
    }
    @Override
    public void eat(){
        System.out.println(name+" 正在吃狗粮！");
    }
}

在这里插入图片描述
编译器可以生成：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫！");
    }
    @Override
    public void eat(){
        System.out.println(name+" 正在吃狗粮！");
    }
}
class Bird extends Animal{
    public String wing;//翅膀
    public void fly(){
        System.out.println(name+" 正在飞！");
    }
    @Override
    public void eat(){
        System.out.println(name+" 正在吃鸟粮！");
    }
}
public static void main(String[] args) {
       Animal animal1 = new Dog();
       animal1.name = "小黄";
       animal1.eat();
	System.out.println("=================");
       Animal animal2 = new Bird();
       animal2.name = "圆圆";
       animal2.eat();
}

在这里插入图片描述
静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

在这里插入图片描述

重写需要注意：

  1. private修饰的方法不能被重写。
  2. static修饰的方法不能被重写。
  3. 子类的访问修饰限定权限要大于等于父类的权限。 private < 默认 < protected < public
  4. 被final修饰的方法不能被重写，此时这个方法被称作密封方法。
    在这里插入图片描述

向上转移和向下转型

向上转型

实际就是创建一个子类对象，将其当成父类对象来使用。

  1. 直接赋值
class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫！");
    }
}
public class Test2 {
    public static void main1(String[] args) {
        Dog dog = new Dog();
        dog.name = "小黄";
        dog.eat();
        dog.wangwang();
        Animal animal = dog;
    }
}
  1. 方法传参
class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫！");
    }
}
public class Test2 {
    public static void func(Animal animal){
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        func(dog);
    }
}

3.方法返回值

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫！");
    }
}
public class Test2 {
    public static Animal func2(){
        return new Dog();
    }
    public static void main(String[] args) {
        func2();
    }
}

优点：让代码实现更简单灵活。
缺陷：不能调用到子类特有的方法。

向下转型

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+" 正在吃饭！");
    }
}
class Dog extends Animal{
    public void wangwang(){
        System.out.println(name+" 正在汪汪叫！");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        //向下转型
        Dog dog = (Dog)animal1;
        dog.name = "小黄";
        dog.wangwang();
    }
}

向下转型非常不安全，比如：
在这里插入图片描述

解决方法：Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

if(animal1 instanceof Dog){
     //向下转型
     Dog dog = (Dog)animal1;
     dog.name = "小黄";
     dog.wangwang();
}

可以理解为判断animal1这个引用，是不是引用Dog对象。

多态的优缺点

class Shap{
    public  void draw(){
        System.out.println("画图形！");
    }
}
class Rect extends Shap{
    @Override
    public void draw() {
        System.out.println("画矩形！");
    }
}
class Cycle extends Shap{
    @Override
    public void draw() {
        System.out.println("画圆！");
    }
}
class Flower extends Shap{
    @Override
    public void draw() {
        System.out.println("画一朵花❀！");
    }
}
public class Test3 {
    public static void drawMap(Shap shap){
        shap.draw();
    }
    public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();

        drawMap(rect);
        drawMap(cycle);
        drawMap(new Flower());
    }
}

在这里插入图片描述

class Shap{
    public  void draw(){
        System.out.println("画图形！");
    }
}
class Rect extends Shap{
    @Override
    public void draw() {
        System.out.println("画矩形！");
    }
}
class Cycle extends Shap{
    @Override
    public void draw() {
        System.out.println("画圆！");
    }
}
class Flower extends Shap{
    @Override
    public void draw() {
        System.out.println("画一朵花❀！");
    }
}
public class Test3 {
    public static void drawMap2(){
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        //c r c r f
        String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
        for (String shape : shapes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("rect")) {
                rect.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
        }
    }
    public static void main(String[] args) {
        drawMap2();
    }
}

在这里插入图片描述

多态实现：

public static void drawMap3(){
  Rect rect = new Rect();
  Cycle cycle = new Cycle();
  Flower flower = new Flower();
  Shap [] shaps = {cycle,rect,cycle,rect,flower};
  for(Shap shap:shaps){
      shap.draw();
  }
}

多态好处：

  1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else。
  2. 可扩展能力更强如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低。

多态缺陷：代码的运行效率降低。

  1. 属性没有多态性：当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性。
  2. 构造方法没有多态性。

避免在构造方法种调用重写的方法

下面我们看一段有坑的代码：

class B {
    public B() {
// do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}
public class Test4 {
    public static void main(String[] args) {
        D d = new D();
    }
}

当在父类的构造方法当中去调用父类和子类重写的方法的时候，此时会调用子类的。
num为0是因为父类此时还没有走完，就来到了打印阶段。

在这里插入图片描述
结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。

马尔科686
关注
专栏目录
java多态的几种方法_多态的两种实现方法
weixin_42502016的博客
02-27 2605
多态体现在父类和派生类之间，通过函数覆盖，实现在运行过程中动态调用函数。必要条件：(1)父类中将该函数声明为virtual(2)子类中完全一致的覆盖父类中的函数，要求返回值、函数名、参数都一致(3)通过指针或者借助于函数来实现方法一(利用指针)：#include class A{public:virtual void func(){cout<}}class B: public A{publi...
JavaSE基础知识(十八)--Java多态之构造方法和多态
ruidianbaihuo的博客
08-18 474
Java SE 是什么，包括哪些内容(十八)？ 本文内容参考自Java8标准 再次感谢Java编程思想对本文的启发！ 通常，构造方法不同于其他的普通方法，涉及到多态时仍是如此。 尽管构造方法并不具有多态性(在前面的博文中提到过，构造方法实际上是静态方法，只不过static的声明是隐式的)。但还是非常有必要理解构造方法怎样通过多态在复杂的层次结构中运作，这将有助于我们避免一些令人不快的困扰。 1、构...
JAVA中多态以及向上转型向下转型、重写的讲解
Green_756的博客
04-03 3428
对多态、、向上、向下转型，以及重写的解释
Day10 Java多态性继承关系中'向上转型'和'向下转型(还原)'的演示例子与作用及规则的详解.
硬核编程乐乐的博客
12-03 601
Polymorphism — 多态性 Multi — 多个 Restore — 还原 instansof — 实例-判断其类和对象是否有转型关系(instan噢夫) 一/多态性在代码中的体现 1/ 向上转型 那就是父类引用指向子类对象. 左父右子 释意:把右侧的子类当作左侧的父类来使用(把子类当父类用) 格式: 父类名 自定义对象名 = new 子类名(); 或者: 接口名 ...
深入理解Java中的继承与多态（包括向上、向下转型）
Darling_sheeps的博客
09-14 448
继承 语法结构：class 子类名称 extends 父类名称 { } 子类继承了父类除构造方法以外所有的。例如： class Animals{ String name; int age; void eat(){ System.out.println("Animals:eat()"); } } class cat extends Animals{ } //cat作为animals的子类，就继承了父类的name、age属性和eat（）方法。 注：如果父类中有私有的属性或行为，子类也会继承，只
JavaSE - 多态、重载与重载的区别（详）、向上转型和向下转型
Fighting！！！
08-10 531
重写、向上转型和向下转型、多态、instanceof、封装继承多态的总结
[JavaSE] 面向对象编程（多态深度理解、向下转型、super与this区别、大坑）
Nick 的笔记
04-06 1045
​ 🍹欢迎各路大佬来到 Nick 主页指点 ☀️本期文章将学习 [JavaSE] 面向对象编程（多态深度理解、向下转型、super&&this、大坑），我是博主Nick。✨ ✨我的博客主页：Nick_Bears 🌹꧔ꦿ 🌹꧔ꦿ博文内容如对您有所帮助，还请给个点赞 + 关注 + 收藏✨ ​
【JavaSE系列】 第九话 —— 多态那些事儿
哎呀是小张啊 的博客
04-15 3481
一步一步帮你认识多态！！！！！！
JavaSE——Day9——多态、抽象类、接口
晃在云淡风轻
02-07 418
多态 简单来说，就是某个事物在不同时刻表现出的不同状态。 来看一个小的案例： public class Demo { public static void main(String[] args) { Cat cat = new Cat(); //Animal cat = new Cat(); } } class Animal { } class Ca...
JavaSE学习总结（六）面向对象（中）代码块继承this和super父类没有无参构造子类怎么办方法重写重写和重载的区别final关键字多态多态成员访问特点向上转型向下转型孔子装爹
long3359的博客
03-05 138
JavaSE学习总结（六）面向对象（中）代码块/继承/this和super/父类没有无参构造子类怎么办/方法重写/重写和重载的区别/final关键字/多态/多态成员访问特点/向上转型向下转型/孔子装爹
JavaSE进阶_03_接口&多态
mxyjajajavavava的博客
03-19 278
今日内容 ​ 接口 【重点】 ​ 多态 【重点】 接口 【重点】 什么是接口 当一个类中的所有的方法都是抽象方法的时候，这个类就可以定义成接口 接口其实是特殊的类，比抽象类更加抽象 接口是使用interface关键字定义的特殊的类 接口的好处 1、定义了规则：接口中的抽象方法可以认为是一种规则 2、利于扩展 接口的定义格式 public interface 接口名{} 接口的特点 1、接口不能实例化
06【接口、多态】
緑水長流*z
07-30 4379
一、接口 1.1 接口概述 1.1.1 接口引入 继承抽取了类的共性，使得其子类都具备了父类的功能，提高了代码的复用性，但是有些情况下，并不是所有的子类都应该具备父类的全部功能，有些功能只是当做与"扩展功能"，并不是与生俱备的； 例如：吃饭、睡觉、走路等本就是人们具备的功能，我们可以将其定义在"人类"的继承体系中，只要是一个"人类"，那么就应该具备这些功能；但是有些功能是只有一部分人会的，如打篮球、敲代码等，如果将这些功能也定义在"人类"这个继承体系中，那么所有的人就必定要会打篮球
Java多态、方法的重写、static、final
Zp_support的博客
07-23 422
JavaSE之多态、方法的重写、static、final
【JavaSE】继承和多态重点语法知识汇总
qq_68993495的博客
09-26 783
JavaSE之继承和多态，本部分属于语法中的难点，希望这篇文章对你有所帮助！
服务器虚拟化
最新发布
Hellc007的博客
10-30 469
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 962
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 456
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1211
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
2301_79272475的博客
10-30 231
Java复习24（PTA)：多种排序的book类*
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

马尔科686

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值