Набор параметров конструктора и набор всех нестатических полей должны полностью совпадать

Обновлено: 07.05.2024

Чтобы настроить, как класс инициализирует его члены или вызывать функции при создании объекта класса, определите конструктор. Конструкторы имеют имена, совпадающие с именами классов, и не имеют возвращаемых значений. Вы можете определить столько перегруженных конструкторов, сколько необходимо для настройки инициализации различными способами. Как правило, конструкторы имеют открытые специальные возможности, чтобы код за пределами определения класса или иерархии наследования может создавать объекты класса. Но вы также можете объявить конструктор как protected или private .

Конструкторы могут при необходимости принимать список инициализаторов элементов. Это более эффективный способ инициализации членов класса, чем назначение значений в тексте конструктора. В следующем примере показан класс Box с тремя перегруженными конструкторами. Последние два используют списки инициализации элементов:

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

Конструкторы могут быть объявлены как inline , , explicitfriend или constexpr .
Конструктор может инициализировать объект, объявленный как const , volatile или const volatile . Объект становится const после завершения конструктора.
Чтобы определить конструктор в файле реализации, присвойте ему полное имя, как и любая другая функция-член: Box::Box() .

Списки инициализаторов элементов

При необходимости конструктор может иметь список инициализаторов элементов, который инициализирует члены класса перед запуском тела конструктора. (Список инициализаторов элементов не совпадает со списком инициализаторов типа std::initializer_list .)

Предпочитать инициализаторы элементов перечисляют значения вместо назначения значений в тексте конструктора. Список инициализаторов элементов напрямую инициализирует элементы. В следующем примере показан список инициализаторов элементов, состоящий из всех identifier(argument) выражений после двоеточия:

Идентификатор должен ссылаться на член класса; он инициализирован со значением аргумента. Аргумент может быть одним из параметров конструктора, вызова функции или . std::initializer_list

const члены и члены ссылочного типа должны быть инициализированы в списке инициализаторов элементов.

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

Конструкторы по умолчанию

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

Конструкторы по умолчанию являются одной из специальных функций-членов. Если конструкторы в классе не объявляются, компилятор предоставляет неявный inline конструктор по умолчанию.

Если используется неявный конструктор по умолчанию, обязательно инициализировать элементы в определении класса, как показано в предыдущем примере. Без этих инициализаторов члены будут неинициализированы, а вызов Volume() создаст значение мусора. Как правило, рекомендуется инициализировать элементы таким образом, даже если не используется неявный конструктор по умолчанию.

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

Конструктор по умолчанию, созданный компилятором, будет определен как удаленный, если какие-либо члены класса не являются конструктором по умолчанию. Например, все члены типа класса и их члены класса должны иметь конструктор по умолчанию и деструкторы, которые доступны. Все члены данных ссылочного типа и все const члены должны иметь инициализатор элементов по умолчанию.

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

Это утверждение является примером проблемы "Большинство vexing Parse". Можно интерпретировать myclass md(); как объявление функции или как вызов конструктора по умолчанию. Поскольку средства синтаксического анализа C++ предпочитают объявления по сравнению с другими вещами, выражение рассматривается как объявление функции. Дополнительные сведения см. в разделе "Большинство синтаксического анализа".

Если объявлены какие-либо конструкторы, отличные от по умолчанию, компилятор не предоставляет конструктор по умолчанию:

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

Однако для инициализации массива объектов Box можно использовать набор списков инициализаторов:

Дополнительные сведения см. в разделе "Инициализаторы".

Конструкторы копии

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

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

При определении конструктора копирования необходимо также определить оператор присваивания копирования (=). Дополнительные сведения см. в разделе "Назначение " и " Копирование конструкторов" и операторов присваивания копирования.

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

При попытке копирования объекта возникает ошибка C2280: попытка ссылаться на удаленную функцию.

Конструкторы перемещения

Конструктор перемещения — это специальная функция-член, которая перемещает владение данными существующего объекта в новую переменную без копирования исходных данных. Он принимает ссылку rvalue в качестве первого параметра, а все последующие параметры должны иметь значения по умолчанию. Конструкторы перемещения могут значительно повысить эффективность программы при передаче больших объектов.

