ООП: Наследование в C# (.NET): подробное руководство

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты решил создать свою собственную видеоигру. В этой игре есть разные виды транспорта: машины, мотоциклы, грузовики и велосипеды. У каждого из них есть что-то общее: все они могут двигаться, у всех есть колёса, все они могут сигналить. Но при этом каждый вид транспорта делает это по-своему. Машина едет по дороге, грузовик перевозит тяжёлые грузы, а велосипед может ехать по тропинкам.

Если бы ты писал код для каждого вида транспорта с нуля, тебе пришлось бы каждый раз заново описывать, что такое колёса, как работает двигатель, как включать фары. Это было бы очень долго и нудно. А если бы ты захотел добавить новую функцию, например, «включить кондиционер», тебе пришлось бы менять код во всех классах сразу.

Наследование — это механизм в объектно-ориентированном программировании, который позволяет создать один общий класс (назовём его «Транспортное средство»), в котором описаны все общие свойства и методы. А затем для каждого конкретного вида транспорта ты создаёшь свой класс, который наследует всё от общего класса, но при этом может добавлять что-то своё или изменять поведение родителя.

Представь, что ты строишь дом. Фундамент, стены и крыша — это общий класс «Дом». А затем ты строишь конкретные дома: «Коттедж с бассейном», «Городская квартира», «Дачный домик». Каждый из них использует общие элементы, но добавляет свои уникальные детали. Наследование в программировании работает точно так же.

Зачем это нужно? Во-первых, это экономит время — ты не пишешь один и тот же код по сто раз. Во-вторых, это упрощает поддержку — если нужно изменить что-то общее, ты меняешь только в одном месте. В-третьих, это делает код более логичным и понятным — ты видишь иерархию классов и понимаешь, как они связаны между собой.

Теория: как это работает изнутри

Давай заглянем «под капот» и разберёмся, что на самом деле происходит в памяти компьютера, когда мы используем наследование.

Базовый и производный классы

В наследовании всегда есть два участника:

• Базовый класс (родительский, суперкласс) — это класс, от которого наследуют. Он содержит общие поля, свойства и методы.
• Производный класс (дочерний, подкласс) — это класс, который наследует от базового. Он получает всё, что есть у родителя, и может добавить своё.

Как C# хранит объекты в памяти

Когда ты создаёшь объект производного класса, в памяти выделяется место для всех полей — как тех, что объявлены в производном классе, так и тех, что унаследованы от базового. Представь себе матрёшку: самая большая матрёшка — это базовый класс, а внутри неё — матрёшка поменьше, производный класс. Когда ты обращаешься к полю или методу, компилятор сначала ищет его в самом производном классе. Если не находит — поднимается на уровень выше, к базовому классу.

Модификаторы доступа и наследование

Не всё, что есть у родителя, доступно ребёнку. В C# есть специальные ключевые слова, которые контролируют видимость:

Модификатор	Доступен ли в производном классе?	Доступен ли извне?
public	Да	Да
private	Нет	Нет
protected	Да	Нет
internal	Да (в пределах сборки)	Да (в пределах сборки)
protected internal	Да	Да (в пределах сборки)
private protected	Да (только в пределах сборки)	Нет

Важно: private поля и методы родителя не наследуются. Они существуют в объекте, но дочерний класс не может к ним напрямую обратиться. Это сделано для защиты данных — родитель может скрыть свои внутренние детали реализации.

Виртуальные методы и переопределение

Иногда бывает так: у родителя есть метод, но ребёнок хочет сделать его по-своему. Для этого в C# используется механизм виртуальных методов. Родитель помечает метод ключевым словом virtual, а ребёнок — override. Это значит: «Эй, я знаю, что папа делает так, но я буду делать иначе».

Когда ты вызываешь такой метод у объекта, C# смотрит не на тип переменной, а на реальный тип объекта в памяти. Это называется полиморфизм — одна из трёх основ ООП (наряду с наследованием и инкапсуляцией).

