类的继承
结构的继承
案例
虚方法
多态性
隐藏方法
调用方法的基类版本
抽象类和抽象方法
密封类和密封方法
派生类的构造函数

类的继承

可以继承基类和接口

class MyDerivedClass: MyBaseClass
  {
  // members
  }

如果类（或结构）也派生自接口，则用逗号分隔列表中的基类和接口：

public class MyDerivedClass: MyBaseClass, IInterface1, IInterface2
{
   // members
}

结构的继承

只能用于接口继承

public struct MyDerivedStruct: IInterface1, IInterface2
{
   // members
}

案例

定义了基类Shape。
无论是矩形还是椭圆，形状都有一些共同点：形状都有位置和大小。
定义相应的类时，位置和大小应包含在Shape类中。
Shape类定义了只读属性Position和Shape，它们使用自动属性初始化器来初始化。

public class Position
{
    public int X { get; set; }
    public int Y { get; set; }
}
public class Size
{
    public int Width { get; set; }
    public int Height { get; set; }
}
public class Shape
{
    public Position Position { get; } = new Position();
    public Size Size { get; } = new Size();
}

虚方法

把一个基类方法声明为virtual，就可以在任何派生类中重写该方法：

普通方法的虚方法

public class Shape
{
    public virtual void Draw()
    {
        WriteLine($"Shape with {Position} and {Size}");
    }
}

代码只有一行时

如果实现代码只有一行，在C# 6中，也可以把virtual关键字和表达式体的方法（使用lambda运算符）一起使用。

这个语法可以独立于修饰符，单独使用：

 public class Shape
 {
     public virtual void Draw() => WriteLine($"Shape with {Position} and {Size}");
 }

属性的虚方法

private Size _size;
public virtual Size Size
{
       get
    {
       return _size;
    }
        set
    {
       _size = value;
    }
}

方法的重写

C#要求在派生类的函数重写另一个函数时，
要使用override关键字显式声明

public class Rectangle : Shape
{
   public override void Draw() =>WriteLine($"Rectangle with {Position} and {Size}");
}

多态性

使用多态性，可以动态地定义调用的方法，而不是在编译期间定义。
编译器创建一个虚拟方法表（vtable），其中列出了可以在运行期间调用的方法，它根据运行期间的类型调用方法。

//DrawShape（）方法接收一个Shape参数，并调用Shape类的Draw（）方法
public static void DrawShape(Shape shape)
{
    shape.Draw();
}

使用之前创建的矩形调用方法。
尽管方法声明为接收一个Shape对象，但任何派生Shape的类型（包括Rectangle）都可以传递给这个方法。

隐藏方法

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

在大多数情况下，是要重写方法，而不是隐藏方法，因为隐藏方法会造成对于给定类的实例调用错误方法的危险。

public class Shape//基类
{
    // various members
}

public class Ellipse: Shape//派生类
    {
      public void MoveBy(int x, int y)
      {
        Position.X += x;
        Position.Y += y;
      }
    }

当派生类定义一个基类中不存在的方法时
基类在后面也写了一个与派生类相同的方法，但没有定义是虚方法。

编译Ellipse类会生成一个编译警告，提醒使用new关键词隐藏方法。在实践中，不使用new关键字会得到相同的编译结果，但避免出现编译器警告：

public class Ellipse: Shape
{
    new public void Move(Position newPosition)
 {
    Position.X = newPosition.X;
    Position.Y = newPosition.Y;
  }
    //. . . other members
}

不使用new关键字，也可以重命名方法，或者，如果基类的方法声明为virtual，且用作相同的目的，就重写它。
然而，如果其他方法已经调用了此方法，简单的重命名会破坏其他代码。

调用方法的基类版本

C#有一种特殊的语法用于从派生类中调用方法的基类版本

例如，派生类Shape声明了Move（）方法，想要在派生类Rectangle中调用它，以使用基类的实现代码。

:::danger base.<MethodName>（） :::

public class Shape
{
    public virtual void Move(Position newPosition)
    {
        Position.X = newPosition.X;
        Position.Y = newPosition.Y;
        WriteLine($"moves to {Position}");
    }
    //. . . other members
}

Move（）方法在Rectangle类中重写，把Rectangle一词添加到控制台。

public class Rectangle: Shape
    {
      public override void Move(Position newPosition)
      {
        Write("Rectangle ");
        base.Move(newPosition);
      }
      //. . . other members
      }

抽象类和抽象方法

C#允许把类和方法声明为abstract。

:::info 抽象类不能实例化，而抽象方法不能直接实现，必须在非抽象的派生类中重写。 :::

public abstract class Shape
{
    public abstract void Resize(int width, int height);  // abstract method
}

从抽象基类中派生类型时，需要实现所有抽象成员。否则，编译器会报错：

public class Ellipse : Shape
{
   public override void Resize(int width, int height)
   {
      Size.Width = width;
      Size.Height = height;
   }
}

密封类和密封方法

如果不应创建派生自某个自定义类的类，该自定义类就应密封。

给类添加sealed修饰符，就不允许创建该类的子类。
密封一个方法，表示不能重写该方法。

sealed class FinalClass
{
    // etc
}
class DerivedClass: FinalClass      // wrong. Cannot derive from sealed class.
{
    // etc
}

派生类的构造函数

创建派生类的实例时，实际上会有多个构造函数起作用。
要实例化的类的构造函数本身不能初始化类，还必须调用基类中的构造函数。

public class Shape
{
    public Position Position { get; } = new Position();
    public Size Size { get; } = new Size();
}

在幕后，编译器会给类创建一个默认的构造函数，把属性初始化器放在这个构造函数中：

public class Shape
{
    public Shape()
    {
        Position = new Position();
        Size = new Size();
    }
    public Position Position { get; };
    public Size Size { get; };
}

构造函数总是按照层次结构的顺序调用：

先调用System.Object类的构造函数
再按照层次结构由上向下进行
直到到达编译器要实例化的类为止。

public abstract class Shape
{
    public Shape(int width, int height, int x, int y)
    {
        Size = new Size { Width = width, Height = height };
        Position = new Position { X = x, Y = y };
    }
    public Position Position { get; }
    public Size Size { get; }
}

当删除默认构造函数，重新编译程序时，不能编译Ellipse和Rectangle类，因为编译器不知道应该把什么值传递给基类唯一的非默认值构造函数。

public Rectangle(int width, int height, int x, int y)
        : base(width, height, x, y)
    {
    }

把初始化代码放在构造函数块内太迟了，因为基类的构造函数在派生类的构造函数之前调用。这就是为什么在构造函数块之前声明了一个构造函数初始化器。

电子、计算机

实现继承