java中多态的理解

最新推荐文章于 2024-06-25 05:03:58 发布
最新推荐文章于 2024-06-25 05:03:58 发布
阅读量155 收藏
点赞数
文章标签： 多态 java 接口 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42211758/article/details/114695247
版权

多态是继封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义
  • 多态： 是指同一行为，对于不同的对象具有多个不同表现形式。
  • 程序中多态: 是指同一方法,对于不同的对象具有不同的实现.
前提条件【重点】
  1. 继承或者实现【二选一】
  2. 父类引用指向子类对象【格式体现】
  3. 方法的重写【意义体现：不重写，无意义】

小结:

  • 多态： 是指同一行为，对于不同的对象具有多个不同表现形式。
  • 条件:
    • 继承或者实现
    • 父类引用指向子类的对象
    • 方法的重写

知识点-- 实现多态

目标:

  • 如何实现多态

路径:

  • 多态的实现

讲解:

多态的体现：父类的引用指向它的子类的对象：

父类类型 变量名 = new 子类对象；
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

  • 多态实现方式一:通过继承类
abstract class Animal{
    public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头...");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
    }
}
public class Test1 {
    public static void main(String[] args) {
        // 父类的引用指向子类的对象
        Animal anl = new Dog();
        anl.eat();// 狗吃骨头...

        anl = new Cat();
        anl.eat();// 猫吃鱼...


    }
}
  • 多态实现方式二:通过实现接口
interface A{
    void method();
}
class Imp implements A{

    @Override
    public void method() {
        System.out.println("重写method");
    }
}
public class Test2 {
    public static void main(String[] args) {
        // 父接口的引用指向实现类的对象
        A a = new Imp();
        a.method();
    }
}

小结:

  • 继承或者实现
  • 父类的引用指向子类的对象
  • 方法的重写

知识点-- 多态时访问成员的特点

目标

  • 掌握多态时访问成员的特点

路径:

  • 多态时成员变量的访问特点
  • 多态时成员方法的访问特点

讲解:

  • 多态时成员变量的访问特点
    • 编译看左边,运行看左边
      • 简而言之:多态的情况下,访问的是父类的成员变量
  • 多态时成员方法的访问特点
    • 非静态方法:编译看左边,运行看右边
      • 简而言之:编译的时候去父类中查找方法,运行的时候去子类中查找方法来执行
    • 静态方法:编译看左边,运行看左边
      • 简而言之:编译的时候去父类中查找方法,运行的时候去父类中查找方法来执行
  • 注意:多态的情况下是无法访问子类独有的方法
  • 演示代码:
class Fu{
    int num = 10;
    // 非静态方法
    public void method1(){
        System.out.println("Fu 非静态方法method1");
    }
    // 静态方法
    public static void method2(){
        System.out.println("Fu 静态方法method2");
    }
}
class Zi extends Fu{
    int num = 20;
    // 非静态方法
    @Override
    public void method1(){
        System.out.println("Zi 非静态方法method1");
    }
    // 静态方法
    public static void method2(){
        System.out.println("Zi 静态方法method2");
    }
}
public class Test {
    public static void main(String[] args) {
        /*
            多态时访问成员的特点:
                成员变量:编译看父类,运行看父类(编译看左边,运行看左边)
                成员方法:
                    非静态方法: 编译看父类,运行看子类(编译看左边,运行看右边)
                    静态方法:   编译看父类,运行看父类(编译看左边,运行看左边)
                记忆:
                    除了非静态方法,编译看父类,运行看子类,其余都是看父类
         */
        // 父类的引用指向子类的对象
        Fu f = new Zi();
        System.out.println(f.num);// 10
        f.method1();
        f.method2();
    }
}

小结:

  • 除了非静态方法,编译看父类,运行看子类,其余都是看父类

知识点-- 多态的几种表现形式

目标:

  • 多态的几种表现形式

路径:

  • 普通父类多态
  • 抽象父类多态
  • 父接口多态

讲解:

  • 多态的表现形式:

    • 普通父类多态
class Fu{}
class Zi extends Fu{}
public class Test {
    public static void main(String[] args) {
        Fu f = new Zi();
    }
}
  • 抽象父类多态
abstract class Fu{}
class Zi extends Fu{}
public class Test {
    public static void main(String[] args) {
        Fu f = new Zi();
    }
}
  • 父接口多态
interface A{}
class Imp implements A{}
public class Test {
    public static void main(String[] args) {
        A a = new Imp();
    }
}

知识点-- 多态的应用场景:

目标:

  • 掌握多态在开发中的应用场景

路径:

  • 变量多态 -----> 意义不大
  • 形参多态----> 常用
  • 返回值多态—> 常用

讲解:

多态的几种应用场景:

  • 变量多态
class Fu{}
class Zi extends Fu{}

