JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例...

最新推荐文章于 2024-03-18 21:39:26 发布
最新推荐文章于 2024-03-18 21:39:26 发布
阅读量133 收藏
点赞数
文章标签： java 操作系统
原文链接：https://yq.aliyun.com/articles/316150
版权

JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例

学习是不能停止的

一.多态

我们今天又要学习一个新的概念了，就是多态，它是面向对象的第三个特征，何谓多态？

  • 定义

某一类事物的多种存在方式

  • 比如

动物中的猫狗，人类中的男人，女人

我们可以把多态理解为事物存在的多种体现形态

当我们new一个猫类的时候，和new 一个动物，其实是一样的，多种形态变现

所以我们可以分这几部分分析

    1. 多态的体现
    1. 多态的前提
  • 3.多态的好处
  • 4.多态的应用

我们定义一个需求，描述动物，正常的逻辑应该是这样描述的

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */
        Cat c = new Cat();
        c.eat();
        dog d = new dog();
        d.eat();
    }
}

/**
 * 动物
 * 
 * @author LGL
 *
 */
abstract class Animal {

    // 吃什么不确定，抽象
    abstract void eat();
}

/**
 * 猫
 * 
 * @author LGL
 *
 */
class Cat extends Animal {

    @Override
    void eat() {
        System.out.println("猫吃鱼");
    }

}

/**
 * 狗类
 * 
 * @author LGL
 *
 */
class dog extends Animal {

    @Override
    void eat() {
        System.out.println("狗吃骨头");
    }

}

这个体系我们展现出来一个为题，我们为了使用猫吃东西和狗吃东西，得new两个对象，要是多来几只小动物，我不还得new死，所以我们要想一个解决办法，他们有一个共性，就是都是动物，我们可以这样转换

Animal a = new Cat();
a.eat();

因为也是动物类型，我们输出

这里写图片描述

这就是多态在程序中的表现

  • 父类的引用指向了自己的子类对象，这就是多态的代码体现形式，人 = new 男人，换句话说，父类的引用也可以接收子类的对象，所以我们可以这样定义一个方法
//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */
        AnimalEat(new Cat());
        AnimalEat(new dog());
    }

    public static void AnimalEat(Animal a) {
        a.eat();
    }
}

这样就方便了，这样也就体现了多态的好处：

  • 多态的出现大大的提升了程序的扩展性

但是有前提的

  • 必须类与类之间有关系，要么继承，要么实现
  • 通常，还有一个前提就是存在覆盖

不过，有利有弊，还是会存在弊端的

  • 提高了扩展性，但是只能使用父类的引用访问父类的成员，这是局限性，但是我们侧重扩展性

我们再返回前面说多态的转型，我们看这段代码

//类型提升
Animal a = new Cat();  
a.eat();

我们也叫作向上转型，

如果想要调属性，该如何操作（向下转型）？

  • 强制将父类的引用转为子类类型
        Animal a = new Cat();
        a.eat();

        Cat c = (Cat)a;
        c.sleep();

这里写图片描述

也就是说，转型是强制将父类的引用，转为子类类型，向下转型。千万不要将父类对象转成子类对象，我们能转换的是父类引用指向子类对象的子类，多态自始至终都是子类对象在做着变化

那么你会了强转之后，你就说，我可以这样做

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */

        AnimalEat(new Cat());
        AnimalEat(new dog());

    }

    public static void AnimalEat(Animal a) {
        a.eat();

        Cat c = (Cat) a;
        c.sleep();
    }
}

这样是不是可以？我们看结果

这里写图片描述

这里报错了，提示的是狗类型不行转换成猫类型，的确，不能随便乱转。我们价格判断，怎么判断呢？条件语句该怎么写呢？这里我们又有一个关键字了instanceof

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */

        AnimalEat(new Cat());
        AnimalEat(new dog());

    }

    public static void AnimalEat(Animal a) {
        a.eat();

        //如果a的类型是Cat就执行
        if(a instanceof Cat){
            Cat c = (Cat) a;
            c.sleep();
        }

    }
}

