举几个简单的例子给我解释下构造函数，以及用法，尽可能的详细

构造函数就是：：：类名和方法名相同

构造函数是用来创建对象的特殊方法
方法名和类名一样,没有返回值不用void
构造函数可以重载  就是有多个参数不同的构造函数
这是视频上的一个例子


namespace 构造函数
{
    class Program
    {
        static void Main(string[] args)
        {
            person p1=new person("zs",18,"nan",80);
            p1.SayHello();
            Console.ReadKey();
        }
    }
    class person
    {
        public person(string name, int age, string sex)//重载
        {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        public person(string name, int age, string sex, int en)
        {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.en = en;
        }
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;

        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private string sex;

        public string Sex
        {
            get { return sex; }
            set { sex = value; }
        }
        private int en;

        public int En
        {
            get { return en; }
            set { en = value; }
        }
        public void SayHello()
        {
            Console.WriteLine("我叫{0},今年{1},我是{2}的,我的英语成绩{3}", this.name, this.age, this.sex, this.en);
        }
    }
}

构造函数是一种特殊的方法成员，构造函数的主要作用是是在创建对象时初始化对象。一个类定义必须至少有一个构造函数，如果定义类时，没有声明构造函数，系统会提供一个默认的构造函数，如，数值类型被初始化为0，字符类型被初始化为空格，字符串类型被初始化为null，逻辑类型被初始化为false等。
举个例子
创建个类

1. using System
   
2. class Student
   
3.         {
   
4.             public string id;
   
5.             public string name;
   
6.             public bool sex;
   
7.             public int age;
   
8.         }

复制代码

构造函数为默认。
在主函数中 Student s1 = new Student();数据成员不赋值下你可以输出结果看看。
如果不用默认构造函数
则创建的类为

1. class Student
   
2.         {
   
3.             public string id;
   
4.             public string name;
   
5.             public string sex;
   
6.             public int age;
   
7.             public Student(string ID, string nname, string ssex, int aage)
   
8.             {
   
9.                 id = ID;
   
10.                 name = nname;
    
11.                 sex = ssex;
    
12.                 age = aage;
    
13.             }
    
14.         }

复制代码

此时在主函数中 Student s1 = new Student("1","tom","girl",21);括号里边不能为空，new字后面实际上是对构造函数的调用。
这就是构造函数的用法。

(1)构造函数是用来创建对象的特殊方法，方法名和类名一样，没有返回值，连void都不用
(2)构造函数可以有参数，new对象的时候传递函数参数即可
(3)如果不指定构造函数，则类有一个默认的无参构造函数
如果指定了构造函数，则不再有默认的无参构造函数，如果需要无参构造函数，则需要自己来写
(4)构造函数可以重载，也就是说有多个参数不同的构造函数
例子：

1. //写一个Ticket类，有一个距离属性（本属性只读，在构造方法中赋值），不能为负数，
   
2.     //有一个价格属性，价格属性只读，并且根据距离计算价格（1元/公里）：
   
3.     //0-100公里      票价不打折
   
4.     //101-200公里    总额打9.5折
   
5.     //201-300公里    总额打9折
   
6.     //300公里以上    总额打8折
   
7.     //有一个方法可以显示这张票的信息
   
8.     class Ticket    //构造函数
   
9.     {
   
10.         //构造方法 目的：距离只能读不能改  实例化的时候赋一次值以后不允许改变
    
11.         public Ticket(int dis)
    
12.         {
    
13.             this.dis = dis;//this.dis表示当前这个类的dis字段,后面的dis表示传递的参数
    
14. 
    
15. 
    
16.         }
    
17. 
    
18.         int dis;
    
19. 
    
20.         public int Dis
    
21.         {
    
22.             get
    
23.             {
    
24.                 if (dis >= 0)
    
25.                 {
    
26.                     return dis;
    
27.                 }
    
28.                 else
    
29.                 {
    
30.                     dis = 0;
    
31.                     return dis;
    
32.                 }
    
33.             }
    
34.             
    
35.         }
    
36. 
    
37. 
    
38.         double price=1.0;
    
39. 
    
40.         public double Price
    
41.         {
    
42.             get { return price; }
    
43.            
    
44.         }
    
45. 
    
46.         public void ShowPrice()
    
47.         {
    
48.             if (dis > 0 && dis < 100)
    
49.             {
    
50.                 Console.WriteLine("距离为{0}，票价为{1}",dis,price*dis);
    
51.             }
    
52.             if (dis > 100 && dis < 200)
    
53.             {
    
54.                 Console.WriteLine("距离为{0}，票价为{1}", dis, price * dis * 9.5);
    
55.             }
    
56.             if (dis > 200 && dis < 300)
    
57.             {
    
58.                 Console.WriteLine("距离为{0}，票价为{1}", dis, dis * price * 9.0);
    
59.             }
    
60.             if (dis > 300)
    
61.             {
    
62.                 Console.WriteLine("距离为{0}，票价为{1}", dis, price * dis * 8.0);
    
63.             }
    
64. 
    
65.         }
    
66.     }

复制代码

构造函数就是与类名相同的方法

1，构造函数具有与类相同的名称，它通常初始化新对象的数据成员；
2，不带参数的构造函数称为“默认构造函数”；
public class City
{
      private string name;
      public City()//默认构造函数
     {
   
      }
      public City(string name)//带参数的构造函数
     {
         this.name = name;
      }
}
3，构造函数的名字必须与类同名;
4，构造函数没有返回类型,它可以带参数,也可以不带参数;
5，声明类对象时,系统自动调用构造函数,构造函数不能被显式调用;
6，构造函数可以重载,从而提供初始化类对象的不同方法;
7，若在声明时未定义构造函数,系统会自动生成默认的构造函数,此时构造函数的函数体为空.
8，静态构造函数,用static修饰，用于初始化静态变量，一个类只允许有一个构造函数，在类实例化时加载，这时修饰符public、private失去作用.
9，可以使用public、protected、private修饰符。.
10，引用父类构造时用（）：base（）方法，引用自身重载的构造使用（）：this（int para）.
11，可以使用public、protected、private修饰符。