【C#基础】面向对象开发（OOP）

在面向对象编程中，有两种截然不同的继承类型，实现继承和接口继承。C# 不支持多重继承，C#类可以派生自另一个类和任意多的接口。

• 实现继承：表示一个类型派生自一个基类型，它拥有该基类型的所有成员字段和函数，在需要给现有类型添加功能或者许多相关类型共享一组重要的公共功能时这种类型继承非常有用
• 接口继承：表示一个类型只继承了函数的签名，没有继承任何的实现代码

实现继承

    /// <summary>
    /// 基类
    /// </summary>
    class Person
    {
        /// <summary>
        /// 使用virtual关键字定义的方法允许在派生类中使用override重写
        /// </summary>
        public virtual void SayHello()
        {
            Console.WriteLine("基类的SayHello");
        }
    }
    /// <summary>
    /// 派生自Person
    /// </summary>
    class ChinaPerson : Person
    {
        /// <summary>
        /// 使用override关键字重写基类的SayHello方法
        /// </summary>
        public override void SayHello()
        {
            Console.WriteLine("你好");
        }
    }
    /// <summary>
    /// 派生自Person
    /// </summary>
    class ThailandPerson : Person
    {
        public override void SayHello()
        {
            Console.WriteLine("萨瓦迪卡");
        }
    }

把一个基类函数声明为 virtual，就可以在任何派生类中重写该函数，virtual 也适用于属性。

注意；成员字段和静态函数都不能声明为 virtual ，因为这个概念只对类中的实例成员有意义

隐藏方法

如果签名相同的方法在基类和派生类中都进行了声明，但该方法没有声明为 virtual 和 override，派生类会隐藏基类方法。

 class Person
    {
        public void SayHello()
        {
            Console.WriteLine("基类的SayHello");
        }
    }
    class ChinaPerson : Person
    {
        //提示:隐藏继承的成员Person.SayHello，如果有意的，请使用关键字new
        public void SayHello()
        {
            Console.WriteLine("你好");
        }
    }

调用基类方法

C#中可以使用 base. 这种语法来调用方法的基类版本。

    class Person
    {
        public virtual void SayHello()
        {
            Console.WriteLine("基类的SayHello");
        }
    }
    class ChinaPerson : Person
    {
        public override void SayHello()
        {
            base.SayHello();
            Console.WriteLine("你好");
        }
    }

接口继承

表示一个类型只继承了函数的签名，没有继承任何实现代码。在需要指定该类型具有某些可用的特性时，最好使用这种类型的继承。

接口名称通常以字母 I 开头，以便知道这是一个接口。C#支持多接口继承和单一实现继承，接口继承中又分为隐式实现和显式实现。

    interface IPerson
    {
        void SayHello();
    }
    /// <summary>
    /// 隐式实现接口
    /// </summary>
    class ChinaPerson : IPerson
    {
        public void SayHello()
        {
            Console.WriteLine("你好");
        }
    }
    /// <summary>
    /// 显式实现接口
    /// </summary>
    class ThailandPerson : IPerson
    {      
        void IPerson.SayHello()
        {
            Console.WriteLine("莎娃迪卡");
        }
    }

对于隐式实现的接口调用这两种方式都可以

      ChinaPerson chinaPerson = new ChinaPerson();
      IPerson person = new ChinaPerson();
      person.SayHello();
      chinaPerson.SayHello();

对于显式实现的接口调用只能使用接口调用

      IPerson thailandPerson = new ThailandPerson();
      thailandPerson.SayHello();

抽象类和抽象函数

• C#中允许把类或函数声明为abstract ，抽象类不能被实例化。抽象函数也不能直接实现，必须在非抽象的派生类中重写
• 如果类包含抽象函数，则该类也必须被声明为抽象的
• 抽象方法只在派生类中真正实现，这表明抽象方法只存放函数原型不涉及主体代码
• 派生自抽象类的类需要实现其基类的抽象方法，才能实例化对象
• 使用 override 关键字可在派生类中实现抽象方法，经 override 声明重写的方法称为重写基类方法，其签名必须与 override 方法的签名相同