这样我们加了判断之后，我们就可以知道

这里写图片描述

既然多态说了这么多，我们来看看多态的应用吧，还是以一个需求开始去分析

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：幼儿园有两个班 大班： 学习，睡觉 小班： 学习，睡觉 可以将两类事物进行抽取
         */
        SmallClass s = new SmallClass();
        s.study();
        s.sleep();

        BigClass b = new BigClass();
        b.study();
    }

}

/**
 * 学生类
 * 
 * @author LGL
 *
 */
abstract class Student {
    // 学习的内容不一样，抽象
    public abstract void study();

    // 睡觉
    public void sleep() {
        System.out.println("躺着睡");
    }
}

/**
 * 大班
 * 
 * @author LGL
 *
 */
class BigClass extends Student {

    @Override
    public void study() {
        System.out.println("学习大班知识");
    }

}

/**
 * 小班
 * 
 * @author LGL
 *
 */
class SmallClass extends Student {

    @Override
    public void study() {
        System.out.println("学习小班知识");
    }

    @Override
    public void sleep() {
        System.out.println("卧着睡");
    }

}

这个例子输出

这里写图片描述

你拿到一想，是不是根据上面的方法直接复用父类对象的引用？这里我们可以拿到一个单独的类去复用封装

/**
 * 封装工具类
 * 
 * @author LGL
 *
 */
class DoStudent {
    public void dosome(Student s) {
        s.study();
        s.sleep();
    }
}

这样我们使用

        DoStudent dos = new DoStudent();
        dos.dosome(new BigClass());
        dos.dosome(new SmallClass());

得到的结果

这里写图片描述

我们再来看下多态的代码特点，我们举个例子

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        zi z = new zi();
        z.method1();
        z.method2();
        z.method3();
    }
}

class Fu {
    void method1() {
        System.out.println("fu method1");
    }

    void method2() {
        System.out.println("fu method2");
    }
}

class zi extends Fu {
    void method1() {
        System.out.println("zi method1");
    }

    void method3() {
        System.out.println("zi method3");
    }

}

你能告诉我打印的结果吗？

这里写图片描述

我们现在用多态的思想去做

这里写图片描述

你会知道，3是引用不了的，我现在把报错的的地方注释掉，然后你能告诉我运行的结果吗

这里写图片描述

我们可以总结出特点（在多态中成员函数的特点）

  • 在编译时期。参阅引用型变量所属的类是否有调用的方法，如果由，编译通过。如果没有编译失败
  • 在运行时期，参阅对象所属的类中是否有调用的方法
  • 简单总结就是成员函数在多态调用时，编译看左边，运行看右边

我们再在子类和父类中都定义一个int值分别是5和8

我们这么输出

        Fu f = new zi();
        System.out.println(f.num);

        zi z = new zi();
        System.out.println(z.num);

输出多少呢？

这里写图片描述

这里就总结出

  • 在多态中，成员变量的特点:无论编译和运行，都参考左边（引用型变量所属）
  • 在多态中，静态成员变量的特点：无论编译和运行，都参考左边

我们把学到的应用在案例上

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard b = new MainBoard();
        b.run();
    }
}

/**
 * 主板
 * 
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

}

我们程序这样写， 无疑看出来很多弊端，我想上网，看电影，他却没有这功能，我们要怎么去做，我们重新设计程序，再增加

/**
 * 网卡
 * 
 * @author LGL
 *
 */
class NetCard {
    public void open() {
        System.out.println("打开网络");
    }

    public void close() {
        System.out.println("关闭网络");
    }
}

但是这样，还是主板的耦合性是在是太强了，不适合扩展，所以，这个程序一定不是一个好的程序我，我们重新设计，用一个标准的接口

