精华内容
下载资源
问答
  • 虚方法实现多态

    千次阅读 2016-05-26 20:56:15
    大家都知道面向对象的三大特征,封装、继承、多态,这里解释一下多态——什么叫多态同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。换句话说,实际上就是同一个类型的实例调用...

    大家都知道面向对象的三大特征,封装、继承、多态,这里解释一下多态

    ——什么叫多态

    同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。换句话说,实际上就是同一个类型的实例调用“相同”的方法,产生的结果是不同的。这里的“相同”打上双引号是因为这里的相同的方法仅仅是看上去相同的方法,实际上它们调用的方法是不同的。

    ——里氏转换

    多态是基于对象继承和里氏转换的,那么什么叫叫作里氏转换呢

    • 任何子类对象都可以赋值给父类对象
    • 如果父类对象中装的是子类对象,则父类对象可以强制转化为对应的子类对象
      这样说着很抽象,通过下面这个例子就能很好的理解了
    //首先,我们定义两个有继承关系的类
    public class Person
        {
            public void PersonSayHello()
            {
                Console.WriteLine("我是老师");
            }
        }
    
        public class Student : Person
        {
            public void StudentSayHello()
            {
                Console.WriteLine("我是学生");
            }
        }
     //在main方法中实例化一下
     static void Main(string[] argus){
         Person p = new Student();
             Student stu = p as Student;
             stu.StudentSayHello();
             //输出我是学生
     }
     //as方法是如果p对象能够转换成Student对象,则返回Student实例对象

    上面的例子就把一个子类赋值给了一个父类,并且父类转化成了子类,并调用方法

    由于有了里氏转换,所以所有父类出现的地方,子类都可以出现,比如参数,有的参数类型是object,而object是所有类的父类,所以可以赋值给任意值

    ——虚方法实现多态

    虚方法中一个重要的实现就是对父类方法的重写,解释一下重写的概念

    重写(override):子类中为满足自己的需要在子类中来重复定义某个方法的不同实现,需要用override关键字,被重写的父类方法必须是虚方法,用的是virtual关键字。它的特点是(三个相同):

    • 相同的方法名
    • 相同的参数列表
    • 相同的返回值

    举一个例子

    //首先我先定义三个有继承关系的类,Student和Master类继承于Person
        public class Person{
            public virtual void SayHi(){
                Console.WriteLine("我是人类");
            }
        }
        public class Student : Person {
            public override void SayHi()
            {
                Console.WriteLine("我是学生");
            }
        }
        public class Master : Person {
            public override void SayHi()
            {
                Console.WriteLine("我是班长");
            }
        }
    //继承的两个类都对父类的虚方法进行了override重写
    //我们在Main方法中实例并且调用一下
    static void Main(string[] args){
        Person person = new Person();
            person.SayHi();
            Person student = new Student();
            student.SayHi();
            Person master = new Master();
            master.SayHi();
    }
    /*输出结果:
    我是人类
    我是学生
    我是班长
    */

    子类赋值给了父类,当父类中装的是子类的实例的时候,父类在调用方法的时候,会自动去找到对应的子类实例对象的方法,这也就实现了一个方法实现了多种功能,也就是多种状态,也就是多态了!
    当然这里也可以选择不对父类的虚方法进行重写,如果这样的话要调用子类的方法就必须是通过子类来调用了,父类也要强制转换为子类才可以调用


    实现多态的第二种方式——【抽线类实现多态】

    展开全文
  • 知识点:理解多态的概念 、掌握使用虚方法实现多态、 理解抽象类和抽象方法 1、理解多态 1.1 什么是多态 多态(polymorphism)可以理解为多种形态,自然界的物质都存在多种形态,如水就有液态、固态和气态三种...

    知识点:理解多态的概念 、掌握使用虚方法实现多态、 理解抽象类和抽象方法

     

    1、理解多态

    提出问题:我们上一课学到的【继承】,知道子类从父类那里继承的方法时完全一致的,如项目实践里,当我们使用不同的游戏道具时,他们都调用了父类的方法,并没有体现出不同游戏道具之间的区别。

    解决问题:当子类从父类那里继承某个方法之后,子类对于这个方法有不同的响应方式,成为多态。

     

    1.1  什么是多态

               多态(polymorphism)可以理解为多种形态,自然界的物质都存在多种形态,如水就有液态、固态和气态三种。而面向对象中的多态,主要和对象的操作有关,不同的对象进行同一个操作时,可以有不同的实现方法。

    举个例子,人类都需要吃东西,而不同国家的人有不同的吃东西方式,中国人用筷子,美国人用刀叉,印度人用手。

    通俗理解:通过继承实现的不同对象调用相同的方法&

    展开全文
  •  虚方法实现多态  父类声明方法时加 virtual关键字表示这是一个虚方法  子类声明方法时加override关键字表示这个方法是重写父类中的虚方法  声明对象时 使用父类类型 声明对象变量 使用子类类型 构造...
  • 1.虚方法提供一种默认实现,子类可以选择是否重写,如果不重写,那么就使用父类已经...2.如果父类方法是虚方法,那么子类可以选择是否重写,如果重写,就会调用子类的重写方法,实现多态;如果没有重写,就会使用...

    1.虚方法提供一种默认实现,子类可以选择是否重写,如果不重写,那么就使用父类已经实现的方法。(重写可以改变方法的指针)

    如果需要改变类型指针,那么需要做方法的重写:

    1.如果子类方法是重写方法,那么系统会扫描父类方法中,有没有相同签名的可重写方法,如果没有就报错。

    2.如果父类方法是虚方法,那么子类可以选择是否重写,如果重写,就会调用子类的重写方法,实现多态;如果没有重写,就会使用父类已经实现的方法。

    3.实现多态需要实现方法的重写

    3.实现重写得实现类的继承

    多态的使用:申明父类变量,实例化子类对象。

    多态:一种操作,多种响应。

     

    实现多态的思路:

    1.先创建好父类,在创建好子类;

    2.在父类中创建需要被重写的虚方法或者抽象方法

    3.在子类中重写父类的虚方法或者抽象方法

    4.申明父类类型的变量,实例化子类对象---写出通用代码;

     

    1.声明父类变量,实例化子类对象  如:Person per=new Student()

    2.以父类作为方法的返回值类型,返回具体的子类对象---(简单工厂,封装变化点);

    3,父类作为参数,传入具体的子类对象;

     

     

    父类People

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的实现
    {
        class People
        {
            #region ID
            int id;
    
            public int ID
            {
                get { return id; }
                set { id = value; }
            }
            #endregion
    
            #region Name
            string name;
    
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
            #endregion
    
            #region Age
            int age;
    
            public int Age
            {
                get
                {
                    //如果年龄大于0小于等于100,就返回,否则返回18岁
                    if (age > 0 && age <= 100)
                    {
                        return age;
                    }
                    else
                    {
                        return 18;
                    }
                }
                set
                {
                    if (value > 0 && value <= 100) //注意这里不是: if(age>0&&age<=100)
                    {
                        age = value;
                    }
                    else
                    {
                        age = 18;
                    }
                }
            }
            #endregion
    
            #region Sex
            string sex;
    
            public string Sex
            {
                get
                {
                    //如果性别是男,或者女,就返回相应值,否则就设置为人妖
                    if (sex == "" || sex == "")
                    {
                        return sex;
                    }
                    else
                    {
                        return "人妖";
                    }
                }
                set
                {
                    if (value == "" || value == "")
                    {
                        sex = value;
                    }
                    else
                    {
                        sex = "人妖";
                    }
                }
            }
            #endregion
    
            public virtual void Show()
            {
                Console.WriteLine("我是父类People的Show方法");
            }
    
        }
    }

     

    子类Student

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的实现
    {
        /// <summary>
        /// 
        /// </summary>
        class Student : People   //实现多态必须要实现方法的重写,实现重写,必须要实现继承
        {
            public override void Show()
            {
    
                 Console.WriteLine("我是Student类的Show方法");
            }
            //public override void Show()
            //{
            //    //方法重写默认是,调用父类的同名方法
            //    base.Show();
            //}
        }
    }

     

    子类Teacher

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的实现
    {
        class Teacher:People  //实现多态必须要实现方法的重写,实现重写,必须要实现继承
        {
            override public void Show()
            {
                Console.WriteLine("我是teacher类的Show方法");
            }
        }
    }

     

     测试:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的实现
    {
        class Program
        {
            static void Main(string[] args)
            {
                //创建父类变量
                People[] p = new People[2];
    
                //实例化子类对象
                p[0] = new Student();
                p[1] = new Teacher();
                
                //写出通用代码
                p[0].Show();
                p[1].Show();
                Console.ReadKey();
            }
        }
    }

     

     

    例子2:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的练习
    {
        class Animal
        {
            public virtual void GetFood()
            { 
               //虚方法往往不知道,怎么实现。
            }
        }
    }
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的练习
    {
        class LaoYing:Animal
        {
            public override void GetFood()
            {
                Console.WriteLine("老鹰靠俯冲捕食。");
                //base.GetFood();
            }
        }
    }
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的练习
    {
        class Snack:Animal
        {
            public override void GetFood()
            {
                Console.WriteLine("蛇靠偷袭捕食");
                //base.GetFood();  //虚方法提供了默认实现,就是调用父类的方法
            }
        }
    }
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 多态的练习
    {
        class Program
        {
            static void Main(string[] args)
            {
                //实现多态的步骤
                //1.先写好父类,和可以被重写的方法
                //2.写好子类,重写父类的方法
                //3.声明父类变量,实例化子类对象
    
                Animal[] ans = new Animal[2];
                ans[0] = new Snack();
                ans[1] = new LaoYing();
    
                foreach (var item in ans)
                {
                    item.GetFood();
                }
                Console.ReadKey();
            }
        }
    }

    结果是:

     

    转载于:https://www.cnblogs.com/caofangsheng/p/4513432.html

    展开全文
  • 2168:36 亲情奉献全套精品.Net基础视频教程(1-9) ------------------------------------- ... 多态 ...虚方法实现多态-注:用虚方法子类可以实现多态,也可以不实现多态 虚方法多态实现:1父类的...

    .net基础教程 12-13448:48.net 基础教程 12-13

    -------------------------------------

    https://www.bilibili.com/video/av32101840?p=10

    多态

    实现多态的三种方法:1.虚方法;2抽象类;3.接口

    虚方法实现多态-注:用虚方法子类可以实现多态,也可以不实现多态

    虚方法多态实现:1父类的方法用virtual写成虚方法;2子类的同名方法用override关键字覆盖父类同名方法.此时使用父类对象指向子类对象,父类对象调用子类同名override方法实现多态(不调用父类自己的方法,而是调用子类的override方法.)

    抽象类-实现多态

    抽象类必须使用abstract关键字
    抽象成员(方法)只能出现在抽象类中.抽象成员(方法)必须使用abstract关键字.
    抽象类的抽象方法禁止实现
    抽象类可以有非抽象成员(方法),对自己无意义,但对子类有用
    抽象类的对象不能new实例化(即只有非抽象类的对象才能实例化)
    非抽象的子类实现父类的抽象方法时需要使用override关键字
    抽象类有构造函数,虽然无法实例化
    抽象类可以有virtual方法-对自己无意义,对子类有用
    (后代可以实现多态,也可以不实现多态.对比:普通方法-后代不能实现动态;抽象方法-后代必须实现多态;虚方法-后代可以实现动态,也可以不实现多态)
    多态:可以使用抽象父类的对象(抽象类不能new实例化对象)引用它的非抽象子类对象,并调用子类方法(父类成员必须满足多态条件,子类成员必须override覆盖)

    抽象类实现多态简单示例:


    全部代码如下:

    namespace App018_抽象类 {
        class Program {
            static void Main(string[] args) {
                //动物类 test = new 动物类();//注意!抽象类不能实例化
    
                //抽象类实现多态
                动物类[] 动物们 = new 动物类[4];
                //使用父类对象指向子类对象
                动物们[0] = new 猫咪类();
                动物们[1] = new 狗狗类();
                动物们[2] = new 猪头类();
                动物们[3] = new 驴子类();
                foreach (动物类 小动物 in 动物们) {
                    小动物.叫();
                }
                Console.ReadKey();
            }
        }
        /// <summary>
        /// 抽象类.可以有抽象方法和非抽象方法
        /// 抽象方法禁止实现,由派生类实现.
        /// (派生类也可以是抽象方法,但总归会有派生类的派生类...实现)
        /// </summary>
        public abstract class 动物类 {
            public abstract string 名字 { get; set; }
            public abstract void 叫();
            //注意:抽象方法禁止实现!不可以有方法体! 
            //抽象方法必须由子类实现!(除非子类也是抽象方法.但子类的派生类总归要实现!)
        }
        class 猫咪类 : 动物类 {
            public override string 名字 { get; set; }
            public override void 叫() {
                Console.WriteLine("我是猫咪.我喵喵喵叫!");
            }
        }
        class 狗狗类 : 动物类 {
            public override string 名字 { get; set; }
            public override void 叫() {
                Console.WriteLine("我是狗狗.我汪汪汪叫!");
            }
        }
        class 猪头类 : 动物类 {
            public override string 名字 { get; set; }
            public override void 叫() {
                Console.WriteLine("我是猪头.我吼吼吼叫!");
            }
        }
        class 驴子类 : 动物类 {
            public override string 名字 { get; set; }
            public override void 叫() {
                Console.WriteLine("我是驴子.我昂昂昂叫!");
            }
        }
    }

    程序输出:

    我是猫咪.我喵喵喵叫!
    我是狗狗.我汪汪汪叫!
    我是猪头.我吼吼吼叫!
    我是驴子.我昂昂昂叫!

    再以电脑和移动设备(手机/U盘/移动硬盘等)为例

    写个抽象类实现移动设备插电脑读写,代码如下:

    namespace 抽象类示例_移动设备插电脑读写 {
        class Program {
            static void Main(string[] args) {
                
                电脑 我的电脑 = new 电脑();
                我的电脑.插入的移动设备 = new 手机();
                我的电脑.让设备写数据();
                我的电脑.让设备读数据();
                Console.ReadKey();
            }
        }
        public class 电脑 {
            private 移动设备 _插入的移动设备;
            public 移动设备 插入的移动设备 { get => _插入的移动设备; set => _插入的移动设备 = value; }
    
            public void 让设备读数据() {
                插入的移动设备.读数据();
            }
            public void 让设备写数据() {
                插入的移动设备.写数据();
            }
        }
    
        public abstract class 移动设备{
            public abstract void 读数据();
            public abstract void 写数据();
        }
        public class 优盘 : 移动设备 {
            public override void 写数据() {
                Console.WriteLine("优盘写数据");
            }
            public override void 读数据() {
                Console.WriteLine("优盘读数据");
            }
        }
        public class 移动硬盘 : 移动设备 {
            public override void 写数据() {
                Console.WriteLine("移动硬盘写数据");
            }
            public override void 读数据() {
                Console.WriteLine("移动硬盘读数据");
            }
        }
        public class 手机 : 移动设备 {
            public override void 写数据() {
                Console.WriteLine("手机写数据");
            }
            public override void 读数据() {
                Console.WriteLine("手机读数据");
            }
        }
    }

    其中抽象父类为移动设备:

        public abstract class 移动设备{
            public abstract void 读数据();
            public abstract void 写数据();
        }

    它的非抽象子类有:优盘,移动硬盘,手机

    作为调用这些类的主体是电脑类的对象:

        public class 电脑 {
            private 移动设备 _插入的移动设备;
            public 移动设备 插入的移动设备 { get => _插入的移动设备; 
                set => _插入的移动设备 = value; }
    
            public void 让设备读数据() {
                插入的移动设备.读数据();
            }
            public void 让设备写数据() {
                插入的移动设备.写数据();
            }
        }

    当我们插入的移动设备是手机时,代码及运行效果如下:

    当我们插入的移动设备是优盘移动硬盘时,只需简单修改代码:


    而且,以后即使再增加更多的移动设备子类,也无须变更现有类代码耦合性大大降低...

    访问修饰符

    public:公开的,所有类都可以访问
    protected:受保护的,当前类和子类可以访问(可以跨程序集/项目)
    private:仅当前类可以访问
    internal:仅当前程序集(项目)可以访问.在同一项目中,internal和public等价.
    protected internal:仅当前程序集的当前类和子类可以访问

    1.修饰类的只有public和internal

    2.可访问性不一致.
    子类的访问权限不能高于父类的访问权限,否则会暴露父类的成员

    设计模式-简单工厂设计模式


    使用多态实现简单工厂模式:每次用户要求不同的具体子类产品时,只需给出父类产品即可(利用多态父类产品指向具体子类产品).因此无论客户要求哪种具体子类产品,工厂核心只需给客户父类产品 即可.

    序列化和反序列化

    概念

    序列化:将对象转化为二进制

    反序列化:将二进制还原为对象

    作用:传输数据

    方法

    序列化:

    1.在类前面加入序列化标记[Serializable];2.通过FileStream和BinaryFormatter生成序列化.如下为序列化简单示例:

    以下是反序列化示例,通过反序列化上例产生的文件而反序列化对象:

    部分类

    使用partial关键字修饰的类为部分类.部分类允许多个人共写一个类.

    对程序来说,使用partial修饰的类仍旧是同一个类并且只存在这一个类.

    密封类

    使用关键字sealed修饰的类为密封类.密封类不能被任何类继承.

    接口-实行多态

    接口概念

    接口不能被实例化,为了多态,也不能实现(只能被子类继承且必须实现),它只允许有禁止实现的成员.

    接口的成员只能有方法(禁止实现.不能有方法体),自动属性(不可以有普通属性),索引器和事件.

    接口中的成员(自动属性或方法)不允许添加访问修饰符.接口的成员默认是public(不能也没必要添加public修饰符)

    接口禁止存在字段成员(接口不允许存在数据)和构造函数

    接口可以继承接口,且可以多继承.类可以继承最多1个类+多个接口,此时继承的类必须写于继承的接口之前.

     

    我们来写一个接口简单示例

    首先看类图

    代码运行效果如下:

    代码如下:

    namespace App021_接口 {
        class Program {
            static void Main(string[] args) {
                //接口实现多态
                //IFlyable flyObj = new Swan();
                //IFlyable flyObj = new Hawk();
                IFlyable flyObj = new Parrot();
                //IFlyable flyObj = new Helicopter();
                //IFlyable flyObj = new Jordan();
                flyObj.Fly();
    
                ISpeak spkObj= new Parrot();
                //ISpeak spkObj = new Jordan();            
                spkObj.Speak();
    
                Console.ReadKey();
            }
        }
        class Bird {
            public double Wings {
                get;
                set;        
            }
            public void DrinkAndEat() {
                Console.WriteLine("我会吃会喝");
            }
        }
        interface IFlyable {
            void Fly();
        }
        interface ISpeak {
            void Speak();
        }
        class Swan : Bird, IFlyable {
            public void Fly() {
                Console.WriteLine("天鹅会飞");
            }
        }
        class Hawk : Bird, IFlyable {
            public void Fly() {
                Console.WriteLine("鹰会飞");
            }
        }
        class Parrot : Bird, IFlyable,ISpeak {
            public void Fly() {
                Console.WriteLine("鹦鹉会飞");
            }
            public void Speak() {
                Console.WriteLine("鹦鹉会说人话");
            }
        }
        class Cock : Bird {
            //公鸡不会飞,所以不继承IFlyable接口
        }
        class Hen : Bird {
            //母鸡不会飞,所以不继承IFlyable接口
        }
        class Helicopter : IFlyable {
            public void Fly() {
                Console.WriteLine("直升机用螺旋桨飞");
            }
        }
        class Jordan : IFlyable, ISpeak {
            public void Fly() {
                Console.WriteLine("飞人乔丹在篮球场飞");
            }
            public void Speak() {
                Console.WriteLine("飞人乔丹会说话");
            }
        }
    }

    显式实现接口

    超市收银系统

    md5

    ToString(string)方法中格式参考:https://docs.microsoft.com/zh-cn/dotnet/api/system.byte.tostring?view=netframework-4.8#System_Byte_ToString_System_String_

    展开全文
  • 1.示例代码 ...因此,可以通过在不同派生类中加override关键字进行重写的方式实现多态的效果。 2.示例代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; usin...
  • 虚方法:用virtual修饰的方法叫做虚方法 虚方法可以在子类中通过...2,虚方法在父类中必须有实现; 3,子类继承父类后,可以选择对虚方法进行重写也可以选择不进行重写; 4,当子类重写父类方法的时候,必须保证
  • 关于多态,简而言之就是 用父类的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数,这种方法呢,可以让父类的指针具有多种形态,也就是说不需要改动很多的代码就可以让父类这一种指针,干一些很多...
  • 实现多态虚方法

    2012-03-25 21:11:33
    实现多态虚方法
  • 虚方法多态

    2011-08-14 17:52:00
    虚方法多态 虚方法(virtual)virtual关键字用地修饰方法、属性、索引器或事件声明,并且允许在派生类中重写这些对象。virtual表示此方法是一个虚方法,override表示要覆盖主线类的虚方法,对方法进行...
  • C++函数实现多态

    千次阅读 2017-06-03 18:56:43
    C++是通过函数来解决多态问题的 函数,就是在基类声明函数是虚拟的,并不是实际存在的函数,然后再派生类中才正式定义此函数。在程序运行期间,用指针指向某一派生类对象,这样就能调用指针指向的派生类对象中...
  • 056函数实现多态

    2018-12-17 16:22:37
    Shape.h #ifndef SHAPE_H #define SHAPE_H class Shape { public: Shape(); ~Shape(); virtual double calcArea(); }; #endif Shape.cpp #include &quot;Shape.h&......
  • 定义:用virtual关键字修饰的函数,本质:由指针和表控制,指针指向表中的某个函数入口地址,就实现多态。 作用:实现多态函数可以被子类重写,函数地址存储在表中 二、使用: ...
  • C#函数实现多态

    2011-03-10 09:39:00
    C#函数实现多态:using System; using System.Collections.Generic; using System.Text; namespace jichengtest {  class Program  {  static void Main(string[] args)  {  // F...
  • C++ 函数实现多态总结 1.使用virtual时,只在成员函数的声明中添加virtual,在成员函数的实现中不要加virtual,示例如下: Father.h class Father{ public: virtual int val(); } Father.cpp int Father::val(){...
  • 在上一篇文章CLR怎样实现虚方法多态调用(1)中主要介绍了CLR怎样多态调用虚方法以及各种类型的方法在Method Table中的排布,但是没有介绍怎样调用接口方法,当某个对象向上转型为接口时进行多态调用时,CLR是怎样...
  • 在上一篇文章CLR怎样实现虚方法多态调用(1)中主要介绍了CLR怎样多态调用虚方法以及各种类型的方法在Method Table中的排布,但是没有介绍怎样调用接口方法,当某个对象向上转型为接口时进行多态调用时,CLR是怎样...
  • 1.虚方法多态 1.1 背景: /////////////////////////////////////////////////////////////////////////////////////////////////// 基类: //////////////////////////////////////////////////////////////////...
  • c++ 函数实现多态的原理

    千次阅读 2014-08-15 12:46:26
    前面的文章说过了c++如何实现多态,最主要的就是使用函数,另一种方法就是RTTI,这里我们不做说明了。前面说过编译器是这样实现晚绑定的:编译器对每一个含有virtual函数的类创建一个函数表vtable,其实vtable...
  • C#-虚方法多态

    2014-02-28 16:38:08
    虚方法:用virtual修饰 子类可以重写就会调用子类的 也可以不重写调用父类的. 如果子类重写了父类的虚方法. 那么通过父类变量来调用这个方法的时候 会调用子类的. 父类 p = new 子类(); 如果 父类和子类存在同名...
  • 多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运。...1.用抽象类实现多态 我们先定义一个水果Fruit抽象类
  • 11.1.1 为何用多态 下面程序,将Tuna 实例传递给Fish 参数,并通过该参数调用基类的Swim(); #include using namespace std; class Fish { public :  void Swim()  {  cout  } }; class ...
  • system-verilog: 关于虚方法多态

    千次阅读 2019-10-31 19:48:47
    子类继承父类的所有数据成员和方法; 子类可以添加新的数据成员和方法; 子类可以重写基类中的数据成员和方法,也就是重写; 如果基类的一个方法被重写,其必须保持和基类的原定义有一致的参数; 子类可以通过...
  • 函数实现多态---C++

    2014-11-23 16:49:07
    1、相同概念:晚绑定、动态绑定、运行时绑定...Virtual关键字 给一个编译器标记(具体实现原理不可以不了解,涉及函数表) fun是一个通用方法 运行结果: <未完待续>
  • 多态的概念:让一个对象能够表现出多种的状态(类型)。  用一句话来描述多态:通过继承实现的不同对象调用相同的方法,表现出不同的行为,称之为多态。... 实现多态的3种方式: 虚方法、抽象类、接口。 1...
  • void Func() //子类实现了父类的同名方法 ...{ printf("Child::Run() "); } }; class Child1 : public Base ...{ public: }; int main() ...{ Child a; Child1 b; a.Run(); //调用子类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,639
精华内容 18,655
关键字:

虚方法实现多态