密封类和密封方法

C#允许把类和方法声明为 sealed ，对于类这表示不能继承；对于方法这表示不能重写该方法。

派生类的构造函数执行顺序

首先定义基类 A，为了方便查看，显式指明基类的无参构造函数

 class A
    {
        public int Age { get; set; }
        public string Name { get; set; }
        public A()
        {
            Console.WriteLine("A类无参构造函数");
        }
    }

然后定义B类继承自A类

 class B : A
    {
        public B()
        {
            Console.WriteLine("B类无参构造函数");
        }
    }

实例化B类

static void Main(string[] args)
    {
       B b = new B();
       Console.ReadKey();
    }

输出：
A类无参构造函数
B类无参构造函数

实例化子类时，只可以new子类，执行顺序为：先执行父类构造函数=>再执行子类构造函数

如果父类存在多个构造函数会怎么样？

    class A
    {
        public int Age { get; set; }
        public string Name { get; set; }
        public A()
        {
            Console.WriteLine("A类无参构造函数");
        }
        public A(int age， string name)
        {
            Console.WriteLine("A类带参构造函数");
        }
    }
    class B : A
    {
        public B()
        {
            Console.WriteLine("B类无参构造函数");
        }
    }

再次实例化B类

static void Main(string[] args)
     {
         B b = new B();
         Console.ReadKey();
     }

输出：
A类无参构造函数
B类无参构造函数

实例化子类时，会先执行父类的构造函数(默认为父类的无参构造函数)，也可以在子类中使用base关键字指定调用父类的哪个构造函数

   class Program
    {
        static void Main(string[] args)
        {
            B b = new B(3);
            Console.ReadKey();
        }
    }
   class A
    {
        public int Age { get; set; }
        public A()
        {
            Console.WriteLine("A类无参构造函数");
        }
        public A(int age)
        {
            Console.WriteLine("A类带参构造函数");
        }
    }
   class B : A
    {
        public B() : base(3)
        {
            Console.WriteLine("B类无参构造函数调用父类带参构造函数");
        }
    }

输出：
A类带参构造函数
B类无参构造函数调用父类带参构造函数

总结：

• 实例化父类时，可以使用 new 子类，执行构造函数顺序为：执行父类构造函数=>执行子类构造函数
• 实例化子类时，只可以 new 子类，执行顺序同上
• 父类实例化后，只能执行父类的方法，获得父类的属性等
• 实例化子类后，可同时执行子类和父类的方法和属性，如同名方法，则执行子类的方法
• 子类构造函数可以使用 base 关键字指定调用的父类构造函数

抽象类和接口的区别

相同点

• 都可以被继承
• 都不能被实例化
• 都包含方法声明
• 派生类必须实现未实现的方法

区别

• 抽象基类可以定义字段/属性/方法实现.接口只能定义属性/索引器/事件/方法声明
• 抽象类是一个不完整的类，需要通过集成进一步细化。而接口更像是一个行为规范表明能做什么
• 接口是可以被多重实现的，可以有多个类实现接口，因为类的单一继承性，抽象类只能被单一继承
• 抽象类实现继承需要使用 override 关键字，接口则不用
• 如果抽象类实现接口，可以把接口方法映射到抽象类中作为抽象方法不必实现，而在抽象类的子类中实现接口方法
• 抽象类表示的是这个对象是什么；接口表示的是这个对象能做什么；使用抽象类是为了代码的复用，使用接口是为了实现多态性

普通类和抽象类的区别

• 都可以被继承
• 抽象类不能实例化，普通类允许实例化
• 抽象方法只包含方法声明而且必须包含在抽象类中
• 子类继承抽象类必须实现抽象类中的抽象方法除非子类也是抽象类
• 抽象类中可以包含抽象方法和实例方法