Компилятор выбирает конструктор перемещения, когда объект инициализируется другим объектом того же типа, если другой объект будет уничтожен и больше не нуждается в его ресурсах. В следующем примере показано одно дело, когда конструктор перемещения выбирается с помощью разрешения перегрузки. В конструкторе, который вызывает get_Box() , возвращаемое значение является xvalue (значение eXpiring). Поэтому он не назначается какой-либо переменной и поэтому выходит за пределы области действия. Чтобы обеспечить мотивацию для этого примера, давайте предоставим Box большой вектор строк, представляющих его содержимое. Вместо копирования вектора и его строк конструктор перемещения "крадет" его из значения "box", чтобы вектор теперь принадлежит новому объекту. Вызов std::move необходим, так как оба vector класса string реализуют собственные конструкторы перемещения.

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

Неявно объявленный конструктор перемещения определяется как удаленный, если какие-либо элементы, являющиеся типами классов, не имеют деструктора или если компилятор не может определить, какой конструктор следует использовать для операции перемещения.

Дополнительные сведения о написании конструктора нетривиального перемещения см. в разделе "Конструкторы перемещения" и "Операторы присваивания перемещения" (C++).

Явно заданные по умолчанию и удаленные конструкторы

Конструкторы копирования по умолчанию , конструкторы по умолчанию, конструкторы перемещения, операторы присваивания копирования, операторы присваивания перемещения и деструкторы. Вы можете явно удалить все специальные функции-члены.

Конструкторы constexpr

Конструктор может быть объявлен как constexpr , если

он либо объявлен как стандартный, либо удовлетворяет всем условиям для функций constexpr в целом;
класс не имеет виртуальных базовых классов;
каждый из параметров является литеральным типом;
тело не является блоком try-block функции;
инициализированы все нестатические члены данных и подобъекты базового класса;
Значение , если класс является (a) объединением, имеющим члены варианта, или (б) имеет анонимные объединения, инициализируется только один из членов профсоюза;
каждый нестатический член данных типа класса, а все подобъекты базового класса имеют конструктор constexpr.

Конструкторы списков инициализаторов

Затем создайте объекты Box следующим образом:

Явные конструкторы

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

Можно инициализировать Box следующим образом:

Или передать целое значение функции, принимающей объект Box:

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

Когда конструктор является явным, эта строка вызывает ошибку компилятора: ShippingOrder so(42, 10.8); . Дополнительные сведения см. в разделе о преобразованиях определяемых пользователем типов.

Порядок строительства

Конструктор выполняет свою работу в следующем порядке.

Вызывает конструкторы базовых классов и членов в порядке объявления.

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

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

Выполняет весь код в теле функции.

В следующем примере показан порядок, в котором конструкторы базовых классов и членов вызываются в конструкторе для производного класса. Сначала вызывается базовый конструктор. Затем члены базового класса инициализируются в том порядке, в котором они отображаются в объявлении класса. Наконец, вызывается производный конструктор.

Выходные данные будут выглядеть следующим образом.

Конструктор производного класса всегда вызывает конструктор базового класса, чтобы перед выполнением любых дополнительных операций иметь в своем распоряжении полностью созданные базовые классы. Конструкторы базового класса вызываются в порядке наследования, например, если ClassA является производным от , производным от ClassC ClassB которого является конструктор, ClassC сначала вызывается конструктор, а затем ClassB конструктор, а затем ClassA конструктор.

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

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

Отменяется код в теле функции конструктора.

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

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

Производные конструкторы и расширенная инициализация агрегатов

Если конструктор базового класса не является открытым, но доступен для производного класса, нельзя использовать пустые фигурные скобки для инициализации объекта производного типа в /std:c++17 режиме, а затем в Visual Studio 2017 и более поздних версий.

В следующем примере показана соответствующая реакция на событие в C++14:

В C++17 Derived теперь считается агрегатным типом. Это означает, что инициализация Base через закрытый конструктор по умолчанию происходит непосредственно как часть расширенного правила агрегатной инициализации. Ранее частный Base конструктор был вызван через Derived конструктор, и он был успешно выполнен из-за friend объявления.

В следующем примере показано поведение C++17 в Visual Studio 2017 и более поздних версий в /std:c++17 режиме:

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

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

Должны выводиться следующие выходные данные:

Делегирующие конструкторы

Делегирующий конструктор вызывает другой конструктор в том же классе для выполнения некоторых действий по инициализации. Эта функция полезна, если у вас есть несколько конструкторов, которые все должны выполнять аналогичную работу. Основную логику можно написать в одном конструкторе и вызвать из других. В следующем тривиальном примере Box(int) делегирует свою работу Box(int,int,int):

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

