面向对象的多态

这篇具有很好参考价值的文章主要介绍了面向对象的多态。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

7. 面向对象特征三:多态性

概念:
多态是面向对象程序设计(OOP)的一个重要特征,指同一个实体同时具有多种形式,

女朋友养宠物
王者荣耀英雄

面向对象的多态

7.1 多态的形式和体现

7.1.1 对象的多态性
多态性,是面向对象中最重要的概念,
在 Java 中如何体现的:对象的多态性:父类的引用指向子类的对象
格式:父类 变量名 = new 子类;( Father a = new Son(); )

2 . 特点
多态的前提1:是继承
多态的前提2:要有方法的重写

练习:多态入门案例
创建包: cn.tedu.oop
创建类: TestDemo.java

package cn.tedu.oop2;
/*本类用作多态的入门案例*/
public class TestDemo {
    public static void main(String[] args) {
        //6.创建“纯纯的”对象用于测试
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        a.eat();//小动物Animal吃啥都行~调用的是父类自己的功能
        c.eat();//小猫爱吃小鱼干~调用的是子类重写后的功能
        d.eat();//小狗爱吃肉骨头~调用的是子类重写后的功能
        /*2.父类对象不可以使用子类的特有功能*/
        //a.jump();//报错,Animal类里并没有这个方法
        //a.run();//报错,Animal类里并没有这个方法
        c.jump();//小猫Cat跳的老高啦~,子类可以调用自己的功能
        d.run();//小狗Dog跑的老快啦~,子类可以调用自己的功能

        //7.创建多态对象进行测试
        /*3.口诀1:父类引用指向子类对象
        * 解释:创建出来的子类对象的地址值,交给父类类型的引用类型变量来保存*/
        Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
        Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
        //8.测试多态对象
        /*4.口诀2:编译看左边,运行看右边
        * 解释:必须要在父类定义这个方法,才能通过编译,把多态对象看作是父类类型
        *      必须要在子类重写这个方法,才能满足多态,实际干活的是子类*/
        a2.eat();//小猫爱吃小鱼干~,多态对象使用的是父类的定义,子类的方法体
    }
}
/*1.多态的前提:继承+重写*/
//1.创建父类
class Animal{
    //3.创建父类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }
}
//2.1创建子类1
class Cat extends Animal{
    //4.1添加重写的方法
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    //5.1添加子类的特有功能
    public void jump(){
        System.out.println("小猫Cat跳的老高啦~");
    }
}
//2.2创建子类2
class Dog extends Animal{
    //4.2添加重写的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉骨头~");
    }
    //5.2添加子类的特有功能
    public void run(){
        System.out.println("小狗Dog跑的老快啦~");
    }
}

父类引用指向子类对象,如:Animal a = new Cat();
多态中,编译看左边,运行看右边
面向对象的多态

6. 练习:多态成员使用测试

创建包: cn.tedu.oop
创建类: TestDemo2.java

package cn.tedu.oop2;
/*本类用于测试多态成员的使用情况*/
public class TestDemo2 {
    public static void main(String[] args) {
        //7.创建纯纯的子类对象
        Dog2 d = new Dog2();
        System.out.println(d.sum);//20,子类自己的属性
        d.eat();//小狗爱吃肉包子,子类自己的方法

        //8.创建多态对象
        /*口诀1:父类引用指向子类对象*/
        /*口诀2:编译(保存)看左边,运行(效果)看右边*/
        Animal2 a = new Dog2();
        /*多态中,成员变量使用的是父类的*/
        System.out.println(a.sum);//10
        /*多态中,方法的声明使用的是父类的,方法体使用的是子类的*/
        a.eat();//小狗爱吃肉包子
        /*多态中,调用的静态方法是父类的,因为多态对象把自己看作是父类类型
        * 直接使用父类中的静态资源*/
        a.play();//没有提示,玩啥都行~
        Animal2.play();

     //但是多态不能调用子类的方法和属性(后面的向下转型会讲)
    }
}
//1.创建父类
class Animal2{
    //3.创建父类的成员变量
    int sum = 10;
    //4.创建父类的普通方法
    public void eat(){
        System.out.println("吃啥都行~");
    }
    //9.1定义父类的静态方法play
    public static void play(){
        System.out.println("玩啥都行~");
    }
}
//2.创建子类
class Dog2 extends Animal2{
    //5.定义子类的成员变量
    int sum = 20;
    //6.重写父类的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉包子");
    }
    //9.2创建子类的静态方法play
    //@Override
    /*这不是一个重写的方法,只是恰巧在两个类中出现了一模一样的两个静态方法
    * 静态方法属于类资源,只有一份,不存在重写的现象
    * 在哪个类里定义,就作为哪个类的资源使用*/
    public static void play(){
        System.out.println("小狗喜欢玩皮球~");
    }
}

