精华内容
下载资源
问答
  • c#虚方法

    2018-10-09 01:31:03
    把一个基类函数声明为virtual,就可以在任何派生类中重写该... 我们在子类里面重写函数之后,不管在哪里调用都是调用重写之后的方法 namespace ConsoleApp7 { class Enemy { public virtual void Move() { ...
    1. 把一个基类函数声明为virtual,就可以在任何派生类中重写该函数:
    2. 在派生类中重写另外一个函数时,要使用override关键字显示声明
    3. 我们在子类里面重写虚函数之后,不管在哪里调用都是调用重写之后的方法
    namespace ConsoleApp7
    {
        class Enemy
        {
            public virtual void Move()
            {
                Console.WriteLine("这是调用的Enemy.Move()");
            }
            public void AI()
            {
                Move();
                Console.WriteLine("这是调用的Enemy.AI()");
            }
        }
        class Boss:Enemy
        {
            public override void Move()
            {
                Console.WriteLine("这是调用的Boss.Move()");
            }
            public void A()
            {
                Move();
                Console.WriteLine("这是调用的Boss.A()");
            }
        }
        class Program
        {
    
            static void Main(string[] args)
            {
    
                Boss boss1 = new Boss();
                boss1.AI();//这是调用的Boss.Move();这是调用的Enemy.AI()
                boss1.Move();//这是调用的Boss.Move()
                boss1.A();//这是调用的Boss.Move();这是调用的Boss.A()
    
                Console.WriteLine("----------------");
    
                Enemy enemy = new Enemy();
                enemy.AI();//这是调用的Enemy.Move();这是调用的Enemy.AI()
                enemy.Move();//这是调用的Enemy.Move()
    
                Console.WriteLine("----------------");
    
                Enemy boss2 = new Boss();
                boss2.Move();//这是调用的Boss.Move()。如果没有Override(即隐藏函数),则会调用Enemy.Move()
    
                Console.ReadKey();
            }
        }
    
    }

    经典例题(虚方法和隐藏函数之间的区别):

    下列代码输出为:

    class Father{
       public void F() { Console.WriteLine("A.F"); }
       public virtual void G() { Console.WriteLine("A.G"); }
    }
    class Son: Father{
       new public void F() { Console.WriteLine("B.F"); }//隐藏了父类中的方法,父类中的F方法还存在
       public override void G() { Console.WriteLine("B.G"); }//重写了父类中的方法,父类中的G方法就不存在了
    }
    class override_new{
       static void Main() {
          Son b = new Son();
          Father a = b;
          a.F();//通过父类声明的对象 调用隐藏方法,会调用父类中的  A.F
          b.F();//通过子类声明的对象 调用隐藏方法,会调用子类中的  B.F
          a.G();// B.G
          b.G();//B.G
       }
    }
    
    展开全文
  • C# 虚方法

    2020-04-25 11:38:06
    把一个基类方法声明为 virtual, 就可以在任何派生类(子类)中重写该方法: public class Shape { public virtual void Draw() ...// 这里演示如何重写父类的虚方法 public class MyClass : Shape...

    把一个基类方法声明为 virtual, 就可以在任何派生类(子类)中重写该方法:

    public class Shape
    {
        public virtual void Draw()
        {
            Console.WriteLine( "父类实现Draw 方法" );
        }
    }
    
    // 这里演示如何重写父类的虚方法
    public class MyClass : Shape
    {
        public override void Draw()
        {
            Console.WriteLine( "子类实现Draw 方法" );
        }
    }
    
    
    // 这里演示调用
    public void Main()
    {
        MyClass my = new MyClass();
    
        my.Draw();
    }
    
    // 控制台输出
    // 子类实现Draw 方法

    在C# 中函数在默认情况下不是虚拟的, 但是可以显式的声明为 virtual (构造函数除外)。 在派生类的函数重写时需要使用 override 关键字显式声明。(上面的例子很好的演示了如何声明虚方法和重写虚方法)

    当然也可以给属性声明 virtual 。 对于定义虚属性或重写属性,语法与函数相同,这里就不举例了。

     

    注意:成员字段和静态函数不能声明为 virtual, 因为这个概念只对类中的实例函数成员有意义。

     

    展开全文
  • C#虚方法

    2016-05-03 11:35:07
    //这个表示类中的一个全新的方法SayHello,为什么可以添加一个和父类中的SayHello一模一样的方法呢? //因为使用了new关键字,将从父类继承下来的SayHello方法隐藏掉了 public new void SayHello (){ ...
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace ConsoleApplication2
    {
        class Program
        {
            static void Main(string[] args)
            {
                Chinese c = new Chinese();
                c.SayHello();
                Japanese j = new Japanese();
                j.SayHello();
                Console.ReadKey();
            }
        }
    
        public class Person
        {
            public virtual void SayHello()
            {
                Console.WriteLine("Hello");
            }
        }
    
        public class Chinese : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("你好");
               // base.SayHello();
            }
        }
    
        public class Japanese : Person
        {
    
            //这个表示类中的一个全新的方法SayHello,为什么可以添加一个和父类中的SayHello一模一样的方法呢?
            //因为使用了new关键字,将从父类继承下来的SayHello方法隐藏掉了
            public new void SayHello(){
                Console.WriteLine("新方法");
                base.SayHello();
            }
        }
    }
    
    展开全文
  • 主要介绍了C#虚方法的声明和使用实例教程,对于初学者理解C#的虚方法有一定的帮助,需要的朋友可以参考下
  • C#虚方法Virtual+详解 很详细的哦 京华志&精华志出品 希望大家互相学习,互相进步 支持CSDN 支持微软
  • C# 虚方法Virtual详解

    2020-01-20 10:26:32
    1.Virtual简介 virtual 关键字用于修改方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。Virtual方法可被任何继承它的类替代,虚拟成员的实现可由派生类中的替代成员更改... 不能替代非虚方法。virtua...

    1.Virtual简介

    1. virtual 关键字用于修改方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。Virtual方法可被任何继承它的类替代,虚拟成员的实现可由派生类中的替代成员更改。
    2. 调用虚拟方法时,将为替代的成员检查该对象的运行时类型。 将调用大部分派生类中的该替代成员,如果没有派生类替代该成员,则它可能是原始成员。
    3. 默认情况下,方法是非虚拟的。 不能替代非虚方法。virtual 修饰符不能与 static、abstract``private 或 override 修饰符一起使用。

    2.Virtual使用

    虚拟函数从C#的程序编译的角度来看,它和其它一般的函数有什么区别呢?一般函数在编译时就静态地编译到了执行文件中,其相对地址在程序运行期间是不发生变化的。而虚函数在编译期间是不被静态编译的,它的相对地址是不确定的,它会根据运行时期对象实例来动态判断要调用的函数。

    具体的检查的流程如下:

    1. 当调用一个对象的函数时,系统会直接去检查这个对象申明定义的类,即申明类,看所调用的函数是否为虚函数;

    2. 如果不是虚函数,那么它就直接执行该函数。而如果有virtual关键字,也就是一个虚函数,那么这个时候它就不会立刻执行该函数了,而是转去检查对象的实例类。

    3. 在这个实例类里,他会检查这个实例类的定义中是否有重新实现该虚函数(通过override关键字),如果是有,那么OK,它就不会再找了,而马上执行该实例类中的这个重新实现的函数。而如果没有的话,系统就会不停地往上找实例类的父类,并对父类重复刚才在实例类里的检查,直到找到第一个重载了该虚函数的父类为止,然后执行该父类里重载后的函数。

    3.Virtual例子

    以下是一个详细的例子。

    using System;
    
    namespace VirtualSample
    {
        class A
        {
            public virtual void Func() // 注意virtual,表明这是一个虚拟函数
            {
                Console.WriteLine("Func In A");
            }
        }
    
        class B : A // 注意B是从A类继承,所以A是父类,B是子类
        {
            public override void Func() // 注意override ,表明重新实现了虚函数
            {
                Console.WriteLine("Func In B");
            }
        }
    
        class C : B // 注意C是从A类继承,所以B是父类,C是子类
        {
        }
    
        class D : A // 注意B是从A类继承,所以A是父类,D是子类
        {
            public new void Func() // 注意new ,表明覆盖父类里的同名类,而不是重新实现
            {
                Console.WriteLine("Func In D");
            }
        }
    
        class program
        {
            static void Main()
            {
                //A a;         // 定义一个a这个A类的对象.这个A就是a的申明类
                //A b;         // 定义一个b这个A类的对象.这个A就是b的申明类
                //A c;         // 定义一个c这个A类的对象.这个A就是b的申明类
                //A d;         // 定义一个d这个A类的对象.这个A就是b的申明类
    
                A a = new A(); // 实例化a对象,A是a的实例类
                A b = new B(); // 实例化b对象,B是b的实例类
                A c = new C(); // 实例化b对象,C是b的实例类
                A d = new D(); // 实例化b对象,D是b的实例类
    
                a.Func();    // 执行a.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类A,就为本身 4.执行实例类A中的方法 5.输出结果 Func In A
                b.Func();    // 执行b.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类B,有重载的 4.执行实例类B中的方法 5.输出结果 Func In B
                c.Func();    // 执行c.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类C,无重载的 4.转去检查类C的父类B,有重载的 5.执行父类B中的Func方法 5.输出结果 Func In B
                d.Func();    // 执行d.Func:1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类D,无重载的(这个地方要注意了,虽然D里有实现Func(),但没有使用override关键字,所以不会被认为是重载) 4.转去检查类D的父类A,就为本身 5.执行父类A中的Func方法 5.输出结果 Func In A
                D d1 = new D();
                d1.Func(); // 执行D类里的Func(),输出结果 Func In D
                Console.ReadLine();
            }
        }
    }
    

    参考文章:
    https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/virtual
    https://www.cnblogs.com/zhaoshujie/p/10502404.html

    展开全文
  • 虚方法则有自己的函数体,已经提供了函数实现,但是允许在子类中重写或覆盖。 重写的子类虚函数就是被覆盖了。抽象方法使用abstract关键字 public abstract bool Withdraw(…);抽象方法是必须被派生类覆写的方法。...
  • c++ c#虚方法

    千次阅读 2013-05-30 19:14:05
    C#的语法脱胎于C++,因而保留了virtual关键字,可以定义一个虚方法(或虚属性)。一个类的成员被定义为virtual,就意味着它在告诉自己的子类:我准备了一笔遗产,你可以全盘接受,也可以完全拒绝或者修改我的遗嘱。...
  • C#虚方法(Virtual)详解

    2010-08-04 09:34:16
    用一个生动的例子和程序段详细的说明了虚方法的用法,有助于理解
  • C#虚方法和抽象方法

    万次阅读 2011-05-28 16:03:00
    虚方法:1、virtual方法表示此方法可以被重写, 也就是说这个方法具有多态.父类中的方法是通用方法,可以在子类中重写以重新规定方法逻辑. 2、virtual方法可以直接使用,和普通方法一样 3、不是必须重写的. 子类可以...
  • C# 虚方法与抽象方法区别

    千次阅读 2015-02-17 21:40:46
    虚方法则有自己的函数体,已经提供了函数实现,但是允许在子类中重写或覆盖。 重写的子类虚函数就是被覆盖了。 抽象方法 使用abstract关键字 public abstract bool Withdraw(…); 抽象方法是必须被派生类...
  • 1.虚方法  关键字virtual,如果父类中存在虚方法,则子类可以用override进行方法的重写,当然也可以不重写 2.抽象方法  关键字abstract,抽象方法必须存在于抽象类之后,但是抽象类不仅仅只有抽象方法,也可由有...
  • C#虚方法的重写

    2016-05-26 09:53:00
    情景:子类调用父类构造函数,父类构造函数调用虚函数,子类重写该虚方法。 结果:执行的是子类覆写的方法 输出结果: sonClass: son using System; namespace VirtualOverrideTest { public class ...
  • 什么是虚方法? 虚方法有什么特点? 虚方法怎么声明? 虚方法到底是怎么执行的? 虚拟类有什么规则? 虚方法有什么用?
  • C#虚方法virtual详解

    2010-09-17 21:18:00
    函数在编译期间是不被静态编译的,它的相对地址是不确定的,它会根据运行时期对象实例来动态判断要调用的函数,其中那个申明时定义的类叫申明类,那个执行时实例化的类叫实例类。如:飞禽 bird = new 麻雀();...
  • 虚方法(virtual)和抽象方法(abstract)方法的区别
  • 当类中的方法声明前加上virtual, 该方法称为虚方法虚方法可以被重载。 如果对方法使用了virtual修饰符后,将不再允许有static,abstract或override修饰符对方法进行定义。 对于非虚方法,无论被其所在类的...
  • 父类中方法如果没写virtual 则在子类中是无法使用override的 必须是对应的 不然是会报错的 父类 namespace Class { public class SuperClass { public virtual int Add(int a,int b) {
  • 前言:在前面的博文中,我介绍了C#中的虚方法与抽象方法,本博文将对两者的区别进行详细叙述。参考博文:浅谈C#虚方法与隐藏方法的区别、深究C#中的抽象类、抽象属性、抽象方法 文章目录一、虚方法的回顾二、抽象...
  • 虚方法 特点: <1>虚方法必须使用virtual修饰 <2>虚方法同抽象方法(adstract)一样使用override关键字重写 <3>...
  • C#虚方法

    热门讨论 2016-11-04 17:34:58
    不懂啊,查了查,还是不大懂,今天的C#视频中有虚方法,不能再等了,再不整懂就老了。内容虚方法:在声明的时候加上个virtual关键字,它是可以被重写的,当然是它的子类要重写它了。先写父类和子类 (这里的父类和...
  • 前言:本博文讲解了C#虚方法与隐藏方法的概念、定义以及区别。 文章目录一、虚方法1、概念讲解2、示例讲解3、总结一下二、隐藏方法1、概念讲解2、案例讲解3、总结一下三、虚方法与隐藏方法的区别1、重写和隐藏的...
  • C#虚方法解读

    千次阅读 2017-02-15 22:01:51
    C#虚方法解读
  • C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用
  • 主要介绍了C#中的虚方法和抽象方法的运用,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • C#语言视频 虚方法

    2009-05-19 16:17:58
    C#语言视频, 介绍虚方法的知识,已经如何去使用。
  • C#虚方法和抽象类的对比虚方法和抽象类的区别主要在于前者父类可以写方法而后者不可以写方法。具体代码解释如下 虚方法中父类和子类的写法/*虚方法父类*/ class 父类名 { public virtual void 方法名() { ...
  •  按照字面意思,虚方法就是虚的方法,没有任何体现,没有价值,它的由来和多态有关,多态的实现,有两种方式,两种方式取决于基类中的方法是抽象方法,还是具体实现的方法,关于这一个概念在Java和c#语言中都是相同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,984
精华内容 12,393
关键字:

c#虚方法

c# 订阅