Наследование конструкторов (C++11)

Производный класс может наследовать конструкторы от прямого базового класса с помощью using объявления, как показано в следующем примере:

Visual Studio 2017 и более поздних версий: оператор using в /std:c++17 режиме и более поздних версиях преобразует все конструкторы из базового класса, за исключением тех, которые имеют идентичную сигнатуру конструкторам в производном классе. Как правило, рекомендуется использовать наследуемые конструкторы, когда производный класс не объявляет новые члены данных или конструкторы.

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

Производный класс не может наследоваться от нескольких базовых классов, если эти базовые классы имеют конструкторы с одинаковой сигнатурой.

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

Классы, содержащие члены типа класса, называются составными классами. При создании члена типа класса составного класса конструктор вызывается перед собственным конструктором класса. Если у содержащегося класса нет конструктора по умолчанию, необходимо использовать список инициализации в конструкторе составного класса. В предыдущем примере StorageBox при присвоении типу переменной-члена m_label нового класса Label необходимо вызвать конструктор базового класса и инициализировать переменную m_label в конструкторе StorageBox :

Java-конструктор – это специальный метод, который вызывается при создании экземпляра объекта. Другими словами, когда вы используете новое ключевое слово. Цель конструктора – инициализировать вновь созданный объект перед его использованием.

Вот простой пример:

Здесь создается новый объект MyClass и вызывается конструктор без аргументов MyClass.

Конструктор класса инициализирует экземпляры (объекты) этого класса. Обычно конструктор инициализирует поля объекта, которые необходимо инициализировать. Конструкторы также могут принимать параметры, поэтому поля могут быть инициализированы в объекте во время создания.

Объявление конструктора Java

Простой пример объявления конструктора:

Конструктор – это часть:

Первая часть объявления конструктора – это модификатор доступа. Он имеет те же значения, что и для методов и полей. Определяют, какие классы могут получить доступ (вызвать) конструктор.
Вторая часть – это имя класса, к которому принадлежит конструктор. Использование сигнализирует компилятору, что это конструктор. Также обратите внимание, что конструктор не имеет возвращаемого типа, как другие методы Java.
Третья часть – это список параметров, которые может принимать конструктор. Объявляются в круглых скобках () после части имени класса конструктора. В приведенном выше примере параметры не объявляются.
Четвертая часть – это тело конструктора. Определяется внутри фигурных скобок <> после списка параметров. В приведенном выше примере нет операций внутри тела конструктора. Говорят, что это «пустой» конструктор.

Перегрузка конструктора

Класс может иметь несколько конструкторов, если их сигнатура (параметры, которые они принимают) не совпадают. Когда класс содержит несколько конструкторов, мы говорим, что конструктор перегружен (поставляется в нескольких версиях):

Класс выше содержит два конструктора. Первый – без аргументов, то есть он не принимает параметров. Второй – принимает параметр int. Внутри тела значение параметра int присваивается полю, то есть значение параметра копируется в поле. Таким образом, поле инициализируется для данного значения параметра.

Ключевое слово this перед именем поля (this.number) необязательно. Оно просто сообщает компилятору, что это поле с именем number, на которое ссылаются.

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

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

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

Параметры

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

В этом примере объявлены 3 параметра: первый, последний и год. Внутри тела значения этих трех параметров присваиваются полям объекта Employee.

Разрывы строки на Java после каждого параметра являются необязательными. Компилятор здесь игнорирует разрывы строк. Вы также можете написать объявление параметра в одну строку, если хотите, например:

Чтобы вызвать этот конструктор, который принимает три параметра, вы должны создать экземпляр объекта Employee следующим образом:

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

Параметр конструктора может иметь то же имя, что и поле. В этом случае у компилятора возникают проблемы, зная, на что вы ссылаетесь. По умолчанию, если параметр (или локальная переменная) имеет то же имя, что и поле в том же классе, параметр (или локальная переменная) «затеняет» поле. Посмотрите на этот пример:

Внутри конструктора класса Employee идентификаторы firstName, lastName и birthYear теперь ссылаются на параметры конструктора, а не на поля Employee с одинаковыми именами. Таким образом, конструктор теперь просто устанавливает параметры, равные им самим. Поля Сотрудника никогда не инициализируются.

Чтобы сообщить компилятору, что вы имеете в виду поля класса Employee, а не параметры, поместите ключевое слово this и точку перед именем поля:

