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

В рассмотренных ранее примерах после создания объекта нам приходилось напрямую или с помощью специальных методов присваивать значения полям объекта. Это не всегда удобно. Хорошо было бы иметь возможность задавать значения полей объекта уже на этапе создания объекта. И такая возможность имеется. Связана она с использованием конструктора.

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

Имя конструктора совпадает с именем класса. Обычно описывается с ключевым словом public.
Конструктор не возвращает результат, и идентификатор типа результата для конструктора не указывается (в отличие от обычных методов, которые в подобном случае описываются с идентификатором void).
У конструктора могут быть аргументы. Аргументы передаются конструктору при создании объекта.
Конструктор можно перегружать. Это означает, что в классе может быть описано несколько конструкторов. Каждая версия конструктора отличается типом и/или количеством аргументов.

Если в инструкции создания объекта на основе оператора new после имени класса в круглых скобках указываются определенные значения, то это и есть аргументы, которые передаются конструктору.

Инструкция вида

  new Класс()

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

  new Класс(аргументы)

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

Как отмечалось выше, в классе может быть описано несколько конструкторов (или несколько версий конструктора). В таком случае версия конструктора, вызываемая при создании объекта, определяется по количеству и типу аргументов, переданных конструктору в команде создания объекта. Здесь имеет место полная аналогия с перегрузкой методов. Небольшой пример использования конструкторов представлен ниже.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace pr84_1
{
    // Описание класса с конструктором: 
    class MyClass
    {
        // Закрытые поля:
        private int num; // Целочисленное поле 
        private char symb; // Символьное поле 
        private string txt; // Текстовое поле 
        // Открытый метод для отображения значений полей: 
        public void show()
        {
            Console.WriteLine("Поля: {0}, \'{1}\' и \"{2}\"", num, symb, txt);
        }

        // Конструктор без аргументов: 
        public MyClass()
        {
            // Значения полей: 
            num = 100;
            symb = 'A';
            txt = "Kpacный";
        }

        // Конструктор с одним целочисленным аргументом: 
        public MyClass(int n)
        {
            // Значения полей: 
            num = n;
            symb = 'B';
            txt = "Желтый";
        }

        // Конструктор с двумя аргументами: 
        public MyClass(int n, char s)
        {
            // Значения полей:
            num = n;
            symb = s;
            txt = "3еленый";
        }

        // Конструктор с тремя аргументами: 
        public MyClass(int n, char s, string t)
        {
            // Значения полей:
            num = n;
            symb = s;
            txt = t;
        }

        // Конструктор с одним текстовым аргументом: 
        public MyClass(string t)
        {
            // Значения полей: 
            num = 0;
            symb = 'Z';
            txt = t;
        }
    }
    
    // Класс с главным методом:
    class Program
    {
        // Главный метод:
        static void Main()
        {
            // Создание объектов.
            // Вызывается конструктор без аргументов:
            MyClass A = new MyClass();

            // Проверяются значения полей объекта:
            A.show();

            // Вызывается конструктор с целочисленным аргументом:
            MyClass B = new MyClass(200);

            // Проверяются значения полей объекта:
            B.show();

            // Вызывается конструктор с двумя аргументами:
            MyClass C = new MyClass(300, 'C');

            // Проверяются значения полей объекта:
            C.show();

            // Вызывается конструктор с тремя аргументами:
            MyClass D = new MyClass(400, 'D', "Синий");

            // Проверяются значения полей объекта:
            D.show();

            // Вызывается конструктор с символьным аргументом:
            MyClass F = new MyClass('A');
            // Проверяются значения полей объекта:
            F.show();

            // Вызывается конструктор с текстовым аргументом:
            MyClass G = new MyClass("Серый");
            // Проверяются значения полей объекта:
            G.show();
            // Задержка:
            Console.ReadLine();
        }
    }
}

Архив проекта можно взять здесь.

Как выглядит результат выполнения программы, показано ниже.

