重写是指重写基类的方法，在基类中的方法必须有修饰符virtual，而在子类的方法中必须指明override。
格式：
基类中：
public virtual void myMethod()
{
}
子类中：
public override void myMethod()
{
}
重写以后，用基类对象和子类对象访问myMethod()方法，结果都是访问在子类中重新定义的方法，基类的方法相当于被覆盖掉了。

重载
用于在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。
public void test(int x,int y){}

public void test(int x,ref int y){}

public void test(int x,int y,string a){}
重载特征：

I.方法名必须相同

II.参数列表必须不相同，与参数列表的顺序无关

III.返回值类型可以不相同
=========================
但如果有泛型，就要注意了！

多态
c#的多态性主要体现在类的继承上:
子类继承父类的时候,可能出现同名但方法定义不同的情况,
所以在子类中会将原方法覆盖,实现自身的要求

 1 /*
 2     Function: override
 3 */
 4 using System;
 5 namespace TestOverride
 6 {
 7     class Employee
 8     {
 9         //父类虚方法
10         public virtual void CalculatePay()
11         {
12             Console.WriteLine("Employee");
13         }        
14     }
15     
16        //子类继承重写CalculatePay()方法
17     class SalariedEmploy : Employee
18     {
19         public override void CalculatePay()
20         {
21             Console.WriteLine("Salary");
22         }
23     }
24     
25     class AppPay
26     {
27         public static void Main(String[] args)
28         {
29             //父类创建实例
30             Employee employee1 = new Employee();
31             employee1.CalculatePay();                                     //Employee
32                 
33             //子类赋值给父类
34             Employee employee2 = new SalariedEmploy();
35             employee2.CalculatePay();                                     // Salary
36             
37             //子类创建实例
38             SalariedEmploy employee3 = new SalariedEmploy();
39             employee3.CalculatePay();                                    //Salary
40             
41         }        
42     }
43 }
44 /*
45 Out:
46 Employe
47 Salary
48 Salary
49 */

*****************************************************************************************************************

overload：重载指的是同一个类中有两个或多个名字相同但是参数不同的方法，(注:返回值不能区别函数是否重载)，重载没有关键字。
override：过载也称重写是指子类对父类中虚函数或抽象函数的“覆盖”（这也就是有些书将过载翻译为覆盖的原因），但是这种“覆盖”和用new关键字来覆盖是有区别的。
new：覆盖指的是不同类中（基类或派生类）有两个或多个返回类型、方法名、参数都相同，但是方法体不同的方法。
但是这种覆盖是一种表面上的覆盖，所以也叫隐藏，被覆盖的父类方法是可以调用得到的。
重载覆盖的发生条件：
重载,必然发生在一个类中,函数名相同,参数类型或者顺序不同构成重载,与返回类型无关
重写,必然发生在基类和派生类中,其类函数用virtual修饰,派生类用override修饰
覆盖,在子类中写一个和基类一样名字(参数不同也算)的非虚函数,会让基类中的函数被隐藏,编译后会提示要求使用New关键字
重载示例：

        public void Fun()
        {
            Console.WriteLine("I am F");
        }
public  void Fun(int i)
        {
            Console.WriteLine("I am F,i={0}",i);
        }

override重写特性：

    class A
    {
public void Fun()
        {
            Console.WriteLine("I am F");
        }
    }
class Program:A
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            p.Fun();
            Console.Read();
        }
    }
//结果为：I am F

当我们覆盖原来的方法呢？

    class A
    {
public void Fun()
        {
            Console.WriteLine("I am F");
        }
    }
class Program:A
    {
public new void Fun()
        {
int i = 1;
            Console.WriteLine("I am F,i={0}", i);
        }
static void Main(string[] args)
        {
            Program p = new Program();
            p.Fun();
            Console.Read();
        }
    }
//结果为：I am F,i=1

new覆盖与重写、重载的区别：
当子类与父类的参数不同时
当基类函数不是虚函数时，基类函数将被隐藏。（因为子类和基类不在同一范围内，所以不是重载）
当基类函数是虚函数时，基类函数将被隐藏。（因为子类和基类不在同一范围内，所以不是重载；因为参数不同，所以不是重写）
当子类与父类的参数相同时
当基类函数不是虚函数时，基类函数将被隐藏。（因为子类和基类不在同一范围内，所以不是重载，因为基类不是虚函数，所以是隐藏不是重写）
当基类函数是虚函数时，基类函数将被覆盖。（因为子类和基类不在同一范围内，所以不是重载）
那么为什么不是重写呢？我们可以做一个例子还测试一下，这个例子在虚函数时已经举过，在这里为了说明此问题在重复一下：

    class A
    {
public virtual void Fun()
        {
            Console.WriteLine("I am F");
        }
    }
class Program:A
    {
public override void Fun()
        {
int i = 1;
            Console.WriteLine("I am F,i={0}", i);
        }
static void Main(string[] args)
        {
            A p = new Program();
            p.Fun();
            Console.Read();
        }
    }

我们知道，以上例子中，派生类存在一个对基类的重写方法，所以结果为：I am F ,i=1
若是我们把override换成new，那么如果是重写的话，会和上面的结果相等，但实际结果是什么呢?
实际的结果是：I am F
由此我们知道，当基类函数是虚函数时，基类函数不是重写，而是覆盖了基函数的同名函数。

文章出处：http://www.cnblogs.com/jiajiayuan/archive/2011/09/15/2177051.html