Теперь поля Employee правильно инициализируются внутри конструктора.

Вызов

Вы вызываете конструктор, когда создаете новый экземпляр класса, содержащий его:

Этот пример вызывает конструктор без аргументов для MyClass, как определено ранее в этом тексте.

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

Этот пример передает один параметр конструктору MyClass, который принимает int в качестве параметра.

Вызов конструктора из конструктора

В Java можно вызвать конструктор из другого конструктора. Для этого используется ключевое слово this:

Обратите внимание на второе определение конструктора. Внутри тела конструктора вы найдете этот оператор Java:

Ключевое слово this, за которым следуют скобки и параметры, означает, что вызывается другой конструктор в том же классе. Какой другой вызываемый конструктор зависит от того, какие параметры вы передаете в вызов конструктора (в скобках после ключевого слова this). В этом примере это первый конструктор в классе, который вызывается.

Вызов в суперклассах

В класс может расширять другой. В этом случае говорят, что он «наследует» от класса, который он расширяет. Расширяемый класс называется подклассом, а расширяемый – суперклассом.

Класс, который расширяет другой, не наследует его конструкторы. Однако подкласс должен вызывать конструктор в суперклассе внутри одного из конструкторов подкласса!

Класс Car расширяет (наследует) класс Vehicle:

Обратите внимание на конструктор в классе Car. Он вызывает конструктор в суперклассе, используя этот оператор:

Использование ключевого слова super относится к суперклассу класса. Когда за ключевым словом следуют круглые скобки, как здесь, это относится к конструктору в суперклассе. В этом случае это относится к конструктору в классе Vehicle. Поскольку Car расширяет Vehicle, все конструкторы Car должен вызывать конструктор в Vehicle.

Модификаторы доступа

Модификатор доступа конструктора определяет, какие классы в вашем приложении могут вызывать его. Например, если конструктор объявлен защищенным, то он может вызывать только классы в одном пакете или подклассы этого класса.

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

Исключение

Можно сгенерировать исключение из конструктора:

Обратите внимание на исключительную часть throws объявления конструктора. Она объявляет, что конструктор может выдать исключение. Если это произойдет, созданный экземпляр Car недействителен.

Вот пример вызова конструктора Car:

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

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

Есть тестовое задание с вопросом: "Что напечатает следующий код?" При запуске данного кода в IDE получаю следующую последовательность: 14725689 Вопрос следующий : есть какой-то порядок при котором инициализируются статические блоки/нестатические/конструкторы при наследовании?

И собственно почему именно такая последовательность получилась?

4 ответа 4

Немного расширю предыдущий ответ

Поля объекта инициализируются в следующем порядке:

Статические поля класса Parent;
Статический блок инициализации класса Parent;
Статические поля класса Сhild;
Статический блок инициализации класса Child;
Нестатические поля класса Parent;
Нестатический блок инициализации класса Parent;
Конструктор класса Parent;
Нестатические поля класса Сhild;
Нестатический блок инициализации класса Сhild;
Конструктор класса Сhild.

Сначала несколько важных замечаний.
1) Если в классе не создать конструктор, будет создан конструктор по умолчанию (без аргументов), со спецификатором доступа, как у класса:

2)Первой командой конструктора должна быть this(для вызова другого конструктора) или super(для вызова конструктора суперкласса). Еслу этой команды нет - компилятор добавит ее сам. Следующий код не скомпилируется т.к. в суперклассе создан конструктор с аргументом и конструктор поумолчанию не будет создан, при этом в конструкторе подкласса нет super или this, следовательно компилятор добавляет super() - вызов несуществующего конструктора без аргумента.

В вашем примере порядок будет следующий:
1. При вызове конструктора new C(), сначал производится инициализация статических членов и выполнение блоков статической инициализации. Т.к. класс имеет суперклассы, сначала инициализируются статические члены суперкласса от базового и вниз по иерархии. При этом:
1.1 Выполняется static блок в классе A - выводится "1"
1.2 Выполняется static блок в классе B - выводится "4"
1.3 Выполняется static блок в классе С - выводится "7"
2. По цепочке вызовов приходим к конструктору базового класса:
C() -> В(String str) -> B() -> A() <. >
2.1 В базовом классе A инициализируются поля, в порядке их определения и вызаваются блоки инициализации <. >
2.2 Выполняется тело конструктор A() - выводится "2"
2.3 В классе B инициализируются поля, в порядке их определения и вызаваются блоки инициализации <. >(у вас в данном классе полей и блоков нет)
2.4 Выполняется тело конструктора B()- выводится "5"
2.5 Исполнение возвращается в конструктор B(String str)(см. пункт 2), выполняется тело конструктора - выводится "6"
2.6 В классе С инициализируются поля, в порядке их определения и вызаваются блоки инициализации <. >- выводтся "8"
2.7 Выполняется тело конструктора класса С - С()- выводится "9"