Конструкторы и наследование

Когда создаётся объект производного класса, сначала вызывается конструктор базового класса, а потом — конструктор производного. Это логично: сначала нужно построить фундамент (родителя), а потом уже надстраивать этажи (ребёнка).

Если у базового класса нет конструктора без параметров, производный класс должен явно вызвать один из конструкторов родителя через ключевое слово base.

Синтаксис в C# (.NET): все формы и варианты

Давай разберём синтаксис наследования в C# от простого к сложному.

1. Простое наследование

В C# класс может наследовать только от одного базового класса. Это называется одиночное наследование.

// Базовый класс
public class Animal
{
    public string Name { get; set; }
    
    public void Eat()
    {
        Console.WriteLine($"{Name} ест.");
    }
}

// Производный класс. Символ : означает "наследует от"
public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} гавкает!");
    }
}

2. Наследование с конструкторами

Если у базового класса есть конструктор с параметрами, производный класс должен его вызвать:

public class Vehicle
{
    public string Brand { get; set; }
    public int Year { get; set; }
    
    // Конструктор базового класса
    public Vehicle(string brand, int year)
    {
        Brand = brand;
        Year = year;
    }
    
    public void Start()
    {
        Console.WriteLine($"{Brand} ({Year} года выпуска) заводится.");
    }
}

public class Car : Vehicle
{
    public int DoorsCount { get; set; }
    
    // Ключевое слово base вызывает конструктор родителя
    public Car(string brand, int year, int doorsCount) : base(brand, year)
    {
        DoorsCount = doorsCount;
    }
    
    public void Honk()
    {
        Console.WriteLine($"{Brand} сигналит: Бип-бип!");
    }
}

3. Виртуальные методы и переопределение

public class Shape
{
    public virtual double GetArea()
    {
        return 0; // Базовая реализация, которая ничего не делает
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }
    
    public Circle(double radius)
    {
        Radius = radius;
    }
    
    // Переопределяем метод родителя
    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }
    
    public override double GetArea()
    {
        return Width * Height;
    }
}

4. Запечатанные классы (sealed)

Иногда нужно запретить наследование от класса. Для этого используется ключевое слово sealed:

public sealed class MathHelper
{
    public int Add(int a, int b) => a + b;
}

// Ошибка компиляции! Нельзя наследовать от sealed класса
// public class AdvancedMath : MathHelper { }

5. Абстрактные классы

Абстрактный класс — это класс, который нельзя создать напрямую. Он существует только для того, чтобы от него наследовали. В нём могут быть абстрактные методы (без реализации), которые обязан реализовать производный класс:

public abstract class Employee
{
    public string Name { get; set; }
    
    // Абстрактный метод — нет тела, только объявление
    public abstract decimal CalculateSalary();
    
    // Обычный метод — есть реализация
    public void Work()
    {
        Console.WriteLine($"{Name} работает.");
    }
}

public class FullTimeEmployee : Employee
{
    public decimal MonthlySalary { get; set; }
    
    // Обязаны реализовать абстрактный метод
    public override decimal CalculateSalary()
    {
        return MonthlySalary;
    }
}

public class HourlyEmployee : Employee
{
    public decimal HourlyRate { get; set; }
    public int HoursWorked { get; set; }
    
    public override decimal CalculateSalary()
    {
        return HourlyRate * HoursWorked;
    }
}

6. Множественное наследование через интерфейсы

C# не поддерживает множественное наследование классов (когда один класс наследует от двух и более классов). Но эту проблему решают интерфейсы. Класс может реализовать сколько угодно интерфейсов:

public interface IFlyable
{
    void Fly();
}

public interface ISwimmable
{
    void Swim();
}

// Класс может наследовать от одного класса и реализовать много интерфейсов
public class Duck : Animal, IFlyable, ISwimmable
{
    public void Fly()
    {
        Console.WriteLine("Утка летит.");
    }
    
