Полиморфизм — первые шаги


Вводный урок

Назад – Наследование · Все уроки (иврит)

Полиморфизм («множество форм») — один из основных принципов ООП. Один и тот же метод может иметь разные реализации в разных классах. Это позволяет писать более общий код, работающий с базовым классом, а во время выполнения система выбирает нужную реализацию по фактическому типу объекта.

Сначала рекомендуется просмотреть эту презентацию на иврите.

Переменная базового типа и объект производного типа

В строке Animal pet = new Dog(); объявленный тип переменной pet — Animal, а фактический тип объекта — Dog. Присваивание возможно, потому что каждый Dog является Animal. Это неявное преобразование к базовому типу.

using System;

class Animal
{
    public virtual string Speak() => "Animal sound";
}

class Dog : Animal
{
    public override string Speak() => "Woof!";
    public void Bark() => Console.WriteLine("Bark!");
}

class Program
{
    static void Main()
    {
        Animal pet = new Dog();

        Console.WriteLine(pet.Speak()); // Woof!
        // pet.Bark();                  // CS1061

        Dog sameDog = (Dog)pet;
        sameDog.Bark();                 // Bark!

        if (pet is Dog dog)
        {
            dog.Bark();                 // Bark!
        }
    }
}
  • Вызов pet.Speak() компилируется, потому что метод объявлен в Animal. Метод виртуальный, поэтому для объекта Dog выполняется переопределение из Dog.
  • Вызов pet.Bark() приводит к ошибке компиляции. Метод объявлен только в Dog. Преобразование (Dog)pet даёт ссылку типа Dog на тот же объект. Если объект создан через new Animal(), такое преобразование вызовет InvalidCastException.
  • Проверка pet is Dog dog даёт переменную dog типа Dog, когда объект подходит. Если объект создан через new Animal(), условие ложно и тело if пропускается.

Виды полиморфизма

  • Полиморфизм времени компиляции (статический): реализуется через перегрузку методов (Overloading). Компилятор выбирает подходящую перегрузку по аргументам вызова и их типам, известным при компиляции.
  • Полиморфизм времени выполнения (динамический): реализуется через переопределение методов (Overriding). Базовый класс объявляет метод, например с virtual или abstract, а производные классы переопределяют его с override. Во время выполнения реализация выбирается по фактическому типу объекта.

Пример: геометрические фигуры

Построим иерархию классов:

  • Shape — базовый класс с методом Area().
  • Rectangle — наследует от Shape и вычисляет площадь прямоугольника.
  • Square — наследует от Rectangle: квадрат является частным случаем прямоугольника.
  • Circle — наследует от Shape и вычисляет площадь круга.

UML-диаграмма

classDiagram class Shape { +Area() double +ToString() string } class Rectangle { -width : double -height : double +Area() double +ToString() string } class Square { +Area() double +ToString() string } class Circle { -radius : double +Area() double +ToString() string } Shape <|-- Rectangle Shape <|-- Circle Rectangle <|-- Square

Повторение правил UML (Unified Modeling Language)

  • - перед именем обозначает private.
  • + перед именем обозначает public.
  • 🠈 — наследование: стрелка направлена от производного класса к базовому. Её треугольный наконечник не закрашен.
  • ─♦ — композиция, отношение «содержит» с зависимым жизненным циклом частей: например, у человека есть рука, у автомобиля — колёса.
  • ─◇ — агрегация: например, автомобиль перевозит пассажиров, но они существуют и независимо от автомобиля.

Такие диаграммы удобно создавать в редакторе Mermaid. Можно воспользоваться помощью ИИ.

Код C#

📄 Нажмите, чтобы показать код
using System;

class Shape
{
    public virtual double Area() => 0.0;

    public override string ToString() => "Shape";
}

class Rectangle : Shape
{
    protected double width;
    protected double height;

    public Rectangle(double width, double height)
    {
        this.width = width;
        this.height = height;
    }

    public override double Area() => width * height;

    public override string ToString() => $"Rectangle({width}x{height})";
}

class Square : Rectangle
{
    public Square(double side) : base(side, side) { }

    public override string ToString() => $"Square({width})";
}

class Circle : Shape
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public override double Area() => Math.PI * radius * radius;

    public override string ToString() => $"Circle({radius})";
}

class ShapesDemo
{
    static void Main()
    {
        Shape[] shapes = new Shape[3];
        shapes[0] = new Rectangle(3, 4);
        shapes[1] = new Circle(5);
        shapes[2] = new Square(2);

        foreach (Shape s in shapes)
        {
            Console.WriteLine($"{s} area = {s.Area()}");
        }
    }
}

Возможный вывод

Rectangle(3x4) area = 12
Circle(5) area = 78.53981633974483
Square(2) area = 4

Преимущества полиморфизма

  • Более общий и гибкий код: один и тот же вызов метода работает с объектами разных типов.
  • Простое расширение: можно добавлять новые производные классы, сохраняя общий код обработки объектов.
  • Удобное сопровождение: код становится короче, понятнее и проще в поддержке.

Полиморфизм помогает писать абстрактный, модульный и расширяемый код. В следующем уроке подробнее сравним перегрузку методов (статический полиморфизм) и переопределение методов (динамический полиморфизм).

Следующие уроки пока доступны на иврите. Сохранённое предпочтение языка будет применено, когда появится перевод.

Шпаргалка по преобразованиям и полиморфизму (на иврите)

2. Урок 2

3. Во время выполнения или во время компиляции

4. Что происходит с override и без него