1 public virtual void myMethod()
2 {
3 }

1 public override void myMethod()
2 {
3 }

1 public void test(intx,inty){}
2
3 public void test(intx,refinty){}
4
5 public void test(intx,inty,stringa){}

代码public class Animal{public virtual void Eat(){Console.WriteLine("Animal eat");}}public class Cat : Animal{public override void Eat(){Console.WriteLine("Cat eat");}}public class Dog : Animal{public override void Eat(){Console.WriteLine("Dog eat");}}class Tester{static void Main(string[] args){Animal[] animals = new Animal[3];animals[0] = new Animal();animals[1] = new Cat();animals[2] = new Dog();for (int i = 0; i < 3; i++){animals[i].Eat();}}}

 1 代码
 2
 3 public class Animal
 4     {
 5         public virtual void Eat()
 6         {
 7             Console.WriteLine("Animal eat");
 8         }
 9     }
10
11     public class Dog : Animal
12     {
13         public override void Eat()
14         {
15             Console.WriteLine("Dog eat");
16         }
17     }
18
19     public class WolfDog : Dog
20     {
21         public override void Eat()
22         {
23             Console.WriteLine("WolfDog eat");
24         }
25     }
26
27     class Tester
28     {
29         static void Main(string[] args)
30         {
31             Animal[] animals = new Animal[3];
32
33             animals[0] = new Animal();
34             animals[1] = new Dog();
35             animals[2] = new WolfDog();
36
37             for (int i = 0; i < 3; i++)
38             {
39                 animals[i].Eat();
40             }
41         }
42 }

 1 代码
 2
 3     public abstract class Animal
 4     {
 5 　　　   public abstract void Eat();
 6     }
 7
 8     public class Cat : Animal
 9     {
10         public override void Eat()
11         {
12             Console.WriteLine("Cat eat");
13         }
14     }
15
16     public class Dog : Animal
17     {
18         public override void Eat()
19         {
20             Console.WriteLine("Dog eat");
21         }
22     }
23
24     public class WolfDog : Dog
25     {
26         public override void Eat()
27         {
28             Console.WriteLine("Wolfdog eat");
29         }
30     }
31
32     class Tester
33     {
34         static void Main(string[] args)
35         {
36             Animal[] animals = new Animal[3];
37
38             animals[0] = new Cat();
39             animals[1] = new Dog();
40             animals[2] = new WolfDog();
41
42             for (int i = 0; i < animals.Length; i++)
43             {
44                 animals[i].Eat();
45             }
46         }
47     }

静态类与非静态类的重要区别在于静态类不能实例化，也就是说，不能使用 new 关键字创建静态类类型的变量。在声明一个类时使用static关键字，具有两个方面的意义：首先，它防止程序员写代码来实例化该静态类；其次，它防止在类的内部声明任何实例字段或方法。

静态类是自C# 2.0才引入的，C# 1.0不支持静态类声明。程序员必须声明一个私有构造器。私有构造器禁止开发者在类的范围之外实例化类的实例。使用私有构造器的效果与使用静态类的效果非常相似。

两者的区别：
私有构造器方式仍然可以从类的内部对类进行实例化，而静态类禁止从任何地方实例化类，其中包括从类自身内部。静态类和使用私有构造器的另一个区别在于，在 使用私有构造器的类中，是允许有实例成员的，而C# 2.0和更高版本的编译器不允许静态类有任何实例成员。使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员，编译器将保证不会创建此 类的实例。静态类的另一个特征在于，C#编译器会自动把它标记为sealed。这个关键字将类指定为不可扩展；换言之，不能从它派生出其他类。

静态类的主要特性：
1：仅包含静态成员。
2：无法实例化。
3：是密封的。
4：不能包含实例构造函数。

静态成员

1：非静态类可以包含静态的方法、字段、属性或事件；
2：无论对一个类创建多少个实例，它的静态成员都只有一个副本；
3：静态方法和属性不能访问其包含类型中的非静态字段和事件，并且不能访问任何对象的实例变量；
4：静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员；
5：虽然字段不能声明为 static const，但 const 字段的行为在本质上是静态的。这样的字段属于类，不属于类的实例。因此，可以同对待静态字段一样使用 ClassName.MemberName 表示法来访问 const 字段；

6：C# 不支持静态局部变量(在方法内部定义静态变量)。

静态构造函数

1：静态类可以有静态构造函数，静态构造函数不可继承；
2：静态构造函数可以用于静态类，也可用于非静态类；
3：静态构造函数无访问修饰符、无参数，只有一个 static 标志；
4：静态构造函数不可被直接调用，当创建类实例或引用任何静态成员之前，静态构造函数被自动执行，并且只执行一次。

注意：
1：静态类在内存中是一直有位置的；
2：非静态类在实例化后是在内存中是独立的，它的变量不会重复，在使用后会及时销毁，所以不会出现未知的错误。在C#中静态成员是比较敏感的东西，在不是十分确认的情况下不要使用；
3：建议更多地使用一般类(非静态类)。

使用选择：
当定义的类不需要进行实例化时，我们使用静态类；如果需要实例化对象，需要继承等特性时，应该使用非静态类，并且将统一使用的变量和方法设为静态的，那么所有实例对象都能访问。