    public void Swim()
    {
        Console.WriteLine("Утка плывёт.");
    }
}

7. Сокрытие методов (new)

Иногда нужно не переопределить метод, а скрыть его. Это делается с помощью ключевого слова new:

public class Parent
{
    public void Show()
    {
        Console.WriteLine("Родительский метод");
    }
}

public class Child : Parent
{
    // Скрываем метод родителя
    public new void Show()
    {
        Console.WriteLine("Дочерний метод");
    }
}

// Разница между override и new:
// override — меняет поведение для всех, кто использует объект через ссылку на родителя
// new — только если обращаться через ссылку на дочерний класс

Примеры кода — от простого к сложному

Пример 1: Базовое наследование

using System;

// Базовый класс "Животное"
public class Animal
{
    public string Name { get; set; }
    public int Age { get; set; }
    
    public void Sleep()
    {
        Console.WriteLine($"{Name} спит.");
    }
}

// Производный класс "Собака"
public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} говорит: Гав-гав!");
    }
}

class Program
{
    static void Main()
    {
        // Создаём объект собаки
        Dog myDog = new Dog();
        myDog.Name = "Бобик";  // Свойство унаследовано от Animal
        myDog.Age = 3;         // Свойство унаследовано от Animal
        
        myDog.Sleep();  // Метод унаследован от Animal
        myDog.Bark();   // Собственный метод Dog
    }
}

Пример 2: Наследование с конструкторами и base

using System;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
    
    public void Introduce()
    {
        Console.WriteLine($"Привет, я {FirstName} {LastName}.");
    }
}

public class Student : Person
{
    public string StudentId { get; set; }
    
    // Вызываем конструктор родителя через base
    public Student(string firstName, string lastName, string studentId) 
        : base(firstName, lastName)
    {
        StudentId = studentId;
    }
    
    public void Study()
    {
        Console.WriteLine($"{FirstName} учится. ID студента: {StudentId}");
    }
}

class Program
{
    static void Main()
    {
        Student student = new Student("Иван", "Петров", "ST12345");
        student.Introduce();  // Унаследованный метод
        student.Study();      // Собственный метод
    }
}

Пример 3: Виртуальные методы и полиморфизм

using System;

public class Instrument
{
    public string Name { get; set; }
    
    public Instrument(string name)
    {
        Name = name;
    }
    
    // Виртуальный метод — может быть переопределён
    public virtual void Play()
    {
        Console.WriteLine($"{Name} издаёт звук.");
    }
}

public class Guitar : Instrument
{
    public Guitar() : base("Гитара") { }
    
    public override void Play()
    {
        Console.WriteLine($"{Name}: Дзынь-дзынь!");
    }
}

public class Piano : Instrument
{
    public Piano() : base("Пианино") { }
    
    public override void Play()
    {
        Console.WriteLine($"{Name}: Динь-дон!");
    }
}

class Program
{
    static void Main()
    {
        // Полиморфизм: один тип переменной, разное поведение
        Instrument[] instruments = new Instrument[]
        {
            new Guitar(),
            new Piano(),
            new Instrument("Барабан") // Базовый класс
        };
        
        foreach (var instrument in instruments)
        {
            instrument.Play(); // Каждый играет по-своему
        }
    }
}

Пример 4: Абстрактные классы

using System;

public abstract class DatabaseConnection
{
    public string ConnectionString { get; set; }
    
    public DatabaseConnection(string connectionString)
    {
        ConnectionString = connectionString;
    }
    
    // Абстрактные методы — без реализации
    public abstract void Connect();
    public abstract void Disconnect();
    
    // Обычный метод с реализацией
    public void Log(string message)
    {
        Console.WriteLine($"[LOG] {DateTime.Now}: {message}");
    }
}

public class SqlDatabase : DatabaseConnection
{
    public SqlDatabase(string connectionString) : base(connectionString) { }
    
    public override void Connect()
    {
        Log($"Подключаюсь к SQL базе: {ConnectionString}");
        Console.WriteLine("Подключение к SQL установлено.");
    }
    
