C#中虚方法主要应用在哪些场合

个人观点：望牛人纠正，以求得进步
面向对象的三要素：
封装，继承，多态
多态实现方式又分三种：
虚方法，抽象类，接口
虚方法单独出现没有意义：在面向过程中，根本没有虚方法，但程序也照样出来了
所以说虚方法是一种思想：（只有在程序员眼里）
必须结合继承、里氏转换、重写、才能体现虚方法，而且这种体现只是在代码编写上，而不是实际的算法上有什么改进

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. using System.Threading.Tasks;
   
6. 
   
7. namespace 虚方法
   
8. {
   
9.     public class Daddy
   
10.     {
    
11.         public virtual void Play()//虚方法
    
12.         {
    
13.             Console.WriteLine("Daddy");
    
14.         }
    
15.     }
    
16.     public class Son1 : Daddy
    
17.     {
    
18.         //public new void Play()//没有加override
    
19.         //{
    
20.         //    Console.WriteLine("Son1");
    
21.         //}
    
22.         public void Play()//没有加override//这里为什么提示加new 不明白
    
23.         {
    
24.             Console.WriteLine("Son1");
    
25.         }
    
26.         public void Fun()
    
27.         {
    
28.             Console.WriteLine("Son1");
    
29.         }
    
30.     }
    
31.     public class Son2 : Daddy
    
32.     {
    
33.         public override void Play()
    
34.         {
    
35.             base.Play();
    
36.         }
    
37.         public void Fun()
    
38.         {
    
39.             Console.WriteLine("Son2");
    
40.         }
    
41.     }
    
42.     public class Son3 : Daddy
    
43.     {
    
44.         public override void Play()
    
45.         {
    
46.             Console.WriteLine("Son3");
    
47.         }
    
48.         public void Fun()
    
49.         {
    
50.             Console.WriteLine("Son3");
    
51.         }
    
52.     }
    
53.     class Program
    
54.     {
    
55.         static void Main(string[] args)
    
56.         {
    
57.             Daddy dd = new Daddy();
    
58.             //子类可以赋值给父类
    
59.             Daddy dd1 = new Son1();
    
60.             Daddy dd2 = new Son2();
    
61.             Daddy dd3 = new Son3();
    
62.             dd.Play();
    
63.             Console.WriteLine("============");
    
64.             dd1.Play();
    
65.             dd2.Play();
    
66.             dd3.Play();
    
67.             Console.WriteLine("===========");
    
68.             Son1 ss1 = new Son1();
    
69.             Son2 ss2 = new Son2();
    
70.             Son3 ss3 = new Son3();
    
71.             ss1.Play();
    
72.             ss2.Play();
    
73.             ss3.Play();
    
74.             Console.WriteLine("==============");
    
75.             ss1.Fun();
    
76.             ss2.Fun();
    
77.             ss3.Fun();
    
78.         }
    
79.     }
    
80. }
    

复制代码

下面列举代码：你自己看看吧

1、虚方法必须有实现部分，抽象方法不可以有实现部分；
2、虚方法可以在派生类中重写也可以不重写，抽象方法必须在派生类中重写
3、虚方法可以在任何非密封类中声明，抽象方法只能在抽象类中声明。
4、如果类包含抽象方法，那么该类也必须为抽象的，不能实例化。
虚方法，在父类里面是有代码的，那么如果没子类，父类依然可以干活，如果子类override了这个虚方法，子类的方法将替代这个方法。
抽象方法，在父类里面是个没实现的东西，更加像个说明，子类必须实现这个方法的内容，不然子类也要声明为抽象类。
简单的说，如果你感觉父类的这个方法可以有代码，那么把他声明为虚的，如果你感觉，父类是个超级抽象的概念，方法没有实现代码，需要子类自己实现，那么你用抽象方法。

虚方法virtual是实现多态的主要手段之一
什么时候用虚方法，子类中可以不重写。
1.父类本身需要被实例化。
2.这个方法在父类中有实现的必要（有意义）（方法有默认的实现。）
例如这道题：

1.     class Person
   
2.     {
   
3.         public virtual void SayHello()
   
4.         {
   
5.         Console.WriteLine("你好，我是一名学生");
   
6.         }
   
7.     }
   
8.     class Teacher:Person
   
9.     {
   
10.         public override void SayHello()
    
11.         {
    
12.             Console.WriteLine("你好，我是一名老师");
    
13.         }
    
14.     }
    
15.     class Dirver : Person
    
16.     {
    
17.         public override void SayHello()
    
18.         {
    
19.             Console.WriteLine("你好，我是一名司机");
    
20.         }
    
21.     }

复制代码

就是把Person类中的SayHello改为虚方法让其默认为学生的，增加了老师、司机类。
另外关于虚方法需要注意的几点：
1.父类中如果有方法需要让子类重写，则可以将该方法标记为virtual
2.虚方法在父类中必须有实现，哪怕是空实现。
3.虚方法子类可以重写（override），也可以不重写。

在表现多态上用的比较多，父类中有方法加virtual标签，子类中可以声明一个同名的方法用override修饰，可以重写这个方法，也可以保持原样，如果将类实例化，相同方法在不同类型，不同对象上表现的行为也有不同，这也表现出了面向过程多态的概念，给你个例子。
    class Program
    {
        static void Main(string[] args)
        {
            A Str = new A();
            Str.a();
            B str = new B();
            str.a();
            Console.ReadKey();
        }
        class A
        {
           public virtual void a()
            {
                Console.WriteLine("a");           
            }
        }
        class B:A
        {
           public override void a()
            {         
                Console.WriteLine("b");
            }
        }
    同样的方法经过重写，在不同对象上表现不同