C# 如何定义构造函数

定义：
通用语言运行时CLR要求每个类都有一个构造函数。构造函数是一个有特殊用途的方法，第一次引用时会初始化类或类实例。

分类：

实例构造函数（instance）、私有构造函数（private，实例构造函数的一种特殊情况）和静态构造函数（static）。

构造函数没有返回数据类型，且增加了一个initializer(初始化调用)的选项，其余和一般方法没有区别，不过还有一些约束

1，构造函数必须与类名相同

2，通过initializer在构造函数体前调用基类或者本类的另一个构造函数的方法

a，base(argument list) -调用基类构造函数

b，this(argument list) 调用这个类的另一个构造函数

3，如果类没有写构造函数，编译器将会给类创造一个无参的构造函数

实例化类的时候其实就是调用了构造函数：

如 ：

Test t=new Test();//调用默认的空构造函数

Test tt=new Test(test);//调用了有一个参数的构造函数

私有构造函数：

我们知道对类成员用private修饰时候，是为了不允许在类外的范围这个成员，

那么，用private修饰构造函数的时候，是为禁止实例化这个类的功能，如果一个类只提供静态的方法和字段，就可以使用私有构造函数，注：使用了私有构造函数不能被也不会被继承，不过在类中可以对自己进行实例化~可以提供一个工厂方法创建对象

静态构造函数：

主要作用是初始化静态类成员，

限制：不能有参数，不能重载（一个类只能有一个静态构造函数） 性必须是private，不能调用其他构造函数，只 能类中的静态成员，注意和默认的无参数的构造函数进行区分

下面的代码是我练习的时候写的简单的使用例子：

using System;

using System.Collections.Generic;

using System.Text;

namespace ConsoleApplication1

{

class A

{

public A(){} //这个构造函数编译器会自己添加，写和不写一样

private string _firstName;

private string _lastName;

public A(string firstName， string lastName) {

this._firstName = firstName;

this._lastName = lastName;

}

public string FirstName

{

set

{

_firstName = value;

}

get

{

return _firstName;

}

}

public string LastName

{

get { return _lastName; }

set { _lastName = value; }

}

public override string ToString() //重写了object的ToString()方法

{

return My Name is +_firstName+ + _lastName;

}

};

class B : A

{

private string title;

public string Titel

{

get { return title; }

set { title = value; }

}

public B(string firstName， string lastName， string title):base(firstName，lastName)// 这里调用了基类的构造函数

{

this.title = title;

}

public override string ToString()

{

return base.ToString()+，And my title is +this.title;

}

}

class C:A

{

private string _title;

public string Titel

{

get { return _title; }

set { _title = value; }

}

private string _level;

public string Level

{

get { return _level; }

set { _level = value; }

}

public C(string firstName， string lastNamt， string title)

: base(firstName， lastNamt)

{

this._title = title;

}

public C(string firstName， string lastName， string title， string level)

: this(firstName， lastName， title)//调用了自己的另一个构造函数

{

this._level = level;

}

public override string ToString()

{

if(this._level==null){

return base.ToString()+， And My Title is +this._title;

}else{

return base.ToString()+， My Title is +this._title +， And My Level is +this._level;

}

}

}

//私有构造函数

class D

{

private D()

{

}

//后补充

public staic D CreateD=new D();

private static string _name;

public static string Name

{

get { return _name; }

set { _name = value; }

}

private static int _age;

public static int Age

{

get { return _age; }

set { _age = value; }

}

public static new string ToString()

{

return My Name is + _name + ， and I;m + _age.ToString();

}

}

//静态构造函数类

class E

{

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 title;

public string Title

{

get { return title; }

set { title = value; }

}

private static int i;

static E()

{

Console.WriteLine(Static 构造函数+i);

}

public E()

{

i += 1;

Console.WriteLine( 普通 构造函数 + i);

}

public E(string name， int age)

{

this.name = name;

this.age = age;

hell_boy7 的回答就很好。
基本上怎么使用都覆盖了。

我也来画蛇添足一下。

一，构造函数是做什么用的：
构造函数一般都需要做初始化
比如field成员的初始化。
public class MyClass
{
private int _Age;
private string _Name;

public MyClass( string Name, int Age )
{
_Age = Age;
_Name = Name;
}
}

但是由于经常一个类的构造函数有很多
比如上面的类可以有
public MyClass( string Name, int Age )
public MyClass( string Name)
public MyClass( )
这三种构造函数。
如果field的结构比较复杂。
这三函数需要写三套的初始化代码。
于是比较通用的，用一个最全的函数去初始化
然后其他函数都去调用它。比如
public class MyClass

{

private int _Age;

private string _Name;

public MyClass( string Name)

{

InitMember( Name, 20 );

}

public MyClass( string Name, int Age )

{

InitMember( Name, Age );

}

///

/// Init class members

///

///

///

private void InitMember( string Name, int Age )

{

_Age = Age;

_Name = Name;

}

}
不过，在C#中提供了更为简明的方法，就是在构造函数初始化语句中调用另一构造函数，那么上面的形式可以改写为如下这样。

public class MyClass

{

private int _Age;

private string _Name;

public MyClass( string Name):this( Name, 20 )

{

}

public MyClass( string Name, int Age )

{

_Age = Age;

_Name = Name;

}

}

对于这两者来说，执行效率没有太大差别，但从代码质量而言，后者要好很多，而且会使代码看起来更清晰。

其次，对于基类的调用。由于成员函数不能调用基类的构造函数，所以对于第一种编写就比较困难，后者就简单多了。

例如：

public class MyClass:BaseClass

{

private int _Age;

private string _Name;

public MyClass( string Name):this( Name, 20 )

{

}

public MyClass( string Name, int Age ):base( Name, Age )

{

_Age = Age;

_Name = Name;

}

}

这里要提的一点就是构造函数初始化语句，对于“this”或者“base”之类的调用只能有一个，不能并存。

最后，就是对于readonly常量的初始化，由于readonly常量只能通过成员初始化语句或者在构造函数中被修改，因此在成员函数中无法修改readonly常量，这也是构造函数初始化语句要比成员函数好的重要一个因素。

class lei
｛
public lei()----->构造函数
｛

｝
public(int a,string b,flaot c,double d)--->带参数
｛

｝

｝