    public override void Disconnect()
    {
        Log("Отключаюсь от SQL базы");
        Console.WriteLine("Отключение от SQL выполнено.");
    }
}

public class MongoDatabase : DatabaseConnection
{
    public MongoDatabase(string connectionString) : base(connectionString) { }
    
    public override void Connect()
    {
        Log($"Подключаюсь к MongoDB: {ConnectionString}");
        Console.WriteLine("Подключение к MongoDB установлено.");
    }
    
    public override void Disconnect()
    {
        Log("Отключаюсь от MongoDB");
        Console.WriteLine("Отключение от MongoDB выполнено.");
    }
}

class Program
{
    static void Main()
    {
        // Нельзя: DatabaseConnection db = new DatabaseConnection("...");
        // Абстрактный класс нельзя создать напрямую
        
        DatabaseConnection db1 = new SqlDatabase("Server=myServer;Database=myDB;");
        DatabaseConnection db2 = new MongoDatabase("mongodb://localhost:27017");
        
        db1.Connect();
        db2.Connect();
        
        db1.Disconnect();
        db2.Disconnect();
    }
}

Пример 5: Цепочка наследования

using System;

// Базовый класс
public class LivingBeing
{
    public bool IsAlive { get; set; } = true;
    
    public void Breathe()
    {
        Console.WriteLine("Существо дышит.");
    }
}

// Промежуточный класс
public class Mammal : LivingBeing
{
    public int BodyTemperature { get; set; } = 37;
    
    public void FeedMilk()
    {
        Console.WriteLine("Млекопитающее кормит детёныша молоком.");
    }
}

// Конечный класс
public class Human : Mammal
{
    public string Name { get; set; }
    
    public Human(string name)
    {
        Name = name;
    }
    
    public void Think()
    {
        Console.WriteLine($"{Name} думает.");
    }
}

class Program
{
    static void Main()
    {
        Human person = new Human("Алексей");
        
        // Все методы доступны, несмотря на глубину наследования
        person.Breathe();      // от LivingBeing
        person.FeedMilk();     // от Mammal
        person.Think();        // собственный
        
        Console.WriteLine($"Жив? {person.IsAlive}");  // от LivingBeing
        Console.WriteLine($"Температура тела: {person.BodyTemperature}");  // от Mammal
    }
}

Пример 6: Интерфейсы и множественное наследование

using System;

public interface IWorker
{
    void Work();
}

public interface IEater
{
    void Eat();
}

public interface ISleeper
{
    void Sleep();
}

// Робот может работать, но не ест и не спит
public class Robot : IWorker
{
    public void Work()
    {
        Console.WriteLine("Робот работает.");
    }
}

// Человек может всё
public class HumanWorker : IWorker, IEater, ISleeper
{
    public void Work()
    {
        Console.WriteLine("Человек работает.");
    }
    
    public void Eat()
    {
        Console.WriteLine("Человек ест.");
    }
    
    public void Sleep()
    {
        Console.WriteLine("Человек спит.");
    }
}

class Program
{
    static void Main()
    {
        IWorker worker1 = new Robot();
        IWorker worker2 = new HumanWorker();
        
        worker1.Work();
        worker2.Work();
        
        // worker1 не может есть или спать — он только IWorker
        // worker2 может, но нужно привести к нужному типу
        if (worker2 is IEater eater)
        {
            eater.Eat();
        }
    }
}

Пример 7: Практический пример — система платежей

using System;

public abstract class Payment
{
    public decimal Amount { get; set; }
    public string Currency { get; set; } = "RUB";
    
    public Payment(decimal amount)
    {
        Amount = amount;
    }
    
    // Абстрактный метод — каждая платёжная система реализует по-своему
    public abstract bool ProcessPayment();
    
    // Обычный метод — общая логика для всех
    public void PrintReceipt()
    {
        Console.WriteLine($"Платёж на сумму {Amount} {Currency} обработан.");
    }
}