import javax.print.attribute.standard.MediaName;

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard m = new MainBoard();
        m.run();
        // 没有设备，有设备的话之类传进去
        m.userPCI(null);

    }
}

/**
 * 扩展接口
 * 
 * @author LGL
 *
 */
interface PCI {
    public void open();

    public void close();
}

/**
 * 主板
 * 
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

    public void userPCI(PCI p) {
        if (p != null) {
            p.open();
            p.close();
        } else {
            System.out.println("没有设备");
        }

    }

}

我们现在不管增加听音乐还是上网的功能，只要实现PCI的接口，就可以实现，我们现在增加一个上网功能，该怎么做？


//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard m = new MainBoard();
        m.run();
        // 没有设备
        m.userPCI(null);

        // 有设备
        m.userPCI(new NetCard());

    }
}

/**
 * 扩展接口
 * 
 * @author LGL
 *
 */
interface PCI {
    public void open();

    public void close();
}

/**
 * 主板
 * 
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

    public void userPCI(PCI p) {
        if (p != null) {
            p.open();
            p.close();
        } else {
            System.out.println("没有设备");
        }

    }

}

/**
 * 网卡
 * 
 * @author LGL
 *
 */
class NetCard implements PCI {
    public void open() {
        System.out.println("打开网络");
    }

    public void close() {
        System.out.println("关闭网络");
    }
}

这样我们运行

这里写图片描述

现在的主板是不是扩展性特别强，这就是多态的扩展性

OK,我们本节的篇幅就先到这里，如果感兴趣的话，可以加群：555974449

