派生类的构造函数

派生类的构造函数

abstract class GenericCustomer
{
private string name;
}

class NeverMore60Customer : GenericCustomer
{
private int highCostMinutesUsed;
}

NeverMore60Customer类继承自GenericCustomer类，构造函数都是默认的构造函数。

用new运算符实例化NeverCustomer类:

GenericCustomer cus=new NeverMore60Customer();

NeverMore60Customer实例构造和初始化的步骤：

NeverMore60Customer构造函数运行为其**直接基类**GenericCustomer运行默认构造函数，GenericCustomer的默认构造函数为其直接基类System.Object运行构造函数，System.Object没有任何基类，就运行构造函数，并把控制权返回给GenericCustomer构造函数;

GenericCustomer的构造函数将字段name初始化为null（String为引用类型）,执行结束后，将控制权返回给NeverMore60Customer类的默认构造函数；

NeverMore60Customer类的默认构造函数将字段highCostMinutesUsed初始化为0（int为值类型）。

构造函数的调用顺序，先调用System.Object，再按照层次结构由上向下进行，直到编译器要实例化的类。每个类的构造函数都初始化它自己类中的字段。

在层次结构中添加无参数的构造函数

abstract class GenericCustomer
{
private string name;
public GenericCustomer()  //如果定义为Private，会产生编译错误
: base() //这一行可以省略
{
Console.WriteLine("GenericCustomer Constructor");
}
}
class NeverMore60Customer : GenericCustomer
{
private int highCostMinutesUsed;
public NeverMore60Customer()
{
Console.WriteLine("NeverMore60Customer Constructor");
}
}

两个类中都有无参数的构造函数。

用new运算符实例化NeverCustomer类:

GenericCustomer cus=new NeverMore60Customer();

结果为：



可以看到，先调用了基类的构造函数，再调用了派生类的构造函数。

在层次结构中添加带参数的构造函数

abstract class GenericCustomer
{
private string name;
public GenericCustomer(string par)
{
name = par;
Console.WriteLine("GenericCustomer Constructor {0}",name);
}
}
class NeverMore60Customer : GenericCustomer
{
private int highCostMinutesUsed;
public NeverMore60Customer(string par)
: base(par)  //**将参数par传递给基类的构造函数**
{
Console.WriteLine("NeverMore60Customer Constructor:{0}",highCostMinutesUsed);
}
}

将NeverMore60Customer类实例化的时候，使用带参数的构造函数

GenericCustomer cus = new NeverMore60Customer("March");

执行结果为：



构造函数的重载

class NeverMore60Customer : GenericCustomer
{
private int highCostMinutesUsed;

public NeverMore60Customer(string par,int a)
: base(par)
{
highCostMinutesUsed = a;
Console.WriteLine("NeverMore60Customer Constructor:{0}",highCostMinutesUsed);
}

public NeverMore60Customer(string par)
:this(par,0)
{
Console.WriteLine("One Parameter NeverMore60Customer Constructor:{0}",              highCostMinutesUsed);
}
}

实例化两个NeverMore60Customer对象：

GenericCustomer cus = new NeverMore60Customer("March",8);
Console.WriteLine("aaaa");
GenericCustomer cus1 = new NeverMore60Customer("Ara");

执行结果如下：



第一个对象cus实例化时传入两个参数，首先控制权依次传递顺序为：

带两个参数的NeverMore60Customer构造函数

->基类GenericCustomer构造函数

->System.Object类的构造函数；

执行顺序为：

System.Object的构造函数

->GenericCustomer类的构造函数，初始化字段name为“March”，并输出相应信息

->NeverMore60Customer类的带两个参数的构造函数，初始化highCostMinutesUsed字段为8，并输出相应信息。

第二个对象cus1实例化时传入一个参数，

控制权传递顺序：

带一个参数的NeverMore60Customer构造函数

—>带两个参数的NeverMore60Customer构造函数

—>基类GenericCustomer构造函数

—>System.Object类的构造函数；

执行顺序：

System.Object的构造函数

—> GenericCustomer类的构造函数，初始化字段name为“March”，并输出相应信息

—> NeverMore60Customer类的带两个参数的构造函数，初始化highCostMinutesUsed字段为0，并输出相应信息

—> NeverMore60Customer类的带一个参数的构造函数，输出相应信息。

其中，

public NeverMore60Customer(string par)
:this(par,0)

this关键字表示调用当前类的构造函数，并传入参数par和0。

如果将该构造函数改成base关键字：

public NeverMore60Customer(string par)
:base(par)
{
Console.WriteLine("One Parameter NeverMore60Customer Constructor:{0}", highCostMinutesUsed);
}

实例化对象：

GenericCustomer cus1 = new NeverMore60Customer("Ara");

执行结果如下：



执行顺序：

System.Object的构造函数

—>GenericCustomer的构造函数，初始化name字段为“Ara”；

—>NeverMore60Customer的带一个参数的构造函数，输出相应信息。

一般情况下，总是不断地往上追溯基类，直到不再有基类为止（System.Object类），再由上至下地执行类构造函数，构造函数只初始化自己所在的类的字段，不能访问派生类中的字段；基类的字段已经由其基类的构造函数进行初始化（未显示初始化的，值类型初始化为0、bool等，引用类型初始化
4000
为null），因此派生类可以访问其基类的字段，改变基类字段的初始值，但不建议这样做，每个类的字段的初始化应该由自己类的构造函数处理。