自我理解：

重载：在同一类中，参数不同的同名函数，主要用于传入不同参数时执行执行不同的效果。

例如：一对重载函数，一个参数传入字符串，另一个传入整数。

1. using System.Collections.Generic;  
2. using System.Linq;  
3. using System.Text;  
4.   
5. namespace 重载  
6. {  
7.     class Program  
8.     {  
9.         static void Main(string[] args)  
10.         {  
11.             string s = null;  
12.             show(s);  
13.             int a = 123;  
14.             show(a);  
15.         }  
16.           
17.             static void show(string s)  
18.             {  
19.                 Console.WriteLine("string");  
20.             }  
21.             static void show(int o)  
22.             {  
23.                 Console.WriteLine("int");  
24.             }  
25.         }  
26.     }

重写：子类继承父类时，和父类函数的名称，参数，参数类型都相同，但函数内部不同。

例如：

1. using System.Collections.Generic;  
2. using System.Linq;  
3. using System.Text;  
4.   
5. namespace OverrideTest  
6. {  
7.     class Program  
8.     {  
9.         static void Main(string[] args)  
10.         {  
11.             my HHX = new my();  
12.             HHX.talk();  
13.         }  
14.         public class you  
15.         {  
16.             public virtual void talk()  
17.             {  
18.                 Console.WriteLine("one");  
19.             }  
20.         }  
21.         public class my : you  
22.         {  
23.             public override void talk()  
24.             {  
25.                 Console.WriteLine("two");  
26.             }  
27.         }  
28.     }  
29. }

    输出为：two

构造函数：实例构造函数，静态构造函数，私有构造函数

实例构造函数：

构造函数和类名相同，使用new创建类对象的时候会调用构造函数，初始化新对象的数据成员。

非静态类会生成一个默认的构造函数，并初始化。

构造函数可以有参数，可以存在多个构造函数。

class CoOrds
{
    public int x, y;
    // 实例构造函数（默认构造函数）
    public CoOrds()
    {
        x = 0;
        y = 0;
    }
    // 具有两个参数的构造函数
    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
    // 重写toString方法
    public override string ToString()
    {
        return (String.Format("({0},{1})", x, y));
    }
    static void Main(string[] args)
    {
        CoOrds p1 = new CoOrds();
        CoOrds p2 = new CoOrds(5, 3);

        // 使用重写ToString方法显示结果
        Console.WriteLine("CoOrds #1 at {0}", p1);
        Console.WriteLine("CoOrds #2 at {0}", p2);
        Console.ReadKey();
    }
}

静态构造函数：

不可主动调用，无修饰符，无参，创建第一个实例或者调用静态成员之前会自动调用静态都早函数初始化。

class TestClass
{
    public static int x = 0;
    //构造函数
    TestClass()
    {
        x = 1;
    }
    //静态构造函数
    static TestClass()
    {
//第二步，执行x = 2
        x = 2;
    }
//第一步，程序入口Main最先执行。然后执行public static int x = 0 接着执行静态构造函数。
    public static void Main(string[] args)
    {
        Console.WriteLine("x:{0}", x); //打印，x = 2
        TestClass Test = new TestClass();//第三步执行构造函数，此时x = 1
        Console.WriteLine("x:{0}", x); //打印 x = 1
        Console.Read();
    }
}

私有构造函数：

私有构造函数是一种特殊的实例构造函数。 它通常用于只包含静态成员的类中。 如果类具有一个或多个私有构造函数而没有公共构造函数，则其他类（除嵌套类外）无法创建该类的实例。

public class PrivateConstructor
{
    private PrivateConstructor()
    {
        //PrivateTest a = new PrivateTest(); //注释打开会报错，错误信息：不可访问，因为它受保护级别限制。因为私有构造函数无法在类的外面实例化。
    }
    public class PrivateTest
    {
        int i;
        private PrivateTest()
        {
            i = 3;
        }
        static void Main(string[] args)
        {
            PrivateConstructor t = new PrivateConstructor(); //嵌套类允许实例化。
            PrivateTest p = new PrivateTest(); //类的内部允许实例化。
            Console.WriteLine("i:{0}", p.i); //结果：i：3
            Console.Read();
        }
    }
}