Читая книгу Эккеля, натолкнулся на один момент, который не могу понять. Представлен следующий код:

Всегда думал, что перед вызовом конструктора, должны проиницилизоваться поля класса, чтобы в случае обращения к неициализирвоанной переменной в конструкторе не получить исключение. Следуя этой логике вывод на экран надписи "Beetle.k initialized" должен был быть после вывода "Beetle constructor" . Прощу помочь разобраться. Спасибо.

3 ответа 3

Порядок инициализации таков:

Статические элементы родителя
Статические элементы наследника
Глобальные переменные родителя
Конструктор родителя
Глобальные переменные наследника
Конструктор наследника

Пример

Еще было бы неплохо указать, что статические переменные(да и вообще весь статический контент) инициализируется когда классЛоадер впервые натыкается на этот класс. А все другие переменные уже при вызову конструктора.

@Nara всё верно. Если это не делается вручную, то компилятор сам прописывает вызов конструктора родителя без аргументов.

@Nara, вас смутило то, что я в порядке указал конструктор родителя раньше наследника? Дело в том, что первым делом, при чтении конструктора наследника, вызывается конструктор родителя. Так что справедливее писать именно так.

Порядок инициализации экземпляра объекта описан в JLS (12.5 Creation of New Class Instances) (перевод мой):

Присвоить аргументы конструктора переменным-параметрам для вызова этого конструктора.
Если конструктор начинается с явного вызова (§8.8.7.1) другого конструктор этого же класса (с использованием this ), то нужно вычислить аргументы и выполнить тот конструктор рекурсивно, используя эти же 5 шагов. Если выполнение того конструктора будет прервано (completes abruptly), то этот алгоритм будет прерван по тем же причинам, иначе перейти к шагу 5.
Если конструктор не начинается с явного вызова другого конструктора этого же класса (с использованием this ), то для классов, отличных от Object явно или неявно вызывается конструктор суперкласса (используя super ). Нужно вычислить аргументы и выполнить конструктор суперкласса рекурсивно, используя эти же 5 шагов. Если выполнение того конструктора будет прервано (completes abruptly), то этот алгоритм будет прерван по тем же причинам, иначе перейти к шагу 4.
Выполнить инициализаторы экземпляра (instance initializers) и инициализаторы переменных экземпляра (instance variable initializers) для этого класса, с присвоением значений инициализаторов переменных экземпляра соответствующим переменным экземпляра, слева на право в порядке появления в исходном коде класса. Если выполнение любого инициализатора вызывает исключение, следующие инициализаторы не обрабатываются, а этот алгоритм завершается с тем же исключением. Иначе перейти к шагу 5.
Выполнить остальное тело конструктора. Если выполнение будет прервано, то этот алгоритм будет прерван по тем же причинам. Иначе алгоритм завершится нормально.

T - класс и создается экземпляр класса T .
Вызов статического метода, объявленного в T .
Выполняется присваивание статическому полю, объявленному в T .
Статическое поле, объявленное в T используется, и это поле не является константой (§4.12.4) (константа - final переменная примитивного типа или String , объявленная с инициализатором, являющимся константным выражением)
T - класс верхнего уровня (§7.6) и выполняется выражение assert (assert statement) (§14.10) лексически расположенное внутри T (§8.1.3).

Вооружившись этим корявым переводом, посмотрим, что происходит в вашем примере:

Перед прочтением данной статьи рекомендую ознакомиться с предыдущей, «Быстрый старт с Java: начало», поскольку ожидается, что читатель владеет материалом, изложенным в ней — знает о переменных, условиях, циклах и импорте классов. Сегодня мы углубим знания о Java, создавая игру «Крестики-нолики», которая работает в командной строке (консоли). В процессе будет рассмотрена работа с массивами, а также некоторые аспекты объектно-ориентированного программирования (нестатические методы, нестатические поля, конструктор).

Массивы

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

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