public class Test {
    public static void main(String[] args) {
        // 变量多态---一般不使用,意义不大,除非用来检验调用父类的方法
        Fu f = new Zi();
    }
}

  • 形参多态

  • 参数的类型为父类类型,就可以传入该父类类型的对象,或者该父类类型的所有子类对象

abstract class Animal{
    public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
//.... 很多的子类.....

public class Test {
    public static void main(String[] args) {
        // 形参多态---- 必须掌握
        Dog d = new Dog();
        method(d);

        System.out.println("==============================");
        Cat c = new Cat();
        method(c);
    }
    // 定义一个方法,既可以接收Dog类的对象,又可以接收Cat类的对象(也就是说要能接收Animal类的所有对象)
    // 结论: 参数的类型为父类类型,就可以传入该父类类型的对象,或者该父类类型的所有子类对象
    public static void method(Animal anl){
        anl.eat();
    }

   /* public static void method(Dog d){
        d.eat();
    }
    public static void method(Cat c){
        c.eat();
    }*/
    //....
}

  • 返回值多态

  • 如果方法的返回值类型为父类类型,那么就可以返回该父类对象,或者该父类的所有子类对象

abstract class Animal{
    public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal anl1 = method(1);// 返回狗类对象
        Animal anl2 = method(3);// 返回猫类对象
    }

    // 结论:如果方法的返回值类型为父类类型,那么就可以返回该父类对象,或者该父类的所有子类对象
    public static Animal method(int num){
        if (num == 3){
            // 返回猫
            Cat c = new Cat();
            return c;
        }else {
            // 返回狗
            Dog d = new Dog();
            return d;
        }
    }
}

小结:

  • 如果参数的类型为父类类型,name就可以传入该父类类型的对象,或者该父类类型的所有子类对象
  • 如果方法的返回值类型为父类类型,那么就可以返回该父类类型的对象,或者该父类的所有子类对象

知识点-- 多态的好处和弊端

目标:

  • 实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。但有好处也有弊端

步骤:

  • 多态的好处和弊端

讲解:

  • 好处
    • 提高了代码的扩展性
  • 弊端
    • 多态的情况下，只能调用父类的共性内容，不能调用子类的特有内容。
  • 示例代码
// 父类
public abstract class Animal {  
    public abstract void eat();  
}  
// 子类
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void catchMouse(){
         System.out.println("猫抓老鼠");  
    }
}  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
}

定义测试类：

abstract class Animal{
    public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookHome(){
        System.out.println("狗看家...");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠...");
    }
}
public class Test1 {
    public static void main(String[] args) {
        /*
            - 好处
              - 提高了代码的扩展性
            - 弊端
              - 多态的情况下，只能调用父类的共性内容，不能调用子类的特有内容。
         */
        Dog d = new Dog();
        method(d);

        System.out.println("=========================");

        Cat c = new Cat();
        method(c);
    }

    public static void method(Animal anl){
        anl.eat();
        //anl.lookHome();// 编译报错,因为多态的成员访问特点:编译看父类,父类中没有,就报错
        //anl.catchMouse();// 编译报错,因为多态的成员访问特点:编译看父类,父类中没有,就报错

    }
}

知识点-- 引用类型转换

目标:

  • 向上转型与向下转型,instanceof关键字

步骤:

  • 向上转型
  • 向下转型
  • instanceof关键字

讲解:

向上转型
  • 子类类型向父类类型向上转换的过程，这个过程是默认的。
 Aniaml anl = new Cat();
向下转型
  • 父类类型向子类类型向下转换的过程，这个过程是强制的。
 Aniaml anl = new Cat();  
 Cat c = (Cat)anl;//向下转型
 c.catchMouse();// 可以访问 子类独有的功能,解决多态的弊端
instanceof关键字

  • 向下强转有风险，最好在转换前做一个验证 :

  • 格式:

变量名 instanceof 数据类型 
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

if( anl instanceof Cat){//判断anl是否能转换为Cat类型，如果可以返回：true，否则返回：false
    Cat c = (Cat)anl;//安全转换
}

