Урок 8.3 — Перегрузка методов

Перегрузка (overload) — это когда ты объявляешь несколько методов с одинаковым именем, но разными параметрами (количество, типы или порядок). Компилятор сам выбирает, какой метод вызвать, глядя на аргументы.

Проще говоря: одно имя — много реализаций. Как глагол «идти»: «идти пешком», «идти на автобусе», «идти в кино» — один глагол, разные уточнения.

static void Print(int value)
{
    Console.WriteLine($"int: {value}");
}

static void Print(string value)
{
    Console.WriteLine($"string: {value}");
}

static void Print(double value)
{
    Console.WriteLine($"double: {value}");
}

// Компилятор выбирает по типу аргумента:
Print(42);        // int: 42
Print("привет");  // string: привет
Print(3.14);      // double: 3.14

Перегрузить метод можно тремя способами:

1. По количеству параметров

static int Sum(int a, int b)
{
    return a + b;
}

static int Sum(int a, int b, int c)
{
    return a + b + c;
}

static int Sum(int a, int b, int c, int d)
{
    return a + b + c + d;
}

Console.WriteLine(Sum(2, 3));        // 5
Console.WriteLine(Sum(2, 3, 4));     // 9
Console.WriteLine(Sum(2, 3, 4, 5));  // 14

2. По типам параметров

static string Concat(string a, string b)
{
    return a + b;  // склеивание строк
}

static int Concat(int a, int b)
{
    return a + b;  // сложение чисел
}

static string Concat(string a, string b, string c)
{
    return a + b + c;
}

Console.WriteLine(Concat("Привет, ", "мир!"));  // Привет, мир!
Console.WriteLine(Concat(5, 3));                 // 8
Console.WriteLine(Concat("A", "B", "C"));        // ABC

3. По порядку (разные последовательности типов)

static void Display(string name, int age)
{
    Console.WriteLine($"{name}, {age} лет");
}

static void Display(int age, string name)
{
    Console.WriteLine($"Возраст {age}, имя {name}");
}

Display("Анна", 25);    // вызов первой версии
Display(30, "Борис");   // вызов второй версии

// Компилятор смотрит на типы аргументов и их порядок

Когда ты вызываешь метод, компилятор выполняет следующие шаги:

1. Ищет методы с совпадающим именем в текущем классе
2. Проверяет количество параметров — сколько аргументов передано
3. Проверяет типы аргументов — каждый аргумент должен быть совместим с типом параметра
4. Если подходит несколько — выбирает «наиболее конкретную» версию (ближайший тип)
5. Если не подходит ни одна — ошибка компиляции
6. Если подходит несколько одинаково — неоднозначность, ошибка компиляции

static void Foo(int x)
{
    Console.WriteLine("int");
}

static void Foo(double x)
{
    Console.WriteLine("double");
}

static void Foo(long x)
{
    Console.WriteLine("long");
}

Foo(5);      // int — точное совпадение
Foo(5.0);    // double — точное совпадение
Foo(5L);     // long — точное совпадение
// Foo(5.0f); // float — нет точного, но C# расширит до double

static void Bar(int a, double b) { }
static void Bar(double a, int b) { }

// Bar(1, 2);  // ❌ Ошибка! Неоднозначность: оба подходят

// Нужно указать типы явно:
Bar(1, 2.0);   // ОК — первый int, второй double
Bar(1.0, 2);   // ОК — первый double, второй int

Распространённый вопрос: можно ли перегрузить метод, меняя только тип возврата? Нет. Компилятор не может определить, какую версию вызывать, только по возвращаемому типу, потому что результат может быть не использован:

// ❌ Ошибка компиляции! Одинаковая сигнатура
static int GetValue() { return 42; }
static string GetValue() { return "42"; }

// Компилятор не знает, какой вызвать:
// Console.WriteLine(GetValue());  // Какой из двух?!
// int x = GetValue();  // а так понятно? Нет, всё равно ошибка

Сигнатура метода включает: имя метода + количество, типы и порядок параметров. Тип возврата, модификаторы (static, ref) и имена параметров не входят в сигнатуру.

Перегрузка — мощный, но не всегда нужный инструмент. Вот правила good practices:

Хороший пример — метод Console.WriteLine который имеет 19 перегрузок. Плохой пример — если бы ты создал 10 версий ProcessData с разными комбинациями, которые делают разное.

Создадим класс Vector с перегруженными операциями (на самом деле методами):

using System;

class Program
{
    // Перегрузка Draw — рисует разные фигуры
    static void Draw(string text)
    {
        Console.WriteLine($"[{text}]");
    }

    static void Draw(char symbol, int count)
    {
        Console.WriteLine(new string(symbol, count));
    }

    static void Draw(int width, int height, char fill = '#')
    {
        for (int y = 0; y < height; y++)
        {
            Console.WriteLine(new string(fill, width));
        }
    }

    // Перегрузка Calc — разные способы расчёта
    static double Calc(double a, double b, char op)
    {
        return op switch
        {
            '+' => a + b,
            '-' => a - b,
            '*' => a * b,
            '/' => a / b,
            _ => throw new ArgumentException("Неизвестная операция")
        };
    }

    static double Calc(double a, double b)
    {
        return a * b;  // по умолчанию — умножение
    }

    static double Calc(double a)
    {
        return a * a;  // квадрат числа
    }

    static void Main()
    {
        Draw("Привет");         // [Привет]
        Draw('*', 20);          // **********
        Draw(5, 3);             // прямоугольник 5x3
        Draw(7, 2, '.');        // прямоугольник 7x2 из точек

        Console.WriteLine();
        Console.WriteLine(Calc(5, 3, '+'));  // 8
        Console.WriteLine(Calc(5, 3));       // 15 (умножение)
        Console.WriteLine(Calc(5));          // 25 (квадрат)
    }
}

Создай класс Formatter с перегруженными методами Format:

1. Format(string text) — просто возвращает текст
2. Format(string text, bool upper) — если upper true, то в верхнем регистре
3. Format(string text, int width) — центрирует текст по ширине
4. Format(string text, char pad, int width) — центрирует с заданным символом-заполнителем
5. Format(int number) — возвращает число с разделителями разрядов
6. Продемонстрируй все перегрузки в Main

using System;

class Program
{
    static string Format(string text)
    {
        return text;
    }

    static string Format(string text, bool upper)
    {
        return upper ? text.ToUpper() : text.ToLower();
    }

    static string Format(string text, int width)
    {
        if (text.Length >= width)
            return text;
        int padding = (width - text.Length) / 2;
        return new string(' ', padding) + text;
    }

    static string Format(string text, char pad, int width)
    {
        if (text.Length >= width)
            return text;
        int padding = (width - text.Length) / 2;
        return new string(pad, padding) + text;
    }

    static string Format(int number)
    {
        return number.ToString("N0");
    }

    static void Main()
    {
        Console.WriteLine(Format("Привет"));
        Console.WriteLine(Format("Привет", true));
        Console.WriteLine(Format("Привет", 20));
        Console.WriteLine(Format("Привет", '.', 20));
        Console.WriteLine(Format(1234567));
    }
}