part01.01 C#基础语法与逻辑控制（五）（7. C# 继承和接口）

C# 继承和接口

继承

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

继承的代码实现：

    /// <summary>
    /// 构建一个工作项的业务类（缺省继承自基类Object）
    /// </summary>
    public class WorkItem
    {
        private static int currentID;   //  用于存储最新加入的工作项的ID的静态字段

        protected int ID { get; set; }  //  工作项标识符
        protected string Title { get; set; }    //  名称
        protected string Description { get; set; }  //  说明
        protected TimeSpan JobLength { get; set; }  //  所需时长

        public WorkItem()
        {
            ID = 0;
            Title = "缺省的工作名称";
            Description = "简单的描述";
            JobLength = new TimeSpan();
        }

        public WorkItem(string title,string desc,TimeSpan joblen)
        {
            this.ID = GetNextID();
            this.Title = title;
            this.Description = desc;
            this.JobLength = joblen;
        }

        /// <summary>
        /// 静态构造函数，用来初始化静态属性
        /// </summary>
        static WorkItem()
        {
            currentID = 0;
        }

        /// <summary>
        /// 构建下一个对象的ID
        /// </summary>
        /// <returns></returns>
        protected int GetNextID()
        {
            return ++currentID;
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="title"></param>
        /// <param name="joblen"></param>
        public void Update(string title,TimeSpan joblen)
        {
            this.Title = title;
            this.JobLength = joblen;
        }

        public override string ToString()
        {
            return String.Format("{0}-{1}", this.ID, this.Title);
        }
    }
    
    /// <summary>
    /// 变更工作项请求
    /// </summary>
    public class ChangeRequest : WorkItem
    {
        protected int originalItemID { get; set; }   //  原来安排工作项的ID

        public ChangeRequest()
        {

        }
        public ChangeRequest(string title,string desc,TimeSpan joblen,int originalID)
        {
            this.ID = GetNextID();
            this.Title = title;
            this.Description = desc;
            this.JobLength = joblen;

            this.originalItemID = originalID;
        }
    }

继承的实际应用

 /// <summary>
    /// 继承的实际应用
    /// </summary>
    public static class Inheritence
    {
        public static void ToInheritence()
        {
            //  定义一个工作项
            WorkItem item = new WorkItem("修复 Bugs", "修复当前代码的全部 bug", new TimeSpan(3, 4, 0,0));

            //  定义一个工作项变更要求
            ChangeRequest change = new ChangeRequest("变更基类设计内容", "添加类成员", new TimeSpan(4, 0, 0), 1);

            Console.WriteLine(item.ToString());

            //Console.WriteLine(change.ToString());

            change.Update("进一步变更基类设计内容", new TimeSpan(4, 0, 0));

            Console.WriteLine(change.ToString());
            Console.ReadKey();
        }
    }

抽象类（abstract）

抽象类不能实例化，抽象类的用途是提供一个可供多个派生类共享的通用基类定义。例如，类库可以定义一个抽象类，将其用作多个类库函数的参数，并要求使用该库的程序员通过创建派生类类提供自己的类实现（说明：不完整且必须在派生类中实现的类和类成员）

相关代码：

/// <summary>
    /// 抽象类，不能实例化（一个没有构造函数的类）
    /// 用途是提供一个可供多个派生类共享的通用基类定义（如：
    /// 类库可以定义一个抽象类，将其用作多个类库函数的参数，并要求使用该类库的程序员通过创建派生类来提供自己的类实现
    /// </summary>
    public abstract class StudentUpdateLog
    {
        public Guid ID { get; set; }
        public DateTime UpdateTime { get; set; }    //  更新时间
        public string Description { get; set; }  //  变更说明
        
        public virtual Student Student { get; set; }    //  关联学生

        public abstract void SetDescription(string desc);  //  设置变更说明
    }

    /// <summary>
    /// 学生教学班变更记录
    /// </summary>
    public class StudentSchoolClassUpdateLog : StudentUpdateLog
    {
        public SchoolClass OrogianlSchoolClass { get; set; }    //  原来班级
        public SchoolClass CurrentSchoolClass { get; set; }     //  当前

        public StudentSchoolClassUpdateLog()
        {
            this.ID = Guid.NewGuid();
            this.UpdateTime = DateTime.Now;
        }
        
        /// <summary>
        /// 如果在抽象类中定义了方法，那么必须在它的派生类中实现
        /// </summary>
        /// <param name="desc"></param>
        public override void SetDescription(string desc)
        {
            this.Description = desc;
        }
    }

接口类

（接口包含类或结构可以实现的一组相关功能的定义）

。接口类似于抽象基类。实现接口的任何类或接口多必须实现其所有成员。

。接口无法直接进行实例。其成员由实现接口的任何类或接口来实现。

。接口可以包含事件、索引器、方法和属性。

。一个类或结构可以实现多个接口。

。一个类可以继承一个基类，还可以实现一个或多个接口。

    /// <summary>
    /// 用于描述相等性的接口
    /// </summary>
    /// <typeparam name="T">待指定类型的类型</typeparam>
    public interface IEquatable<T>
    {
        string GetMake();   //  获取制造商
        string GetModle();  //  获取类型
        string GetYear();   //  获取年份

        /// <summary>
        /// 只定义方法、返回值、参数、没有定义任何具体的实现
        /// </summary>
        /// <param name="obj">T所限定类型的对象</param>
        /// <returns></returns>
        bool Equals(T obj);
    }

    public class Car : IEquatable<Car>
    {
        public string Make { get; set; }
        public string Modle { get; set; }
        public string Year { get; set; }
        
        public Car(string make,string modle,string year)
        {
            this.Make = make;
            this.Modle = modle;
            this.Year = year;
        }

        //  实现 IEquatable<T> 接口
        public bool Equals(Car obj)
        {
            if (this.Make == obj.Make && this.Modle == obj.Modle && this.Year == obj.Year)
                return true;
            else
                return false;
        }

        //  实现接口类 IEquatable<T> 的成员方法
        public string GetMake()
        {
            return Make;
        }

        public string GetModle()
        {
            return Modle;
        }

        public string GetYear()
        {
            return Year;
        }
    }

    /// <summary>
    /// 接口类的实现
    /// </summary>
    public static class InterfaceClass
    {
        public static void ToInterface()
        {
            //  创建 Car 实例
            Car car1 = new Car("宝马", "跑车", "2017");
            Car car2 = new Car("宝马", "跑车", "2016");
            bool b= car1.Equals(car2);
            if (b == true)
                Console.WriteLine("相同");
            else
                Console.WriteLine("额不相同");

            //  声明一个转型的 IEquatable，没有创建
            IEquatable<Car> hehe = (IEquatable<Car>)car1;

            Console.WriteLine("Make:{0},Model{1},Year{2}", car1.Make, car1.Modle, car1.Year);

            Console.WriteLine("hMake:{0},hModel{1},hYear{2}", hehe.GetMake(), hehe.GetModle(), hehe.GetYear());

            Console.ReadKey();
        }
    }