public class CreditCardPayment : Payment
{
    public string CardNumber { get; set; }
    
    public CreditCardPayment(decimal amount, string cardNumber) : base(amount)
    {
        CardNumber = cardNumber;
    }
    
    public override bool ProcessPayment()
    {
        Console.WriteLine($"Обработка платежа по карте {CardNumber.Substring(0, 4)}****...");
        // Здесь была бы реальная логика обработки
        Console.WriteLine("Платёж по карте успешен!");
        return true;
    }
}

public class PayPalPayment : Payment
{
    public string Email { get; set; }
    
    public PayPalPayment(decimal amount, string email) : base(amount)
    {
        Email = email;
    }
    
    public override bool ProcessPayment()
    {
        Console.WriteLine($"Обработка платежа через PayPal для {Email}...");
        Console.WriteLine("Платёж через PayPal успешен!");
        return true;
    }
}

public class CryptoPayment : Payment
{
    public string WalletAddress { get; set; }
    
    public CryptoPayment(decimal amount, string walletAddress) : base(amount)
    {
        WalletAddress = walletAddress;
    }
    
    public override bool ProcessPayment()
    {
        Console.WriteLine($"Отправка криптовалюты на кошелёк {WalletAddress.Substring(0, 10)}...");
        Console.WriteLine("Крипто-платёж выполнен!");
        return true;
    }
}

class Program
{
    static void Main()
    {
        // Создаём список платежей разных типов
        List payments = new List
        {
            new CreditCardPayment(1500.50m, "1234567890123456"),
            new PayPalPayment(899.99m, "user@example.com"),
            new CryptoPayment(0.05m, "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa")
        };
        
        // Обрабатываем все платежи единообразно
        foreach (var payment in payments)
        {
            if (payment.ProcessPayment())
            {
                payment.PrintReceipt();
            }
            Console.WriteLine("---");
        }
    }
}

Сравнение с Python: чем похоже и чем отличается

Если ты уже знаком с Python или планируешь изучать его, полезно знать, чем наследование в C# отличается от Python.

Характеристика	C#	Python
Синтаксис наследования	class Dog : Animal	class Dog(Animal):
Множественное наследование классов	Нет (только через интерфейсы)	Да (класс может наследовать от нескольких классов)
Вызов конструктора родителя	base(параметры)	super().__init__(параметры)
Виртуальные методы	Явно: virtual и override	Все методы виртуальны по умолчанию
Абстрактные классы	abstract class (встроенная поддержка)	Через модуль abc (ABC, abstractmethod)
Модификаторы доступа	public, private, protected, internal	Нет формальных модификаторов (конвенция: _private, __name_mangling)
Статическая типизация	Да (проверка типов на этапе компиляции)	Нет (динамическая типизация, проверка во время выполнения)
Интерфейсы	Есть (отдельная конструкция)	Нет формальных интерфейсов (используются абстрактные классы)
Сокрытие методов	new ключевое слово	Просто переопределяешь (все методы виртуальны)

Главное отличие: C# — строго типизированный язык с явным контролем наследования. Python — динамический язык, где «всё работает, пока не сломается». C# заставляет тебя явно указывать свои намерения (virtual, override, abstract), что делает код более предсказуемым, но требует больше кода. Python даёт больше свободы, но и больше шансов ошибиться.

Типичные ошибки и подводные камни

1. Забыл вызвать конструктор базового класса

Если у базового класса нет конструктора без параметров, ты обязан вызвать его через base. Иначе компилятор выдаст ошибку.

public class Parent
{
    public Parent(int x) { }
}

public class Child : Parent
{
    // Ошибка! Parent не имеет конструктора без параметров
    // public Child() { }
    
    // Правильно:
    public Child() : base(0) { }
}

2. Путаница между override и new

Это одна из самых частых ошибок новичков. Запомни:

