java SE 多态的详细讲解

已于 2023-11-22 18:48:25 修改
阅读量68 收藏 2
点赞数 4
分类专栏： JavaSE 让你了解基础语法 文章标签： java jvm 开发语言
于 2023-11-15 16:03:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjmyydsds/article/details/134403736
版权

1.1什么是向上转型

1.向上转型可以理解为

子类对象实例化一个对象

父类对象实例化一个对象

但是这个父类实例化的对象是指向子类实例化对象的，这样就让父类拥有了子类成员变量的全部特征

（比较重要的一点是，父类不能够拥有子类中的方法下面代码就可以详细讲解）

把这个代码方道idea中可以发现代码的第37行报错了而38行是没有报错的！由此可以看出父类被向上转型以后是可以调用子类的成员变量，不能调用子类的成员方法的！

class Animal{
    public String name ;
    public  int age ;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void barks_1(){
        System.out.println(this.name+"狗的名字是");
    }
}


class Dog extends Animal{
    public String color ;
    public  Dog (String name,int age,String color){
        super(name,age);
        this.color = color;
    }
    public void barks (){
        System.out.println(this.name+"正在汪汪叫");
    }
}


class Cat extends  Animal{
   public  Cat(String name,int age){
       super(name,age);
   }
}

public class Frank {
    public static void main(String[] args) {
    Dog dog = new Dog("旺财",18,"green");
    Animal dog_2 = dog ;
    dog_2.barks();
    dog_2.barks_1();
    }
}

2.1什么是多态！

2.1.1理解多态

1.要先理解向上转型。

（1.1已经详细讲解）

2.理解重写

2.1.2 什么是静态绑定！

1.代码（动态绑定代码）

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+"正在恰饭");
    }
}


class Dog extends Animal{
    public String color ;
    public  Dog (String name,int age,String color){
        super(name,age);
        this.color = color;
    }
    public void eat(){
        System.out.println(this.name+"正在恰饭");
    }
    }
}


public class Frank {
    public static void main(String[] args) {
    Dog dog = new Dog("旺财",18,"green");
    Animal animal = dog ;
    animal.eat ();
    }
}
2.1.2.1动态绑定是什么（先理解动态绑定）

（1）在父类中也就是Animal类中我定义了一个eat方法，在子类dog中我定义了一个eat方法这两个方法是一样的！

（2）什么是动态绑定：在编译的时候还是认为调用了父类的eat方法，在运行的时候就绑定到了子类当中，（如上面代码就是在编译的时候就是eat方法但是一旦运行就是调用的子类方法）。

2.1.2.2 重写的特征

1.方法名相同。

2.参数列表相同【参数的顺序，类型个数】

3.返回值相同

代码如下

 public void eat(){
        System.out.println(this.name+"恰饭开心嘿嘿嘿");
    }
 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+"正在恰饭");
    }
}


class Dog extends Animal{
    public String color ;
    public  Dog (String name,int age,String color){
        super(name,age);
        this.color = color;
    }
    public void eat(){
        System.out.println(this.name+"恰饭嘿嘿嘿");
    }
}


public class Frank {
    public static void main(String[] args) {
    Dog dog = new Dog("旺财",18,"green");
    Animal animal = dog ;
    animal.eat ();
    }
}
2.1.2.3 向上转型的几种方式

1.代码

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+"正在恰饭");
    }
}


class Bird extends  Animal{
    public Bird(String name, int age) {
        super(name, age);
    }

    public void fly(){
        System.out.println(this.name+"正在飞");
    }
    public void eat(){
        System.out.println(this.name+"正吃狗粮");
    }
}



class Dog extends Animal{
    public String color ;
    public  Dog (String name,int age,String color){
        super(name,age);
        this.color = color;
    }
    public void eat(){
        System.out.println(this.name+"恰饭嘻嘻嘻嘻");
    }
}


public class Frank{
    public static void fun(Animal animal){
//第二种转型方式传参
    }

    public static void main(String[] args) {
        Dog dog = new Dog("旺财",18,"green");//子类
        Bird bird = new Bird("布谷",18);//子类
        Animal animal_2 = bird ;//向上转型第一种方式直接赋值
        fun(bird);//第二种向上转型，animal = bird animal就具有了bird子类的特征
        fun(dog);//同理

    }
}

//class Frank_1 {
//    public static void main3(String[] args) {
//    Dog dog = new Dog("旺财",18,"green");
//    Animal animal = dog ;
//    animal.eat ();
//    }
//}

我们定jinta5方法是fun，静态方法可以脱离对象，（在这里我们不用调用成员方法和成员变量所以只能用静态方法通过传参的方式进行向上转型），这样就使得animal这个对象有了Dog和Bird子类的特征（第二种向上转型）。

3.多态的展现

3.1我们在2.1.2.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(this.name+"正在恰饭");
    }
}


class Bird extends  Animal{
    public Bird(String name, int age) {
        super(name, age);
    }

    public void fly(){
        System.out.println(this.name+"正在飞");
    }
    public void eat(){
        System.out.println(this.name+"正吃狗粮");
    }
}



class Dog extends Animal{
    public String color ;
    public  Dog (String name,int age,String color){
        super(name,age);
        this.color = color;
    }
    public void eat(){
        System.out.println(this.name+"恰饭嘻嘻嘻嘻");
    }
}


public class Frank{
    public static void fun(Animal animal){
//第二种转型方式传参
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("旺财",18,"green");//子类
        Bird bird = new Bird("布谷",18);//子类
        Animal animal_2 = bird ;//向上转型第一种方式直接赋值
        fun(bird);//第二种向上转型，animal = bird animal就具有了bird子类的特征
        fun(dog);//同理

    }
}

//class Frank_1 {
//    public static void main3(String[] args) {
//    Dog dog = new Dog("旺财",18,"green");
//    Animal animal = dog ;
//    animal.eat ();
//    }
//}

 在fun这个静态方法中，我们通过传参的方式实现了向上转型，这时候我们的animal就有了子类的特征也就是bird和dog类，这时候我们在fun静态方法中调用animal进行向上转型后的eat方法（）这时候的运行结果会是

这样就引出了多态！（这个过程是动态绑定在2.1.2.1中有讲解）

可以看到我们调用eat方法出现了两个结果这两个结果是dog子类和bird中的eat方法！！

同一个动作却造成了不同的结果，理解为对你对不同的人会有不同的相处态度!

3.2运用返回值的方式向上转型

代码如下

 public  static Animal fun_2(){
//第三种转型方式 通过返回值向上转型

        return new Bird("布拉",1) ;

    }

    public static void main(String[] args) {
        Bird bird = new Bird("布谷",18);//子类
        Animal animal_2 = bird ;//向上转型第一种方式直接赋值
        fun_2().eat();

    }
}

3.3多态产生条件

1.发生向上转型（在向上转型的过程中会发生动态绑定）。

2.发生重写（2.1.2.2有讲解）

3.必须在继承体系下。

4.重写（覆盖，覆写）详细讲解（override）

4.1重写的注意事项和override关键字

1.重写是子类对父类非静态，非private，非final修饰，非构造方法的实现过程进行重写编写，返回值和形参都不能改变，核心重写！

（被final修饰的不能被重写，被他修饰就是密封了）。

2.@override关键字

帮助你检测这个类中的方法是否已经被重写。

3.被static修饰的方法不能被重写。

4.重写方法的权限

（1）子类重写父类方法的时候 

         子类权限要大于等于父类的权限

  (2)权限大小顺序：public > private >default >private

  5.被private修饰的类和方法是不能重写的！！！！！

     因为被private修饰的这个方法是只能在这个类的范围内进行使用！！

4.2 重写

4.2.1 重写的规则

1.子类重写父类方法的时候，一般必须于父类方法原型一直：返回值类型 方法名 （参数列表）要完全一致

2.被重写的方法返回值类型不同，但是必须是具有父子一般的关系

3.父类的访问权限一定要大于等于子类的访问权限。

4.父类不能被static private关键字修饰。

5.可以使用@overri注释显示指定，有了这个注释我们就可以进行一些合法性的校验，例如不小心将方法的名字拼错，那么编译器就会报错。

6.重写的方法名构成父子类关系也叫重写

（1）代码(animal是Dog的父类)

（2）被重写的方法一定要有父子类关系。

 public Animal eat_1(){
        System.out.println("想吃饭");
        return null;
    }
    public Dog eat_1(){
        System.out.println("大口吃");
        return null ;
    }

4.2.2重写和重载的区别

1.重写（override）和重载（overload）是面向对象编程中的两个重要概念。

2.重写是指在子类中重新定义父类的方法，以覆盖父类的实现。重写要求子类方法的名称、参数列表和返回类型与父类方法相同，以确保使用时可以通过子类引用调用父类方法时执行子类的实现。重写可以用于多态的实现，即通过父类引用调用子类对象的方法。

3.重载是指在同一个类中定义多个方法，方法名称相同但参数列表不同。重载可以有不同的参数类型、参数顺序或参数个数。当使用重载方法时，编译器会根据传入的参数进行匹配，选择最合适的方法进行调用。重载可以提供更灵活的方法调用方式，方便程序员根据实际需求选择不同输入参数的方法。