С элементами массива можно работать как с обычными переменными, присваивая им результат выражения и читая хранимые значения. При этом в квадратных скобках указывается индекс элемента массива. Индексация в Java идёт с 0 (с нуля). Первый цикл инициализирует элементы массива arr при помощи значений из массива arrInit. Каждый массив имеет поле length, содержащее количество его элементов. Второй цикл выводит элементы массива в консоль, используя второй вариант for — без счётчика цикла.

Методы

Кроме main() класс может содержать и другие методы. Рассмотрим в качестве примера класс с методом add(), который вычисляет и возвращает сумму двух значений, переданных как параметры. Обратите внимание на тип int, который стоит перед именем метода — это тип возвращаемого значения. Две переменные в скобках — параметры. Совокупность имени и параметров называют сигнатурой метода. Вызов метода происходит по имени, в скобках указывают передаваемые значения. В методе они попадают в параметры-переменные. Команда return возвращает результат сложения этих двух переменных и обеспечивает выход из метода.

В качестве полей используем три символьные константы: SIGN_X, SIGN_O и SIGN_EMPTY. Их значения нельзя изменять, об этом говорит модификатор final. Двумерный символьный массив table будет нашим игровым полем. Потребуется также объект random для генерации ходов компьютера и scanner для ввода данных от пользователя.

Имена методов принято писать с маленькой буквы. Однако в коде мы видим метод TicTacToe() — есть ли тут нарушение? Нет, поскольку этот метод особенный и в объектно-ориентированном программировании называется конструктор. Конструктор вызывается сразу после того, как объект создан. Его имя, как видим, должно совпадать с именем класса. Мы используем конструктор для инициализации полей.

Игровая логика

Игровая логика располагается в методе game() и базируется на бесконечном цикле while. Ниже в фрагменте кода последовательность действий описана через комментарии:

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

Реализация вспомогательных методов

Пришло время написать код методов, вызываемых в game(). Самый первый, initTable(), обеспечивает начальную инициализацию игровой таблицы, заполняя её ячейки «пустыми» символами. Внешний цикл, со счетчиком int row, выбирает строки, а внутренний, со счётчиком int col, перебирает ячейки в каждой строке.

Также потребуется метод, отображающий текущее состояние игровой таблицы printTable().

В методе turnHuman(), который позволяет пользователю сделать ход, мы используем метод nextInt() объекта scanner, чтобы прочитать два целых числа (координаты ячейки) с консоли. Обратите внимание как используется цикл do-while: запрос координат повторяется в случае, если пользователь укажет координаты невалидной ячейки (ячейка таблицы занята или не существует). Если с ячейкой всё в порядке, туда заносится символ SIGN_X — «крестик».

Валидность ячейки определяет метод isCellValid(). Он возвращает логическое значение: true — если ячейка свободна и существует, false — если ячейка занята или указаны ошибочные координаты.

Метод turnAI() похож на метод turnHuman() использованием цикла do-while. Только координат ячейки не считываются с консоли, а генерируются случайно, при помощи метода nextInt(3) объекта random. Число 3, передающееся как параметр, является ограничителем. Таким образом, генерируются случайные целые числа от 0 до 2 (в рамках индексов массива игровой таблицы). И метод isCellValid() снова позволяет нам выбрать только свободные ячейки для занесения в них знака SIGN_O — «нолика».

Осталось дописать два последних метода — проверка победы и проверка на ничью. Метод checkWin() проверяет игровую таблицу на «победную тройку» — три одинаковых знака подряд, по вертикали или горизонтали (в цикле), а также по двум диагоналям. Проверяемый знак указан как параметр char dot, за счёт чего метод универсален - можно проверять победу и по «крестикам» и по «ноликам». В случае победы возвращается булевское значение true, в противном случае — false.

Метод isTableFull() во вложенном двойном цикле проходит по всем ячейкам игровой таблицы и, если они все заняты, возвращает true. Если хотя бы одна ячейка ещё свободна, возвращается false.

Теперь осталось собрать все эти методы внутри TicTacToe. Последовательность их расположения в теле класса не важна. А после этого можно попробовать сыграть с компьютером в крестики-нолики.

Заключение

Если вас заинтересовала тема, рекомендую почитать «Java-программирование для начинающих» Майка МакГрата и «Изучаем Java» Кэти Сьерра и Берт Бейтс. Также напоминаю ссылку на мою предыдущую статью, где мы начали знакомство с Java.

Читайте также: