继承

继承（加上封装和多形性）是面向对象的编程的三个主要特性（也称为“支柱”）之一。继承用于创建可重用、扩展和修改在其他类中定义的行为的新类。其成员被继承的类称为“基类”，继承这些成员的类称为“派生类”。派生类只能有一个直接基类。但是，继承是可传递的。如果 ClassB 派生出 ClassC，ClassA 派生出 ClassB，则 ClassC 会继承 ClassB 和 ClassA 中声明的成员。

从概念上来说，派生类是基类的专用化。 例如，如果您有一个基类 Animal，则可以有一个名为Mammal 的派生类和一个名为Reptile 的派生类。Mammal 是一个Animal，Reptile 也是一个Animal，但每个派生类均表示基类的不同专用化。

 

基类与派生类型理解：

如：A（1、2、3、4、5、6、7、8、9）//基类

        B（1、2、3、4、5）//派生类1

        C（5、6、7、8、9）//派生类2

        D（6、7、8、9、0、11、12、13）//派生类3

B、C、D都具有 A  的特征。

继承的传递：（还是以上面的来讲）

B（1、2、3、4、5）//本是 A   的派生类；却为 E  的基类

E(1、3、5）// B 的派生类

因为 E 为 B 的派生类 ，B 为 A    的派生类，所以 E 也为 A   的派生类

 

定义一个类从其他类派生时，派生类隐式获得基类的所有成员 ( 除 构造函数 和 析构函数 外)。因此，派生类可以重用基类中的代码而无需重新实现这些代码。可以在派生类中添加更多成员。派生类以这种方式扩展基类的功能。

下图演示一个 WorkItem 类，该类表示某业务流程中的一个工作项。和所有的类一样，该类派生自System.Object 并继承其所有方法。WorkItem 添加了自己的五个成员。其中包括一个构造函数，因为构造函数不能继承。类ChangeRequest 继承自WorkItem 并表示特定种类的工作项。ChangeRequest 在它从WorkItem 和Object 继承的成员中另外添加了两个成员。它必须添加其自己的构造函数，还添加originalItemID。利用属性originalItemID，可将ChangeRequest 实例与更改请求将应用到的原始WorkItem 相关联。

类继承

 

 下面的示例演示如何以 C# 表示上图所示的类关系。 该示例还演示 WorkItem 如何重写虚方法Object.ToString，以及ChangeRequest 类如何继承该方法的WorkItem 实现。

 

// WorkItem implicitly inherits from the Object class.
public class WorkItem
{
    // Static field currentID stores the job ID of the last WorkItem that
    // has been created.
    private static int currentID;

    //Properties.
    protected int ID { get; set; }
    protected string Title { get; set; }
    protected string Description { get; set; }
    protected TimeSpan jobLength { get; set; }

    // Default constructor. If a derived class does not invoke a base-
    // class constructor explicitly, the default constructor is called
    // implicitly. 
    public WorkItem()
    {
        ID = 0;
        Title = "Default title";
        Description = "Default description.";
        jobLength = new TimeSpan();
    }

    // Instance constructor that has three parameters.
    public WorkItem(string title, string desc, TimeSpan joblen)
    {
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = joblen;
    }

    // Static constructor to initialize the static member, currentID. This
    // constructor is called one time, automatically, before any instance
    // of WorkItem or ChangeRequest is created, or currentID is referenced.
    static WorkItem()
    {
        currentID = 0;
    }


    protected int GetNextID()
    {
        // currentID is a static field. It is incremented each time a new
        // instance of WorkItem is created.
        return ++currentID;
    }

    // Method Update enables you to update the title and job length of an
    // existing WorkItem object.
    public void Update(string title, TimeSpan joblen)
    {
        this.Title = title;
        this.jobLength = joblen;
    }

    // Virtual method override of the ToString method that is inherited
    // from System.Object.
    public override string ToString()
    {
        return String.Format("{0} - {1}", this.ID, this.Title);
    }
}

// ChangeRequest derives from WorkItem and adds a property (originalItemID) 
// and two constructors.
public class ChangeRequest : WorkItem
{
    protected int originalItemID { get; set; }

    // Constructors. Because neither constructor calls a base-class 
    // constructor explicitly, the default constructor in the base class
    // is called implicitly. The base class must contain a default 
    // constructor.

    // Default constructor for the derived class.
    public ChangeRequest() { }

    // Instance constructor that has four parameters.
    public ChangeRequest(string title, string desc, TimeSpan jobLen,
                         int originalID)
    {
        // The following properties and the GetNexID method are inherited 
        // from WorkItem.
        this.ID = GetNextID();
        this.Title = title;
        this.Description = desc;
        this.jobLength = jobLen;

        // Property originalItemId is a member of ChangeRequest, but not 
        // of WorkItem.
        this.originalItemID = originalID;
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of WorkItem by using the constructor in the 
        // base class that takes three arguments.
        WorkItem item = new WorkItem("Fix Bugs",
                                     "Fix all bugs in my code branch",
                                     new TimeSpan(3, 4, 0, 0));

        // Create an instance of ChangeRequest by using the constructor in
        // the derived class that takes four arguments.
        ChangeRequest change = new ChangeRequest("Change Base Class Design",
                                                 "Add members to the class",
                                                 new TimeSpan(4, 0, 0),
                                                 1);

        // Use the ToString method defined in WorkItem.
        Console.WriteLine(item.ToString());

        // Use the inherited Update method to change the title of the 
        // ChangeRequest object.
        change.Update("Change the Design of the Base Class",
            new TimeSpan(4, 0, 0));

        // ChangeRequest inherits WorkItem's override of ToString.
        Console.WriteLine(change.ToString());

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    1 - Fix Bugs
    2 - Change the Design of the Base Class
*/