精华内容
下载资源
问答
  • 主要介绍了Java中多态性的实现方式,什么是多态?通过简单的一道题目帮大家理解java多态性,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 到底什么是多态性”?

    千次阅读 2020-07-22 10:31:36
    1.多态的基本概念 /** ... * @date : 2020/7/22 8:57 *面向对象有三大特征:封装、继承、多态 * 封装、继承是面向于... * 代码中的多态性,其实就是一句话,父类引用指向子类对象,就是父类可以引用不同子类的对象,产

    1.多态的基本概念

    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 8:57
     *面向对象有三大特征:封装、继承、多态
     * 封装、继承是面向于类或者接口;
     * 多态面向的是对象,指的是对象的多态性
     * --------------------------------------------------
     * 代码中的多态性,其实就是一句话,父类引用指向子类对象,就是父类可以引用不同子类的对象,产生不同种 
     * 形态
     * 格式:
     * 父类名称 对象名 = new 之类名称();
     * 或者:
     * 接口名称 对象名 = new 实现类名称();
     */
    public class Multi {
        public static void main(String[] args) {
            // 使用多态方法
            // 左侧父类的调用,指向右侧子类的对象
            // 一只猫被当做动物看待是没有问题的
            Animal obj = new Cat();
    
            obj.method();    // 子类方法,new的是谁就指向谁
            obj.methodFu();  // 父类特有方法,如果子类没有,就会向上找父类
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 8:59
     */
    public class Animal {
        public void method(){
            System.out.println("父类方法");
        }
        public void methodFu(){
            System.out.println("父类特有方法");
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:00
     */
    public class Cat extends Animal {
    
        @Override
        public void method(){
            System.out.println("子类方法");
        }
    }

    2.多态成员变量的使用特点

    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     *访问成员变量的两种方式:
     *
     * 1.直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找,不会向下找。
     * 2.间接通过成员方法访问成员变量: 看该方法属于谁,优先用谁,没有则向上找,不会向下找。
     */
    public class Multi {
        public static void main(String[] args) {
            // 使用多态的写法,父类引用指向子类对象
            Fu fu = new Zi();
            System.out.println(fu.num);
    //        System.out.println(fu.age); // 错误写法,向下查找
    
            // 子类没有覆盖重写父类方法,就是父:10
            // 子类如果覆盖重写父类方法,就是子:20
            fu.showNum();
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Fu {
        int num = 10;
    
        public void showNum(){
            System.out.println(num);
        }
    }
    
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Zi extends Fu {
        int num = 20;
        int age = 16;
    
        @Override
        public void showNum() {
            System.out.println(num);
        }
    }
    

    3.多态成员方法的访问规则

    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     *访问成员变量的两种方式:
     *
     * 1.直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找,不会向下找。
     * 2.间接通过成员方法访问成员变量: 看该方法属于谁,优先用谁,没有则向上找,不会向下找。
     *
     * 在多态的代码当中成员方法的访问规则是:
     *  *  看new的是谁,就优先使用谁,没有则向上找。
     *
     * 口诀:编译看左边,运行看右边。
     */
    public class Multi {
        public static void main(String[] args) {
            // 使用多态的写法,父类引用指向子类对象
            Fu obj = new Zi();
            System.out.println(obj.num);
    //        System.out.println(fu.age); // 错误写法,向下查找
    
            // 子类没有覆盖重写父类方法,就是父:10
            // 子类如果覆盖重写父类方法,就是子:20
            obj.showNum();
    
            // 编译看左面,没问题;运行的时候method()是运行的子类中的方法
            obj.method();   // 子类是new的,并且有,先用子类
            // 编译看左面,没问题;运行的时候method()是运行的子类中的方法,子类中没有向上找到父类
            obj.methodFu(); // 子类没有向上找
    
            // 编译看左边,左边是Fu obj(),没有methodZi(),所以编译报如下错误
    //        obj.methodZi();  // 错误写法
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Fu {
        int num = 10;
    
        public void showNum(){
            System.out.println(num);
        }
    
        public void method(){
            System.out.println("父类方法");
        }
    
        public void methodFu(){
            System.out.println("父类特有方法");
        }
    }
    /**
     * @author : sunkepeng E-mail:sunkepengouc@163.com
     * @date : 2020/7/22 9:14
     */
    public class Zi extends Fu {
        int num = 20;
        int age = 16;
    
        @Override
        public void showNum() {
            System.out.println(num);
        }
    
        @Override
        public void method() {
            System.out.println("子类方法");
        }
    
        public void methodZi(){
            System.out.println("子类特有方法");
        }
    }

    4.使用口诀

    成员变量:编译看左边,运行还是看左边

    成员方法:编译看左边,运行看右边

    5.多态的用处

    就上图示例,等号左面的都是Employee对象,不关心等号右面是讲师、助教、保安等,使得代码更加灵活

    展开全文
  • 了解Java多态性什么是Java的多态性(向上转型)多态性的前提为什么使用多态性?多态性的使用向下转型instanceof运算符 什么是Java的多态性(向上转型) Java的多态性是事物的多种形态,是运行时行为(向上转型,子类...

    什么是Java的多态性(向上转型)

    Java的多态性是事物的多种形态,是运行时行为(向上转型,子类可以赋值给父类),父亲的行为像儿子。

    多态性的前提

    1. 继承性(必须有父类和子类,才会有把子类赋值给父类的情况)
    2. 子类重写了父类的方法(如果子类不重写父类的方法,调用的就还是父类的方法)

    为什么使用多态性?

    多态性可以减少重载函数的使用,可以调用子类重写后的方法

    多态性的使用

    当调用子父类同名方法同参数的方法时,调用只能调用父类中申明过的方法,但是实际上执行的是子类重写父类的方法(编译看左边,执行看右边)。也就是虚拟方法的调用。
    主函数中,父类调用子类重写的行为

    class Person {
        private String name;
        private String age;
    
        public String getName() {
            System.out.println("我是父类");
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    }
    

    在子类Man中

    class  Man extends Person{
        private String name;
        private String age;
    
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void setName(String name) {
            System.out.println("我是男人的姓名");
            this.name = name;
        }
    
        @Override
        public String getAge() {
            System.out.println("我是男人的年龄");
            return age;
        }
    
        @Override
        public void setAge(String age) {
            this.age = age;
        }
    
        public void earnMoney(){
            System.out.println("男人可以赚钱");
        }
    }
    
      Person person=new Man();
            person.getName();//输出结果:我是男人的姓名
    

    例:多态性减少重载函数的使用
    想要得到父类的年龄,也想得到子类的年龄,要写两个重载函数

      private void testAge(Man man){
            System.out.println(man.getAge());
        }
        private void testAge(Person person){
            System.out.println(person.getAge());
        }
    

    然后再主函数调用

            test.testAge(new Man());
            test.testAge(new Person());
    

    使用Java多态性后,只需要保留一个方法

    private void testAge(Person person){
            System.out.println(person.getAge());
        }
    

    调用时:

            test.testAge(new Man());
            test.testAge(new Person());
    

    向下转型

    在使用多态性的时候,父类new了一个子类时,其实子类的所有方法都会加载,但是如果父类没有申明子类的方法,也就是说子类并没有重写父类的方法,而是自定义了一个方法,那么我们如何使用多态性使得父类的对象能够调用子类的特有的方法呢?意味着需要将父类对象如果直接使用赋值符号,在基本数据类型中是有一个自动类型提升的说法,但是类类型的不能使用自动类型提升,只能使用强制类型转换。

            Person person=new Man();
            Man man=(Man) person;
            man.earnMoney();
    

    强制类型转换的时候会出现异常,比如如下情况:地址值相同但是类型不相同

            Person person=new Man();
            Man man=(Man) person;
            Woman woman=(Woman) person;
    

    为了避免这种情况,我们使用instanceof运算符

    instanceof运算符

    1. a instanceof A 判断a 是不是 instanceof 的实例
    Person person=new Man();
            if (person instanceof Man){
                Man man= (Man) person;
                man.earnMoney();
            }
            if (person instanceof Woman){
                Woman woman= (Woman) person;
                woman.goshopping();
            }
    
    展开全文
  • C# 多态性 多态性意味着有多重形式。在面向对象编程范式中,多态性往往表现为”一个接口,多个功能”。 多态性可以是静态的或动态的。在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在...
  • C++基础:什么是C++的多态性

    千次阅读 2020-12-28 18:50:10
    多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。 C++多态性是通过虚函数来实现的,虚函数允许子类重新定义...

    多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。

    C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。

    多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。

    那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。

    最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。

    一、定义

    纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”

    virtual void funtion()=0

    二、引入原因

    1、为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。

    2、在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。

    为了解决上述问题,引入了纯虚函数的概念,将函数定义为纯虚函数(方法:virtual ReturnType Function()=0;),则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类,它不能生成对象。这样就很好地解决了上述两个问题。

    三、相似概念

    1、多态性

    指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性:编译时多态性,运行时多态性。

    a、编译时多态性:通过重载函数实现

    b、运行时多态性:通过虚函数实现。

    2、虚函数

    虚函数是在基类中被声明为virtual,并在派生类中重新定义的成员函数,可实现成员函数的动态覆盖(Override)

    3、抽象类

    包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数,所以不能定义抽象类的对象。

    虚析构函数的特点(动态绑定)

    Base*p=new Derived();

    delete p;

    删除Base类型的指针时,会调用析构函数,如果Base类型的析构函数的虚函数,则会按照虚函数的动态绑定,先调用Derived的析构函数,然后调用Base的析构函数。

    以这样的方式会调用多次析构函数。

    C++类成员和数据成员初始化总结

    C++为类中提供类成员的初始化列表

    类对象的构造顺序是这样的:

    1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员

    2.进入构造函数后在构造函数中执行一般计算

    1.类里面的任何成员变量在定义时是不能初始化的。

    2.一般的数据成员可以在构造函数中初始化。

    3.const数据成员必须在构造函数的初始化列表中初始化。

    4.static要在类的定义外面初始化。

    5.数组成员是不能在初始化列表里初始化的。

    6.不能给数组指定明显的初始化。

    这6条一起,说明了一个问题:C++里面是不能定义常量数组的!

    C++类的初始化:

    1.初始化列表:CSomeClass::CSomeClass() : x(0), y(1){}

    2.类外初始化:int CSomeClass::myVar=3;

    3.const常量定义必须初始化,C++类里面使用初始化列表;

    4.C++类不能定义常量数组。

    免费领取C++学习资料一份

    在这里插入图片描述

    展开全文
  • 运行时多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制,下面...
  • Java是面向对象的语言,多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载...
    

    Java是面向对象的语言,多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制,主要体现在继承和接口实现两方面,详见例子:继承实现多态例如:

    class A{

          method(){

             System.out.println("a");

        }

    }

    class B extends A{

           method(){

           System.out.println("b");

        }

    }

    class test{

           main(){

            A test = new B();

            test.method();//执行以后输出的是:b。解释就是:父类引用(A)指向子类对象(B),这个引用调用的是子类的方法,而不是父  类A的方法;

        }

    }

    继承实现多态其实原理类似:

    interface A{

        method();

    }

    class B implements A{

          method(){

          System.out.println();

        }

    }

    class test{main(){

         A test = new B();

        test.method();//此处便会使用java的多态,B实现了A,虽然=前面是A test,但实际上生成的确是B的对象,所以调用它的方法,同继承中的父类对象指向子类对象原理相同,只是此处为继承;

       }

    }

    多态的好处非常明显啊,有人总结:

            1.可替换性。多态对已存在的代码具有可替换性。

            2.可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际 上新加子类更容易获得多态功能。  

          3.接口性。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。  

         4.灵活性。它在应用中体现了灵活多样的操作,提高了使用效率。  

         5.简化性。多态简化了对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。值得注意的是,多态并不能够解决提高执行速度的问题,因为它基于动态装载和地址引用,或称动态绑定。

    展开全文
  • 多态性给我们带来了好处:多态使得我们可以通过基类的引用或指针来指明一个对象(包含其派生类的对象),当调用函数时可以自动判断调用的是哪个对象的函数。一个函数说明为虚函数,表明在继承的类中重载这个函数时,...
  • C#中多态性的实现

    2021-01-20 02:01:05
    多态是指一个行为具有多个不同表现形式的能力,在C#中通过多态性的检测时机可以分为静态多态性和动态多态性 静态多态性:函数重载和运算符重载 动态多态性:抽象方法、重写方法、隐藏方法 二:函数重载(overlode) ...
  • 主要介绍了Python的多态性,以实例形式深入浅出的分析了Python在面向对象编程中多态性的原理与实现方法,需要的朋友可以参考下
  • C++之多态性

    万次阅读 多人点赞 2019-06-05 00:25:31
    1.初探多态性 在面向对象方法中,所谓多态性就是不同对象收到相同消息,产生不同的行为。在C++程序设计中,多态性是指用一个名字定义不同的函数,这些函数执行不同但又类似的操作,这样就可以用同一个函数名调用不同...
  • 1. 什么是多态性 1.0多态的简要介绍:多态中的态为形态的意思,在面向对象编程中是指向不同的对象发送同一个消息,不同的对象在接收时会产生不同的行为。举个例子通俗来讲就是:比如说开学了,校长把这个消息发送给...
  • C++中的多态性实例,包括静态多态性和动态多态性(运算符的重载和虚函数)
  • 什么是多态性? Polymorphism(多态性)是一个很长的单词,但是它表示的是一个非常简单的概念。 多态性描述了在面向对象编程模式中类有不同的功能,而共享一个通用的接口。 多态性的优点是,并不需要知道它使用的是哪...
  • 贵州大学实验报告 学院电子信息学院 专业通信工程 班级 姓名 学号 实验组 5 实验时间 指导教师 成绩 实验项目名称 多态性 实 验 通过让学生进行实验使其对于动态多态性有一个较为深入的了解和熟悉 最终可以 目 熟练...
  • C#中的多态性

    千次阅读 2020-01-30 19:24:10
    多态是指一个行为具有多个不同表现形式的能力,在C#中通过多态性的检测时机可以分为静态多态性和动态多态性静态多态性:函数重载和运算符重载 动态多态性:抽象方法、重写方法、隐藏方法 二:函数重载(overlode) ...
  • (一)多态性  多态是指同样的消息被不同的对象接收时导致不同的行为。所谓消息是指对类成员函数的调用,不同的行为是指的不同的实现,也就是调用了不同的函数。 1)多态的分类  广义上说,多态性是指一段程序能够...
  • 什么是多态性多态性是继数据抽象和继承后,面向对象语言的第三个特征。从字面上理解,多态的意思是“多种形态”,简单来说,多态是具有表现多种形态的能力的特征,在OO中是指“语言具有根据对象的类型以不同方式...
  • 课程名称《面向对象程序设计》实验项目:多态性;北京信息科技大学信安专业实验报告、实验七
  • 多态性和运算符重载
  • 含实验心得,非常详细
  • 主要介绍了java 多态性详解及简单实例的相关资料,需要的朋友可以参考下
  • 主要介绍了java 多态性详解及常见面试题的相关资料,这里对java 的多态性做了资料整理,并列举常见的关于多态性的面试题,需要的朋友可以参考下
  • 下面小编就为大家带来一篇Java静态方法不具有多态性详解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要讲述,静态联编与动态联编,虚函数的声明与使用,虚函数应用实例,纯虚函数,虚析构函数等内容。
  • C#类的多态性详解

    2021-01-20 06:39:52
    第一种:编译时的多态性,直接这样说不知道说啥?程序执行过程主要分为三步:编译,链接,运行。在编译时体现的多态性是通过方法的重载来实现的。方法的重载我们听过,就是一个类对象调用若干同名,但参数类型、个数...
  • 多态性(polymorphism)是面向对象程序设计的一个重要特征。如果一种语言只支持类而不支持多态,是不能被称为面向对象语言的,只能说是基于对象的,如Ada、VB就属此类。C++支持多态性,在C++程序设计中能够实现多态性...
  • 深入理解C++的多态性

    2020-12-31 11:28:32
    我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够有一个充分的掌握。多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 268,516
精华内容 107,406
关键字:

什么是多态性