Если вы попробовали решить задачу средствами, которые у нас уже есть, то, скорее всего, перенесли присваивания в отдельный метод. Это естественный ход: мы уже умеем объединять действия и передавать в них данные.

Например, класс Mage мог выглядеть так:

public class Mage
{
    public string Name;
    public int Mana;

    public void Initialize(string name, int mana)
    {
        Name = name;
        Mana = mana;
    }

    public void CastSpell()
    {
        if (Mana >= 5)
        {
            Mana -= 5;
            Console.WriteLine($"{Name} произносит заклинание! Осталось маны: {Mana}");
        }
        else
        {
            Console.WriteLine($"{Name}: недостаточно маны!");
        }
    }
}

И тогда создание мага превращается в два шага:

Mage albert = new Mage();
albert.Initialize("Альберт", 20);

Это уже лучше: мы действительно объединили два присваивания в одну операцию и перестали дублировать код.

Объект создаётся отдельно от его заполнения, и между этими действиями нет жёсткой связи. Метод Initialize можно забыть вызвать:

Mage merlin = new Mage();
// забыли задать имя и ману

Объект всё равно будет создан, и программа не заметит, что обязательный шаг пропущен. Правило «у мага должно быть имя и начальный запас маны» никак не закреплено в самом классе.

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

Когда создание и заполнение — это одно действие

В C# для этого существует специальный механизм — конструктор.

Прежде чем писать конкретный код, давайте зафиксируем его общую идею. Конструктор объявляется внутри класса, имеет имя, совпадающее с именем класса, и не имеет возвращаемого типа — даже void не пишется. Он может принимать параметры, как обычный метод, но вызывается автоматически в момент создания объекта через new.

То есть мы описываем, какие данные нужны для создания объекта, и связываем это напрямую с выражением new.

Перепишем класс Mage, убрав метод Initialize и добавив конструктор:

public class Mage
{
    public string Name;
    public int Mana;

    public Mage(string name, int mana)
    {
        Name = name;
        Mana = mana;
    }

    public void CastSpell()
    {
        if (Mana >= 5)
        {
            Mana -= 5;
            Console.WriteLine($"{Name} произносит заклинание! Осталось маны: {Mana}");
        }
        else
        {
            Console.WriteLine($"{Name}: недостаточно маны!");
        }
    }
}

Теперь создание мага выглядит так:

Mage albert = new Mage("Альберт", 20);

Мы передаём аргументы прямо в круглых скобках после имени класса. Именно здесь вызывается конструктор: он получает "Альберт" и 20, а затем записывает их в поля нового объекта.

В отличие от обычного метода, конструктор нельзя вызвать через точку у уже созданного объекта:

albert.Mage("Альберт", 20); // ошибка

Конструктор вызывается только как часть выражения new в момент создания объекта.

Аргументы передаются по порядку и по типам. Конструктор ожидает сначала string, потом int, поэтому, если поменять их местами, компилятор не сможет подобрать подходящий вариант:

Mage gandalf = new Mage(30, "Гэндальф"); // ошибка

Если мы создадим несколько магов, каждый вызов new Mage(...) запустит конструктор заново и создаст отдельный объект со своими значениями:

Mage albert = new Mage("Альберт", 20);
Mage merlin = new Mage("Мерлин", 15);

albert.CastSpell();
merlin.CastSpell();

Это та же независимость объектов, о которой мы говорили в прошлом уроке: каждый маг живёт своей жизнью и хранит собственные данные.

Точно так же работает и класс воина:

public class Warrior
{
    public string Name;
    public int Stamina;

    public Warrior(string name, int stamina)
    {
        Name = name;
        Stamina = stamina;
    }

    public void Attack()
    {
        if (Stamina >= 5)
        {
            Stamina -= 5;
            Console.WriteLine($"{Name} наносит удар! Осталось выносливости: {Stamina}");
        }
        else
        {
            Console.WriteLine($"{Name}: недостаточно выносливости!");
        }
    }
}

Warrior edward = new Warrior("Эдвард", 25);
edward.Attack();

Теперь обязательные начальные значения и для магов, и для воинов передаются непосредственно при создании объектов.

Дополнительные варианты создания

Отсюда напрашивается вопрос: почему раньше такой код работал?

Mage mage = new Mage();

Хотя никакого конструктора мы не писали.

Дело в том, что если в классе нет ни одного явно объявленного конструктора, компилятор добавляет его автоматически. Для нашего класса это эквивалентно такому варианту:

public Mage()
{
}

В его теле нет наших инструкций по заполнению полей, поэтому значения устанавливаются по умолчанию: например, int получает 0, а строка — null. Именно поэтому раньше приходилось вручную задавать имя и ману после создания объекта.

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

Mage mage = new Mage(); // ошибка

И это как раз то поведение, которого мы добивались: нельзя создать мага без обязательных данных.

Однако в реальных задачах бывает, что способов создания объекта нужно несколько. Например, Фёдору понадобился «служебный» маг для тестов — без имени, но с фиксированными значениями. Тогда мы можем добавить второй конструктор:

public class Mage
{
    public string Name;
    public int Mana;

    public Mage()
    {
        Name = "Безымянный маг";
        Mana = 50;
    }

    public Mage(string name, int mana)
    {
        Name = name;
        Mana = mana;
    }
}

Теперь доступны оба варианта:

Mage testMage = new Mage();
Mage albert = new Mage("Альберт", 20);

Компилятор выбирает подходящий конструктор по количеству и типам аргументов.

Иногда различие между вариантами ещё меньше. Допустим, мы решили, что у всех магов по умолчанию 50 маны. Тогда можно задать значение прямо в параметре:

public Mage(string name, int mana = 50)
{
    Name = name;
    Mana = mana;
}

Теперь можно создавать объекты так:

Mage merlin = new Mage("Мерлин");      // мана = 50
Mage albert = new Mage("Альберт", 20);

Параметры со значениями по умолчанию всегда располагаются после обязательных, поэтому new Mage() по-прежнему недопустим.

Не стоит переоценивать роль конструктора. Он задаёт начальное состояние объекта, но не защищает его от последующих изменений:

Mage mage = new Mage("Мерлин", 50);
mage.Name = "";
mage.Mana = -100;

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