C#中的重载，重写，构造函数⾃我理解：
重载：在同⼀类中，参数不同的同名函数，主要⽤于传⼊不同参数时执⾏执⾏不同的效果。
例如：⼀对重载函数，⼀个参数传⼊字符串，另⼀个传⼊整数。
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.    }
输出为：string int
重写：⼦类继承⽗类时，和⽗类函数的名称，参数，参数类型都相同，但函数内部不同。
例如：
1. using System.Collections.Generic;
2. using System.Linq;
3. using System.Text;
4.
5. namespace OverrideTest
6. {
7. class Program
8.    {
writeline函数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();
}
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。