4.总结而言，重写是指在继承关系中，子类重新定义父类的方法；而重载是指在一个类中定义多个名称相同但参数列表不同的方法。

4.2.3重写的设计规则

1.类进来不要修改新建一个类来进行重写

5.1静态绑定

1.称之为前期绑定，即在编译时，更具用户传递的实参类型确定具体调用哪个方法，例如函数的重载。

6.向下转型详细讲解

6.1 向下转型定义

1.当一个子类继承自父类时，通过向上转型可以将子类的对象以父类的形式存储。

2.相当于把bird这个类放到了父类中然后这个bird变成了父类，实例化对象的时候，我通过这个调用了父类中新增的bird方法或者bird成员变量。

3.如果没有向下转型就不能使父类调用子类中的方法

4.代码

我们先通过向下转型使得父类可以访问子类中的方法

记住我们开始讲的多态是通过向上转型然后对子类和父类的方法进行重写再调用的相同的方法而不是使用了子类的方法记住这两个的区别！！！！

public class Frank{
    public static void main(String[] args) {
        Animal animal_1 = new Dog("旺财",18,"green");//子类
        Animal animal_2 = new Bird("布谷",18);//子类
//        animal_1.eat();//向上转型
//        animal_1.fly();//会报错，这个方法没有重写，所以这个是独属于子类的方法父类访问不了
        Bird bird = (Bird) animal_2;
        bird.fly;
        Bird bird_2 = (Bird) animal_1;//这个是骗过了编译器，运行会报错，因为在dog这个子类中是没有fly方法的

    }
}

5.所以上面代码可以看出向下转型是一个比较危险的操作，我们一般向下转型的时候要对其进行判断（记得不是所有的动物都是鸟结合上面代码）

6.为了避免6.1.2中的错误我们引入了instanceof这个关键词，这个关键字结合if语句可以帮助我们向下转型的安全性！代码如下

public class Frank{
    public static void main(String[] args) {
        Animal animal_1 = new Dog("旺财",18,"green");//子类
        Animal animal_2 = new Bird("布谷",18);//子类
       animal_1.eat();//向上转型
//        animal_1.fly();会报错
//        Bird bird = (Bird) animal_2;
//
//        Bird bird_2 = (Bird) animal_1;
        if (animal_1 instanceof  Bird){
            Bird bird_2 = (Bird) animal_2;
            bird_2.fly();
        }else {
            System.out.println("这个动物不是鸟");
        }
    }
}

7.其他注意事项

1.父类的构造方法中，如果调用子类和父类同名的方法也会发生动态绑定。意味着构造方法内也会发生动态绑定。

2.注意，在构造方法中不要调用重写的方法（一般情况我们的构造方法都是用来初始化成员变量的）。

3.运行的化先是父类的构造父类的实例再子类的构造再子类的实例。

8.多态的缺点

1.在java中的多态不能够多继承也就是有多个父类（java用接口解决这个问题下一篇文章会详细讲解）

2.可以更好的使得代码有复用性。