weixin_34265814
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多态的应用
03-05
此代码通过一个实例详细描述了多态的实现过程
java多态性，instanceof及Object类
ttwwok的专栏
10-30 2718
注意：粉红色为个人理解，其他为原作者的表述 多态是一个之前一直搞不清楚的概念,通过这次笔记,对多态的概念及应用有了较全面的认识,同时学习了instanceof关键字以及Object类的特点. 1. Java中类的多态       所谓类的多态性,是指子类对象和父类对象之间的相互转换. 这里分为两部分做笔记:     1.1 子类对象向父类对象转换(向上转换)
instanceof详细介绍和使用，实际项目中的使用案例
a704397849的博客
04-26 2948
instanceof 用来判断指定 对象(实际引用的对象实例) 是否是 指定类或者指定类的子类 的实例 用法 boolean result = object instanceof class object:必选项。任意 对象 表达式。 class:必选项。任意 对象类。 如果object 是 null，则返回 false 如果object实际引用的对象实例 是 class 的实例对象 ...
Java 多态
qq_45566079的博客
10-03 200
1.1 多态的概述 定义： 是指同一行为，具有多个不同表现形式。 多态的前提 要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象 1.2 多态的体现 多态体现的格式： 父类类型 变量名 = new 子类对象； 变量名.方法名(); 父类类型：指子类对象继承的父类类型，或者实现的父接口类型。代码如下： Fu f = new Zi(); f.method(); 1.3 多态中的成员访问特点 成员访问特点 成员变量 编译看父类，运行看父类 成员方法 编译看父类，运行看子类 代码演示
多态的主要应用
qq108455的博客
06-18 2669
在Java中，多态的主要应用体现在两个方面：多态参数和异构集合。下面我们分别以示例详细说明。 1）多态参数 所谓多态参数，就是当方法的某个形式参数是一个引用的时候，与该引用兼容的任何对象都可以传递给方法，从而允许方法接受不同数据类型的形式参数。 异构集合 多态最常见的应用是创建一个不是同一类型，但是有共同父类的数据集合。不同对象的集合称为异构集合。 多态总结 从以上示例，我们可以看出：父类类型的引...
java基础——方法的重写、多态+instanceof（csdn）————程序.pdf
12-01
在Java编程语言中，方法的重写和多态是面向对象设计的重要概念，它们使得代码更加灵活和可扩展。下面将详细阐述这两个概念及其应用场景。 首先，方法的重写（Override）是指在一个子类中定义与父类相同名称和参数...
java-接口的使用,多态的使用,instanceof关键字,笔记本usb接口案例
12-21
在Java编程语言中，接口（Interface）是一种非常重要的概念，它定义了一组抽象方法和常量，用于规范类的行为和属性。接口就像一个契约，它规定了任何实现该接口的类必须遵循的规则。接口的使用有助于实现多态性，即...
一篇文章快速了解Java中的继承与多态
12-21
在Java中，多态主要体现在方法的动态绑定上，即运行时根据实际对象类型调用相应的方法。多态的两个关键点是： - **动态绑定**：编译时无法确定具体调用哪个方法，要在运行时根据对象的实际类型决定。 - **对象转换*...
Java基础精品课11-多态录屏6.instanceof和转型.mp4
05-20
Java基础精品课11-多态录屏6.instanceof和转型.mp4
简单了解Java中多态的基础知识
08-25
Java中的多态基础知识 在 Java 编程语言中，多态是指同一个方法名可以具有不同的实现，这取决于对象的类型和方法参数。多态使得 Java 语言具有更加灵活和强大的功能。本文将详细介绍 Java 中多态的基础知识，包括...
C++学习——多态的应用
weixin_63586719的博客
08-08 205
多态是指同一个方法可以根据上下文的不同而表现出不同的行为。多态性使得可以使用统一的接口来处理不同类型的对象，而无需关注对象的具体类型。多态可以通过虚函数（Virtual Function）来实现，在运行时动态确定使用哪个函数版本。
超详细带你了解Java中的多态
小新的博客
05-09 3781
1.多态 文章目录1.多态多态概述虚函数重写多态的实现方式方式一：重写：方法的重写规则方式二：接口方式三：抽象类和抽象方法4.多态的转型6. instanceof关键字 多态概述 简单概述：同一个对象，在不同时刻表现出来的不同形态 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。 因为在程序运行时才确定具体的类，
Java中的多态
kk1kk2kk3kk4的博客
11-30 468
多态是什么？ 多态是同一个行为具有不同的表现形式或形态的能力 同一方法可以根据发送对象的不同而采用不同的行为方式 例如：打印机分为黑白打印机和彩色打印机，在黑白打印机情况下打出来为黑白，在彩色打印机情况下打印出来为彩色
多态的理解与应用
weixin_51833103的博客
11-29 1180
多态概述 面向对象的三大特性 多态（父类引用变量可以指向子类对象。让程序提前不知道自己到底调用的是哪个方法，只有当他运行的时候才确定，这样不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现）让程序可以选择多个运行状态 封装（隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法） 继承（为了重用父类代码。两个类若存在IS-A的关系就可以使用继承） 多态的使用条件和继承一样，必须有父类和子类，在使用多态后的父类引
Java中的多态（一万字详解）
林二月的博客
07-06 236
【代码】Java中的多态（一万字详解）
多态的概述
weixin_45750619的博客
05-22 207
多态就是同一个对象，在不同时刻表现出来的不同形态。 多态的前提和体现： 1、有继承/实现关系 2、有方法重写 3、有父类引用指向子类对象 多态中成员访问特点： 成员变量访问父类，成员方法访问子类 因为成员方法有重写，而成员变量没有。 多态的好处和弊端 好处：提高了程序的扩展性。体现在定义方法的时候，使用父类作为参数，将来在使用的时候，使用具体的子类型参与操作。 弊端：不能使用子类的特用功能。 ...
多态的应用（包含具体实例）
最新发布
qq_48854032的博客
03-18 1737
什么是多态，多态怎么使用？这篇文章详细介绍了多态，并且给了具体例子让大家灵活运用多态
java面向对象的三大特性
later_You的博客
08-28 205
Java面向对象的封装，继承，多态！ ** 封装 **：是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。 1 ** 继承 **：继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。 1 Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值