Рис.1. Результат выполнения программы

Мы в данном случае имеем дело с классом MyClass, у которого есть три закрытых ноля: целочисленное, символьное и текстовое. В классе описан открытый метод show(), отображающий в консольном окне значения полей.

В теле метода show() использована команда

  Console.WriteLine("Поля: {0}, \'{1}\' и \"{2}\"", num, symb, txt);     .

Командой в консольном окне отображается строка

  "Поля: {0}, \'{1}\' и \"{2}\"",

в которой вместо блока {0} отображается значение целочисленного поля num, вместо блока {1} отображается значение символьного поля symb, а вместо блока {2} отображается значение текстового поля txt. Также в отображаемой текстовой строке мы используем одинарные и двойные кавычки. Одинарные кавычки добавляем в текстовую строку с помощью инструкции \', а двойные кавычки добавляются в текстовую строку с помощью инструкции \".

Кроме метода show(), в классе описано пять версий конструктора:

без аргументов,
с одним целочисленным аргументом,
с одним текстовым аргументом,
с двумя аргументами (целочисленным и символьным) и
с тремя аргументами (целочисленным, символьным и текстовым).

Каждая из версий конструктора описана с ключевым словом public.

Конструктор - это метод. Если мы хотим вызывать конструктор (то есть создавать объекты) вне пределов класса (а мы хотим), то конструктор должен быть открытым. Чтобы он был открытым, конструктор описывают с ключевым словом public - как и в случае, когда в классе описывается открытый метод.

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

        // Конструктор без аргументов: 
        public MyClass()
        {
            // Значения полей: 
            num = 100;
            symb = 'A';
            txt = "Kpacный";
        }

Это означает, что если мы создаем объект и конструктору не передаем аргументы (как это имеет место в команде

  MyClass A = new MyClass();

в главном методе программы), то целочисленному полю создаваемого объекта будет присвоено значение 100, символьное поле получит значение 'А', а текстовое поле получит значение "Красный".

Конструктор с целочисленным аргументом описан таким образом, что его аргумент определяет значение целочисленного ноля создаваемого объекта, а символьное и текстовое поле получают соответственно значения 'В' и "Желтый".

Конструктору могут передаваться два аргумента: первый целочисленный и второй символьный. Они определяют значения целочисленного и символьного полей объекта. Текстовое поле получает значение "Зеленый". Если же конструктору передаются три аргумента (целое число, символ и текст), то они определяют значения полей объекта, который создается.

Кроме версии конструктора с одним целочисленным аргументом, класс MyClass содержит описание версии конструктора с одним текстовым аргументом. Текстовое значение, переданное аргументом конструктору, задает значение текстового поля создаваемого объекта. При этом целочисленное поле получает значение 0, а символьному полю присваивается значение 'Z'.

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

  MyClass B = new MyClass(200);

вызывается конструктор с одним целочисленным аргументом. Команда

  MyClass C = new MyClass(300, 'C');

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

  MyClass D = new MyClass(400, 'D', "Синий");    .

В команде

  MyClass G = new MyClass("Серый");

конструктору передается один текстовый аргумент. Такая версия конструктора в классе MyClass описана и будет вызвана при создании объекта. Но вот в команде

  MyClass F = new MyClass('A');

конструктору передается символьный аргумент, и такой версии конструктора (с одним символьным аргументом) в классе MyClass нет. Зато в классе MyClass есть версия конструктора с одним целочисленным аргументом, а в языке C# разрешено автоматическое преобразование символьного типа в целочисленный. В результате при создании объекта командой

  MyClass F = new MyClass('A');

вызывается конструктор с целочисленным аргументом, а символьное значение 'А' фактически переданного аргумента преобразуется к числовому значению 65 (код символа 'А' в кодовой таблице).

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

  MyClass A = new MyClass();

станет некорректной.

На следующем шаге мы рассмотрим деструктор.

Предыдущий шаг Содержание Следующий шаг