• override — ты говоришь: «Я изменяю поведение родительского метода для всех случаев».
• new — ты говоришь: «Я создаю новый метод, который не связан с родительским, просто у них одинаковое имя».

Если ты используешь new там, где нужно override, полиморфизм не сработает:

public class Parent
{
    public virtual void Method() => Console.WriteLine("Parent");
}

public class Child : Parent
{
    public new void Method() => Console.WriteLine("Child");
}

// Использование:
Parent obj = new Child();
obj.Method(); // Выведет "Parent", а не "Child"!

3. Слишком глубокая иерархия наследования

Наследование в 5-6 уровней — это плохая практика. Код становится запутанным, сложно понять, откуда берётся то или иное поведение. Старайся ограничиваться 2-3 уровнями.

4. Нарушение принципа подстановки Лисков (LSP)

Это важный принцип ООП: если класс B наследует от класса A, то объект класса B должен везде работать вместо объекта класса A без изменения свойств программы. Если твой дочерний класс выбрасывает исключения там, где родитель их не выбрасывает, или возвращает другие типы — это нарушение LSP.

public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
    
    public int GetArea() => Width * Height;
}

public class Square : Rectangle
{
    // Нарушение LSP! Квадрат не должен вести себя как прямоугольник
    public override int Width
    {
        set { base.Width = base.Height = value; }
    }
    public override int Height
    {
        set { base.Width = base.Height = value; }
    }
}

// Теперь если кто-то ожидает Rectangle и меняет Width, Height изменится тоже
// Это может привести к неожиданным ошибкам

5. Использование наследования там, где нужна композиция

Не всё, что похоже на «является», должно быть наследованием. Иногда лучше использовать композицию (когда один класс содержит другой как поле). Например, «Машина имеет двигатель» — это композиция, а не наследование. «Спортивная машина является машиной» — это наследование.

Лучшие практики и советы профессионалов

1. Принцип единственной ответственности (SRP)

Каждый класс должен иметь только одну причину для изменения. Если твой базовый класс делает слишком много — разбей его на несколько.

2. Предпочитай композицию наследованию

Это знаменитый совет из книги «Банды четырёх» (GoF). Наследование — сильная связь между классами. Если изменится родитель, могут сломаться все дети. Композиция более гибкая:

// Вместо наследования:
public class Car : Engine { }

// Лучше использовать композицию:
public class Car
{
    private Engine _engine;
    
    public Car(Engine engine)
    {
        _engine = engine;
    }
}

3. Используй абстрактные классы для общей логики, интерфейсы — для контрактов

Абстрактные классы хороши, когда у тебя есть общая реализация (поля, методы с телом). Интерфейсы — когда ты хочешь только определить, что класс должен уметь делать, без какой-либо реализации.

4. Делай базовые классы абстрактными, если они не должны создаваться напрямую

Если класс «Животное» не имеет смысла сам по себе (все животные — это конкретные виды), сделай его абстрактным. Это защитит от случайного создания бессмысленных объектов.

5. Используй sealed для классов, которые не должны наследоваться

Если ты создал класс-утилиту или класс с критической логикой, запрети наследование. Это упростит поддержку и предотвратит случайные ошибки.

6. Документируй виртуальные методы

Если ты создаёшь метод с virtual, напиши XML-комментарий, объясняющий, как его правильно переопределять. Иначе разработчики могут неправильно понять твои намерения.

/// 

/// Вычисляет площадь фигуры.
/// При переопределении убедитесь, что метод возвращает положительное значение.
/// 
public virtual double GetArea() => 0;

7. Избегай «ромбовидного наследования»

Даже в языках, где оно возможно (как C++), это источник проблем. В C# ты защищён от этого на уровне классов, но с интерфейсами тоже будь осторожен — старайся не создавать сложных пересечений.

Вопросы для самопроверки

1. ← Предыдущая ООП: Классы и объекты в C# (.NET): подробное руков Вперёд → ООП: Инкапсуляция и полиморфизм в C# (.NET): подро