看视频中讲到 重写父类的方法的时候 一种是在子类方法的 访问修饰符后加 new
另一种是声明父类的虚方法 再用override重写
请问这两种方法有何不同？优劣何在？谢谢

一个override 是重写
一个new 是显示隐藏基类

如果基类的方法是virtual 的。
所以子类必须重写基类的方法，也就是必须隐藏基类的方法。
给你看下区别的代码

1. using System ;
   
2. public class MyBase
   
3. {
   
4.      public static int x = 55 ;
   
5.      public static int y = 22 ;
   
6. }
   
7. public class MyDerived : MyBase
   
8. {
   
9.      new public static int x = 100; // 利用new 隐藏基类的x
   
10.      public static void Main()
    
11.     {
    
12.      // 打印x:
    
13.      Console.WriteLine(x);
    
14.      //访问隐藏基类的 x:
    
15.      Console.WriteLine(MyBase.x);
    
16.      //打印不隐藏的y:
    
17.      Console.WriteLine(y);
    
18.      }
    
19. }
    
20. 
    
21. //这个是调用父类的方法
    
22. using System;
    
23. public class Parent
    
24. {
    
25.     string parentString;
    
26.     public Parent()
    
27.     { Console.WriteLine("Parent Constructor."); }
    
28.     public Parent(string myString)
    
29.     {
    
30.         parentString = myString;
    
31.         Console.WriteLine(parentString);
    
32.     }
    
33.     public void print()
    
34.     { Console.WriteLine("I'm a Parent Class."); }
    
35. }
    
36. public class Child : Parent
    
37. {
    
38.     public Child()
    
39.         : base("From Derived")
    
40.     { Console.WriteLine("Child Constructor."); }
    
41.     public void print()
    
42.     {
    
43.         base.print();
    
44.         Console.WriteLine("I'm a Child Class.");
    
45.     }
    
46.     public static void Main()
    
47.     {
    
48.         Child child = new Child();
    
49.         child.print();
    
50.         ((Parent)child).print();
    
51.     }
    
52. }

复制代码

     当子类从基类继承时,它会获得基类的所有方法、字段、属性和事件。若要更改基类的数据和行为，有两种方法：
    1.override 重写虚拟的基类方法；
    2.new 使用新的派生成员替换基类的方法；
    两者的区别在于。override 会直接“覆盖掉基类的方法”；而new后，没有使用到基类的方法,而是直接重新定义了子类的方法。
    例如：

1. using System;
   
2. using System.Text;
   
3. 
   
4. namespace over
   
5. {
   
6.     class Program
   
7.     {
   
8.         static void Main(string[] args)
   
9.         {
   
10.             BaseClass bc = new BaseClass();  
    
11.             DerivedClass dc = new DerivedClass();
    
12.             BaseClass bcdc = new DerivedClass();//使用子类的对象实例化基类的对象;
    
13.             bc.Method1();
    
14.             bc.Method2();
    
15. 
    
16.             dc.Method1();
    
17.             dc.Method2();
    
18. 
    
19.             bcdc.Method1();
    
20.             bcdc.Method2();
    
21.             Console.ReadLine();
    
22.         }
    
23.     }
    
24. 
    
25.     class BaseClass
    
26.     {
    
27.         public virtual void Method1()  //基类虚方法1
    
28.         {
    
29.             Console.WriteLine("基类.Method1");
    
30.         }
    
31. 
    
32.         public virtual void Method2()   //基类虚方法2
    
33.         {
    
34.             Console.WriteLine("基类.Method2");
    
35.         }
    
36.     }
    
37. 
    
38.     class DerivedClass : BaseClass
    
39.     {
    
40.         public override void Method1() //override
    
41.         {
    
42.             Console.WriteLine("子类.Method1");
    
43.         }
    
44. 
    
45.         public new void Method2()  //new
    
46.         {
    
47.             Console.WriteLine("子类.Method2");
    
48.         }
    
49.     }
    
50. }

复制代码

         结果为：基类.Method1
                       基类.Method2
                       子类.Method1
                       子类.Method2
                       子类.Method1
                       基类.Method2