7 拓展 (选讲)
7.1 设计汽车综合案例
创建包: cn.tedu.oopexec
创建类: DesignCar.java



package cn.tedu.oop2;
/*本类用于完成汽车设计案例*/
public class DesignCar {
    public static void main(String[] args) {
        //9.创建一个纯纯的父类对象进行测试
        Car c = new Car();
        System.out.println(c.getColor());//null
        c.start();
        c.stop();
        //c.swim();//报错,父类对象不可以调用子类的特有功能

        //10.创建纯纯的子类对象做测试
        BMW b = new BMW();
        System.out.println(b.color);//五彩斑斓的黑
        System.out.println(b.getColor());//null
        b.start();//都让开,我的车要起飞啦~
        b.stop();//唉呀妈呀熄火了~

        //11.创建多态对象进行测试
        Car c2 = new TSL();
        //System.out.println(c2.color);
        System.out.println(c2.getColor());
        c2.stop();
        c2.start();
        //c2.swim();
    }
}
//1.通过分析,抽象形成一个汽车类
class Car{
    //2.定义并封装汽车类的属性--成员变量
    private String brand;//品牌
    private String color;//颜色
    private int id;//编号
    private double price;//价格

    //3.定义功能
    public void start(){
        System.out.println("我的小车车启动啦~");
    }
    public void stop(){
        System.out.println("唉呀妈呀熄火了~");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

//4.创建子类
class BMW extends Car{
    String color = "五彩斑斓的黑";
    //5.重写父类的方法
    @Override
    public void start(){
        System.out.println("都让开,我的车要起飞啦~");
    }
}
//6.创建子类2
class TSL extends Car{
    //7.重写父类的方法
    @Override
    public void stop(){
        System.out.println("唉呀妈,怎么停不下来呢");
    }
    //8.添加子类的特有功能
    public void swim(){
        System.out.println("没想到吧,我还是个潜水艇");
    }
}

7.2 多态为了统一调用标准 (选讲)

package cn.tedu.oop2;

public class TestFruit {
    public static void main(String[] args) {
        Fruit f = new Fruit();
        Apple a = new Apple();
        Orange o = new Orange();
        get(f);
        get(a);
        get(o);
    }
    //只需要创建一个方法,就可以执行截然不同的效果
    //忽略子类对象的差异统一看作父类类型
    public static void get(Fruit f){
        f.clean();
    }
}
class Fruit{
    public void clean(){
        System.out.println("水果要洗洗再吃");
    }
}
class Apple extends Fruit{
    @Override
    public void clean(){
        System.out.println("苹果需要削皮");
    }
}
class Orange extends Fruit{
    @Override
    public void clean(){
        System.out.println("橙子需要剥皮");
    }
}

多态的好处和弊端

好处:变量引用的子类对象不同,执行的方法就不同,实现动态绑定。代码编
写更灵活、功能更强大,可维护性和扩展性更好了。

弊端:一个引用类型变量如果声明为父类的类型,但实际引用的是子类对象,
那么该变量就不能再访问子类中添加的属性和方法。

向上转型与向下转型

在JAVA中,继承是一个重要的特征,通过extends关键字,子类可以复用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法来加以扩展。
那么在这个过程中就存在着多态的应用。存在着两种转型方式,分别是:向上转型和向下转型。
向上转型:可以把不同的子类对象都当作父类来看,
比如:父类Parent,子类Child
父类的引用指向子类对象:Parent p=new Child();

说明:向上转型时,子类对象当成父类对象,
比如:花木兰替父从军,大家都把花木兰看做她爸,但是实际从军的是花木兰,而且,花木兰只能做她爸能做的事,在军营里是不可以化妆的。

向下转型(较少):子类的引用的指向子类对象,过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能,所以需要重新恢复成子类对象
Parent p = new Child();//向上转型,
此时,p是Parent类型Child c = (Child)p;//此时,把Parent类型的p转成小类型Child

比如:花木兰打仗结束,就不需要再看做是她爸了,就可以”对镜贴花黄”了

7.6.2 如何向上或向下转型 (选讲)
向上转型:自动完成
向下转型:(子类类型)父类变量
instanceof的使用:关键字进行与类型的判断,就是检测向下转型是否成功

package com.cy;

public class Test1 {
    public static void main(String[] args) {

        Fruit fruit=new Apple();
        fruit.eat();
        //fruit.p();报错,不能使用子类的功能

        //我们通过向下转型就可以使用子类的功能
        //向下转型
        Apple apple=(Apple) fruit;

        System.out.println(apple.sex);
        apple.p();

        /**
         * instancof的测试
         * 一个父类可以有多个子类,
         * 但是当我们使用向下转型指向第二个子类的时候
         * 会报错,那么这个时候就需要使用instancof检测是否转型成功
         */

        //使用bana类测试向下转型


        /**
         * 这里之所以运行会报错是因为,开辟空间的时候只开辟了
         * apple类的内存空间,但是在这里却要指向bana类所以报错类
         *
         * 由于fruit对象是由Fruit类创建完成的,向下转型是只能转换成Fruit类型
         * */
        //Bana bana=(Bana) fruit;
        // bana.eat();//这个时候会报错


        /** 为了解决这样的一个错误我们使用一个instanceof关键字进行与类型的判断
         *
         * 父类对象 instanceof 子类类型,如果成立则为true 否则为false
         * 为了确保转型成功我们先进行变量的验证
         * */

        if (fruit instanceof Fruit){

            Fruit fruit1=(Fruit)fruit;
            fruit1.eat();
        }

        if (fruit instanceof Bana){
            Bana bana1=(Bana)fruit;
            bana1.c();
        }else {
            System.out.println("转型失败");
        }
    }
}
class Fruit{

    String name="水果";
    int age=33;
    public void eat(){
        System.out.println("水果要洗洗再吃");
    }
}
class Apple extends Fruit{

    String sex="男";
    public  void p(){

        System.out.println("这是一个玩耍的方法");
    }
}
class  Bana extends Fruit{

    String color="黄色";
    public void c(){
        System.out.println("这是一个颜色方法");
    }
}

执行结果

面向对象的多态

结果执行,当走到第一个if条件语句,检测转型成功执行方法,当走到第二个if条件语句转型失败,输出“转型失败”;

面向对象的多态文章来源地址https://www.toymoban.com/news/detail-481902.html

到了这里,关于面向对象的多态的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 实训7:虚函数与多态性

    参考代码 by 小喾苦 答案仅供参考! 实验目的 掌握运算符重载的方法; 实验任务 参考实验指导书第八章的实验任务 1。 实验步骤 参考实验指导书第八章的实验步骤 1。 测试说明 平台会对你编写的代码进行测试: 输入描述:空格隔开的两个整数x和y,表示一个坐标 输出描述

    2024年02月07日
    浏览(42)
  • Android java基础_多态性

    向上转换:只能定义被子类覆写的方法,不能调用在子类中定义的方法。 运行结果: JAVA向下转换的例子,在进行对象的向下转换前,必须首先发生对象的向上转换.否则会编译不过 运行结果: 看一下,下面的例子,假如有一千个类继承了father这个类,如果我们要打印他们的信

    2024年02月22日
    浏览(40)
  • C# 类class、继承、多态性、运算符重载,相关练习题

    34.函数重载 35.几个相同的函数  print() ,用于打印不同的数据类型。   36.基类和派生类   37.基类的初始化   38.多重继承   39.动态多态性   40.抽象性和虚方法   41.通过虚方法 area() 来计算不同形状图像的面积   42.运算符重载的实现   @www.runoob.com 

    2024年02月09日
    浏览(43)
  • 【C++入门到精通】C++入门 —— 继承(基类、派生类和多态性)

    前面我们讲了C语言的基础知识,也了解了一些数据结构,并且讲了有关C++的命名空间的一些知识点以及关于C++的缺省参数、函数重载,引用 和 内联函数也认识了什么是类和对象以及怎么去new一个 ‘对象’ ,也了解了C++中的模版,以及学习了几个STL的结构也相信大家都掌握

    2024年02月11日
    浏览(46)
  • 【期末不挂科-C++考前速过系列P5】大二C++实验作业-多态性(3道代码题)【解析,注释】

    前言 大家好吖,欢迎来到 YY 滴C++考前速过系列 ,热烈欢迎! 本章主要内容面向接触过C++的老铁 主要内容含: 欢迎订阅 YY 滴C++专栏!更多干货持续更新!以下是传送门! YY的《C++》专栏 YY的《C++11》专栏 YY的《Linux》专栏 YY的《数据结构》专栏 YY的《C语言基础》专栏 YY的《

    2024年01月25日
    浏览(52)
  • 面向对象详解,面向对象的三大特征:封装、继承、多态

    一、面向对象与面向过程 面向对象编程 (Object-Oriented Programming,简称OOP)和 面向过程编程 (Procedural Programming,简称PP)是两种不同的 编程范式 。 面向对象编程强调把问题分解成对象,通过封装、继承和多态等机制,来处理对象之间的关系 。每个对象都可以独立地处理自

    2024年02月21日
    浏览(51)
  • 什么是面向对象,它的三个基本特征:封装、继承、多态

    什么是面向对象思想?已经学完了java确不知道如何跟别人解释面向对象是什么意思这很常见。让我们一起来回顾下这个奇思妙想~ 现在越来越多的高级语言流行起来了,如大家耳熟能详的c++,python,java等,这些都是基于 面向对象 的语言 而最最基础的,学校必学的语言----c语

    2024年02月02日
    浏览(51)
  • Go后端开发 -- 面向对象特征:结构体 && 继承 && 多态 && interface

    type 用来声明数据类型 使用 type 定义结构体 对于结构体对象: 可以先定义后初始化; 也可以直接在{}中初始化 值传参 传递的是结构体的拷贝,原结构体不会发生改变 引用传递 传递的是结构体的指针,原结构体的值会改变 GetName 这个函数前面的 (this Hero) 表明这个函数是绑定

    2024年01月17日
    浏览(44)
  • 【Java SE语法篇】8.面向对象三大特征——封装、继承和多态

    📚博客主页:爱敲代码的小杨. ✨专栏:《Java SE语法》 ❤️感谢大家点赞👍🏻收藏⭐评论✍🏻,您的三连就是我持续更新的动力❤️ 面向对象三大特性:封装、继承和多态。 在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部

    2024年02月01日
    浏览(57)
  • 【C++】面向对象之多态

    文章内的所有调试都是在vs2022下进行的, 部分小细节可能因编译器不同存在差异。 概念引入 对于一个火车票售票系统, 可能会有多重角色, 比如普通成人类、学生类、军人类、儿童类等等… 这些类可能都是从某个基类派生出来的, 而且每个类都有一个基本需求,就是买票

    2024年02月01日
    浏览(84)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包