class Animal{
    public  void eat(){}
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    // 看家
    public void lookHome(){
        System.out.println("狗看家...");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    // 抓老鼠
    public void catchMouse(){
        System.out.println("猫抓老鼠...");
    }
}
public class Test {
    public static void main(String[] args) {
        /*
            引用类型转换:
                向上转型: 子类类型向父类类型向上转换的过程，这个过程是默认的。
                向下转型: 父类类型向子类类型向下转换的过程，这个过程是强制的。
                         格式: 子类类型 变量名 = (子类类型)父类类型的变量;
                         注意: 右边只能是父类类型的变量,并且该变量指向的是要转换的子类类型的对象

                规范: 为了保证转型不出问题,一般转型之前需要进行类型判断----instanceof关键字
                    格式:
                        if(变量名 instanceof 数据类型){

                        }
                    如果变量指向的对象是属于后面的数据类型，返回true。
                    如果变量指向的对象不属于后面的数据类型，返回false。

         */
        // 向上转型
        Animal anl = new Dog();

        // 向下转型
        //Animal a = new Animal();
        //Dog d = (Dog)a;// 运行报错 ClassCastException类型转换异常

        //Dog d = (Dog)anl;// 没有问题
        //Cat c = (Cat)anl;// 运行报错 ClassCastException类型转换异常

        System.out.println("============================================");
        if (anl instanceof Dog){
            Dog d = (Dog)anl;
            d.eat();
            d.lookHome();
        }
    }
}

解决多态的弊端

abstract class Animal{
    public abstract void eat();
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookHome(){
        System.out.println("狗看家...");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠...");
    }
}

public class Test1 {
    public static void main(String[] args) {
        /*
            - 好处
              - 提高了代码的扩展性
            - 弊端
              - 多态的情况下，只能调用父类的共性内容，不能调用子类的特有内容。
         */
        Dog d = new Dog();
        method(d);

        System.out.println("=========================");

        Cat c = new Cat();
        method(c);
    }

