Язык программирования C#9 и платформа .NET5

Большая часть главы была посвящена деталям первого принципа ООП — инкапсуляции. Вы узнали о модификаторах доступа C# и роли свойств типа, о синтаксисе инициализации объектов и о частичных классах. Теперь вы готовы перейти к чтению следующей главы, в которой речь пойдет о построении семейства взаимосвязанных классов с применением наследования и полиморфизма.
  
Глава 6
 
Наследование и полиморфизм
 
В главе 5 рассматривался первый основной принцип объектно-ориентированного программирования (ООП) — инкапсуляция. Вы узнали, как строить отдельный четко определенный тип класса с конструкторами и разнообразными членами (полями, свойствами, методами, константами и полями только для чтения). В настоящей главе мы сосредоточим внимание на оставшихся двух принципах ООП: наследовании и полиморфизме.
Прежде всего, вы научитесь строить семейства связанных классов с применением наследования. Как будет показано, такая форма многократного использования кода позволяет определять в родительском классе общую функциональность, которая может быть задействована, а возможно и модифицирована в дочерних классах. В ходе изложения вы узнаете, как устанавливать полиморфный интерфейс в иерархиях классов, используя виртуальные и абстрактные члены, а также о роли явного приведения.
Глава завершится исследованием роли изначального родительского класса в библиотеках базовых классов .NET Core — 
System.Object
.
  
Базовый механизм наследования
 
Вспомните из главы 5, что наследование — это аспект ООП, упрощающий повторное использование кода. Говоря более точно, встречаются две разновидности повторного использования кода: наследование (отношение "является") и модель включения/делегации (отношение "имеет"). Давайте начнем текущую главу с рассмотрения классической модели наследования, т.е. отношения "является".
Когда вы устанавливаете между классами отношение "является", то тем самым строите зависимость между двумя и более типами классов. Основная идея, лежащая в основе классического наследования, состоит в том, что новые классы могут создаваться с применением существующих классов как отправной точки. В качестве простого примера создайте новый проект консольного приложения по имени 
BasicInheritance
.
Предположим, что вы спроектировали класс 
Car
, который моделирует ряд базовых деталей автомобиля:
namespace BasicInheritance
{
  // Простой базовый класс.
  class Car
  {
    public readonly int MaxSpeed;
    private int _currSpeed;
    public Car(int max)
    {
      MaxSpeed = max;
    }
  public Car()
    {
      MaxSpeed = 55;
    }
    public int Speed
    {
      get { return _currSpeed; }
      set
      {
        _currSpeed = value;
        if (_currSpeed > MaxSpeed)
 
        {
          _currSpeed = MaxSpeed;
        }
      }
    }
  }
}
Обратите внимание, что класс 
Car
 использует службы инкапсуляции для управления доступом к закрытому полю 
_currSpead
 посредством открытого свойства по имени 
Speed
. В данный момент с типом 
Car
 можно работать следующим образом:
using System;
using BasicInheritance;
Console.WriteLine("***** Basic Inheritance *****\n");
// Создать объект Car и установить максимальную и текущую скорости.
Car myCar = new Car(80) {Speed = 50};
// Вывести значение текущей скорости.
Console.WriteLine("My car is going {0} MPH", myCar.Speed);
Console.ReadLine();
  
Указание родительского класса для существующего класса
 
Теперь предположим, что планируется построить новый класс по имени 
MiniVan
. Подобно базовому классу 
Car
 вы хотите определить класс 
MiniVan
 так, чтобы он поддерживал данные для максимальной и текущей скоростей и свойство по имени 
Speed
, которое позволило бы пользователю модифицировать состояние объекта. Очевидно, что классы 
Car
 и 
MiniVan
 взаимосвязаны; фактически можно сказать, что 
MiniVan
 "является" разновидностью 
Car
. Отношение "является" (формально называемое классическим наследованием) позволяет строить новые определения классов, которые расширяют функциональность существующих классов.
Существующий класс, который будет служить основой для нового класса, называется базовым классом, суперклассом или родительским классом. Роль базового класса заключается в определении всех общих данных и членов для классов, которые его расширяют. Расширяющие классы формально называются производными или дочерними классами. В языке C# для установления между классами отношения "является" применяется операция двоеточия в определении класса. Пусть вы написали новый класс 
MiniVan
 следующего вида:
namespace BasicInheritance
{
  // MiniVan "является" Car.
  sealed class MiniVan : Car
  {
  }
}
В текущий момент никаких членов в новом классе не определено. Так чего же мы достигли за счет наследования 
MiniVan
 от базового класса 
Car
? Выражаясь просто, объекты 
MiniVan
 теперь имеют доступ ко всем открытым членам, определенным внутри базового класса.