Frank1-0-2-4
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
Java面向对象——多态
weixin_62838185的博客
02-16 192
Eclipse中创建类时可快捷创建继承 关于Java语言当中的多态语法机制 /** * 1、Animal,Cat,Bird三者之间关系 * Cat继承Animal * Bird继承Animal * Cat和Bird之间没有继承关系 * * 2、面向对象三大特征：封装 继承 多态 * * 3、关于多态中设计到的几个概念： * *向上转型(...
【Java SE】多态
m0_61814277的博客
04-13 1258
本期内容主要介绍多态的概念、实现条件、重写、静态绑定与动态绑定、向上转型与向下转型以及多态的优缺点
【Java SE】多态的详解
程序猿教你打篮球的博客
09-14 6968
本期主要讲解： 1、多态 1.1 简单了解多态 1.2 多态的实现需要具备哪些条件？ 2、方法重写 2.1 重写的概念 2.2 方法重写的规则 2.3 重写和重载的区别 2.4 为什么需要重写呢？ 3、向上转型和向下转型 3.1 向上转型 3.2 结合向上转型，正式学习多态 3.3 向下转型 4、通过练习进一步了解多态 4.1 打印指定不同图案(多态实现) 4.2 避免在构造方法中调用重写的方法...
吐血整理Java SE 继承和多态
m0_48064834的博客
08-28 293
吐血整理Java SE 继承和多态
Java SE 封装 static详细讲解
cjmyydsds的博客
11-10 90
1.套壳屏蔽细节。2.可以理解为我们使用电脑我们并不用造电脑，直接拿来用就行，所以就可以说，封装就是将类进行封装，我们通过接口进行访问它的功能。
【Java Se】多态与抽象类
apple_51673523的博客
11-07 2365
前言 今天是2021LOL全球总决赛，一直不被大家看好的EDG冲到了决赛对战韩国队的DK，可以说EDG面对如此强大的对手，想赢是比较难的，为了给中国队打气我立下flag，如果EDG获胜那我就奖励自己学习到第二天6点，结果我就来了，，，恭喜EDG！ 为了接下来接口的学习，我们先来学习多态与抽类相关的一些知识，有助于我们更好的学习接口这一重点 目录前言多态初识多态什么是多态？多态的分类多态的必要条件实现多态向上转型向下转型instanceof运算符具体实现抽象类与抽象方法为什么要使用抽象？抽象方法抽象类 多态
Java继承和多态
qq_41854911的博客
12-25 1171
文章目录本章学习要点Java类的封装例 1Java封装图书信息类Java继承（extends）简明教程例 1单继承继承的优缺点Java super关键字详解super调用父类构造方法例1例2super访问父类成员super调用成员属性super调用成员方法super和this的区别例 3Java对象类型转换：向上转型和向下转型1）向上转型2）向下转型例 1强制对象类型转换Java中为什么使用向上转型而不直接创建子类对象？例 1Java方法重载例 1Java方法重写例 1Java多态性：Java什么是多态？例
Java多态
qq_39156722的博客
06-21 132
在面向对象的程序设计语言中，多态是数据抽象和继承值后的第三种基本特征 封装通过合并特征和行为来创建新的数据类型，实现隐藏则通过将细节私有化把接口和实现分离开，而多态的作用则是消除类型之间的耦合关系。 1 再论向上转型 对象既可以作为它本身的类型使用也可以作为它的父类的类型使用。这种把某个对象的引用视为对其基类的引用的做法被称为向上转型。因为子类继承自父类，具有父类的所有方法，所以父类可以进行...
【Java SE】面向对象三大特性之多态
kim的博客
09-19 145
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。语法格式：父类类型 对象名 = new 子类类型()//支付宝父类引用子类，因为是小范围到大范围，所以可以实现向上转型向上转型的优点：让代码实现更简单灵活。向上转型的缺陷：不能调用到子类特有的方法。有向上转型肯定会有向下转型啦！向上转型会导致无法调用子类特有的方法，但是有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。}@Override。
JAVA-SE基础知识.pdf
08-18
文档包含for/while/do-while、方法、方法重载、数组、面向对象、单例、重写、多态、抽象类、内部类、异常、String、八大基本数据类型、日期、集合、文件、多线程、网络编程、反射等基础讲解笔记。
Java SE编程入门教程 java集合（共38页）.pptx
12-04
Java SE编程入门教程 java封装继承多态（共56页）.pptx Java SE编程入门教程 java集合（共38页）.pptx Java SE编程入门教程 java接口（共21页）.pptx Java SE编程入门教程 java类和对象方法以及包的使用（共56页）....
Java面试题大全.pdf
01-11
本资源主要讲解Java面试题的知识点，涵盖Java基础知识、Java语言特点、Java发展历史、Java平台无关性、Java简单性、Java解释执行、Java多线程、Java安全性等多个方面的知识点。 Java基础知识 Java是一门面向对象的...
JAVA基础知识学习零基础ppt课件.ppt
11-16
本资源主要讲解了JAVA基础知识，包括JAVA开发环境介绍、编程入门、标示符、关键字、数据类型、表达式、流程控制、数组、常用数据结构及算法、面向对象编程OOP、封装、继承、多态、异常处理等基本概念。此外，还介绍...
Java实用编程技术第章-Java语言概述及编程基础.pptx
11-17
4、高效解释执行：Java语言具有高效的解释执行机制，能够快速地执行程序。 5、健壮性：Java语言具有健壮性，能够提供可靠的编程环境。 6、安全：Java语言具有安全机制，能够保护程序和数据的安全。 7、结构中立：...
基于springboot的青年公寓服务平台源码数据库
最新发布
s123456sj的博客
06-16 468
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 564
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 340
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 802
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
java动态多态_Java动态多态原理
06-10
Java动态多态是指在运行时根据对象的实际类型来确定调用哪个方法，从而实现不同类型对象的行为差异。它是Java语言中面向对象特性的重要体现之一。 Java动态多态的实现原理主要包括两个方面： 1. 继承和重写 Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Frank1-0-2-4

我会继续努力的，十分感谢谢谢你

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

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

打赏作者

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

抵扣说明：

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

余额充值