    public static void method(Animal anl){
        anl.eat();
        // 判断anl指向的是否是Dog对象
        if (anl instanceof Dog){
            Dog d = (Dog)anl;
            d.lookHome();
        }
        // 判断anl指向的是否是Cat对象
        if (anl instanceof Cat){
            Cat c = (Cat)anl;
            c.catchMouse();
        }
    }
}
想胖不能胖的伤痛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
对java中多态理解
09-03
对 Java 中多态理解 Java 中的多态是指在不同的情况下可以有不同的行为，多态是面向对象编程的一种基本特征。多态的实现是通过方法重载和方法重写来实现的。 在 Java 中，多态可以分为两种：编译时多态和运行时...
深入理解重写、隐藏、和静、动态绑定的本质
从左到右
11-12 616
深入理解重写、隐藏、和静、动态绑定的本质 文章目录问题引入重写隐藏动态绑定通俗理解静态绑定总结总结 问题引入 大家都知道成员方法能被继承和重写，那么静态变量或者静态方法能否被子类继承？能否被重写？ 于是写了一段代码先验证下： //定义父类 public class SuperClass { static int SuperVar = 10; public static void method(){ System.out.println("this SuperClass");
Java多态的认识和理解
m0_64742984的博客
04-30 2099
多态是面向对象程序设计的三大特征之一，面向对象的三大特征：封装、继承、多态。 封装给对象提供了隐藏内部特性和行为的能力，保护对象内部的状态，提高了代码的可用性和可维护性。 继承关系使一个子类能继承父类的特征，而不需要再次编写相同的代码，并且附加一些新特征。子类是它的父类的特殊化，每个子类的实例都是其父类的实例。 概念 同一个行为具有多个不同表现形式或形态的能力，指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。 理解 多态是同一个...
什么是Java中的多态？看这一篇就够了
最新发布
yang_love1011的博客
06-25 2305
多态是指同一个方法在不同对象上具有不同的行为。通过多态，程序可以在运行时决定调用哪个方法，从而提高代码的灵活性和可扩展性。多态是Java中一个重要且强大的特性，它允许在运行时根据对象的实际类型调用相应的方法，从而提高代码的灵活性和可扩展性。通过方法重载、方法重写、接口和抽象类，可以实现多态，并在实际开发中广泛应用于代码复用、接口回调和工厂模式等场景。希望本文能帮助您更好地理解和应用Java中的多态。如果您有任何问题或建议，欢迎留言讨论。
【Java】多态的含义、多态的作用及多态的详细代码实现
m0_64210833的博客
03-17 5788
1.多态的含义 什么是多态，就是一个事物有多种形态，比如说是老师是老师，他也是人，也是丈夫或者妻子，或者光棍儿，这就阐述了多种形态。
超详细带你了解Java中的多态
小新的博客
05-09 3788
1.多态 文章目录1.多态多态概述虚函数重写多态的实现方式方式一：重写：方法的重写规则方式二：接口方式三：抽象类和抽象方法4.多态的转型6. instanceof关键字 多态概述 简单概述：同一个对象，在不同时刻表现出来的不同形态 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。 因为在程序运行时才确定具体的类，
Java多态理解
m0_58505748的博客
12-17 465
1.多态的定义 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。 总的来说：
java多态理解
12-17
Java多态理解 java中的多态性是面向对象编程的精髓所在。多态性是指父类引用指向子类对象，例如父类Animal，子类Cat和Dog。其中Animal可以是类也可以是接口，Cat和Dog是继承或实现Animal的子类。Animal animal = ...
进一步理解Java中的多态概念
09-03
这是Java中最常见的多态形式，通常由方法覆盖（Overriding）实现。当子类继承父类并重写了父类的方法，如果有一个父类类型的引用指向子类对象，那么通过这个引用调用的方法将会是子类重写后的方法，这就是运行时多态...
Java 继承与多态的深入理解
08-29
"Java 继承与多态的深入理解" 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为，使得子类具有父类的各种属性和方法。继承的特点是：在继承关系中，父类更通用、子类更具体。父类和子类需要满足is-...
java中多态概念、实现原理详解
08-30
在Java中，多态的实现依赖于动态绑定（也称为晚期绑定或运行时绑定）。这意味着在编译时，我们只知道调用了父类的某个方法，但在运行时，实际调用的是哪个方法取决于对象的实际类型。因此，如果子类重写了父类的方法...
java面对对象-多态
weixin_30462049的博客
09-27 537
什么是多态 1.面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。 2.多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用） 3.实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对...
Java多态的理解
qq_45062696的博客
09-28 183
什么是多态？ 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 多态的实现原理 有2种方式来实现多态，一种是静多态即编译时多态，由编译时期决定，另外一种是动多态即运行时多态，是说运行时期才知道调用哪种方法。 编译时多态是通过方法的重载来实现的，运行时多态是通过方法的重写来实现的。...
Java中的多态如何理解——详解
weixin_50635856的博客
05-01 8014
🎈🎈🎈本篇文章我们主要讲解的是Java中的多态，那么什么是多态呢？同类型的对象，执行同一个行为，会表现出不同的行为特征。接下来让我们一起对多态进行详细地讲解。
Java基础（多态的理解与应用)
热门推荐
冰月灵狐
05-25 17万+
1.多态概述 多态是继封装、继承之后，面向对象的第三大特性。 多态现实意义理解： 现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。...
Java多态详解
m0_67599274的博客
04-28 3万+
目录1. 基本介绍1.1 多态的概念1.2 对象的多态1.3 入门案例2. 具体细节2.1 向上转型2.2 向下转型2.3 instanceOf 比较操作符3. 实现技术：动态绑定4. 应用4.1 多态数组4.2 多态参数5. 多态的优点 1. 基本介绍 1.1 多态的概念 多态是继封装、继承之后，面向对象的第三大特性。 多态体现为父类引用变量可以指向具体的子类对象。 1.2 对象的多态 1.3 入门案例 2. 具体细节 2.1 向上转型 2.2 向下转型 2.3 instanceOf 比较操作符 3. 实
如何理解java中的多态？
weixin_45755718的博客
04-03 548
多态：顾名思义, 就是 “一个引用, 能表现出多种不同形态”。 Java实现多态有三个必要条件： 1.继承：在多态中必须存在有继承关系的子类和父类。 2.重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。 3.向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。 接下来，我们用一段代码来更清楚直接的理解什么是多态 比如，...
Java多态的知识总结（超详细）
weixin_56433857的博客
03-30 2633
Java中的多态（polymorphism）是指同一个类型的对象，在不同的情况下会表现出不同的行为。
探索Java中的多态
梦想家星空的博客
06-24 371
多态是指同一个方法在不同对象上具有不同的行为。通过多态，程序可以在运行时决定调用哪个方法，从而提高代码的灵活性和可扩展性。多态是Java中一个重要且强大的特性，它允许在运行时根据对象的实际类型调用相应的方法，从而提高代码的灵活性和可扩展性。通过方法重载、方法重写、接口和抽象类，可以实现多态，并在实际开发中广泛应用于代码复用、接口回调和工厂模式等场景。希望本文能帮助您更好地理解和应用Java中的多态。如果您有任何问题或建议，欢迎留言讨论。
Java中多态的理解
07-28
多态是面向对象编程中的一个重要概念，它允许不同的对象以自己的方式对相同的消息作出响应。在Java中，多态性是通过继承和方法重写来实现的。 具体来说，当一个父类引用指向一个子类对象时，就发生了多态。通过父类引用调用的方法可以根据实际引用对象的类型而具有不同的行为。这样可以实现代码的灵活性和可扩展性。 例如，假设有一个动物类 Animal 和它的子类 Dog 和 Cat。这些类都有一个公共的方法叫做 makeSound()，但是每个子类会以自己特有的声音来实现这个方法。当我们使用多态时，可以将 Dog 或 Cat 对象赋给 Animal 类型的引用，然后通过这个引用调用 makeSound() 方法，最终会根据引用所指向的对象的实际类型来执行相应的方法。 多态的优势在于增强了代码的灵活性和可维护性。我们可以通过添加新的子类来扩展功能，而不需要修改现有的代码。此外，多态还可以使代码更加通用和可复用。 总结起来，Java中的多态是通过继承和方法重写实现的，它允许不同的对象以自己的方式对相同的消息作出响应，提高了代码的灵活性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值