Инициализаторы

Инициализаторы вызывают для создания нового экземпляра определенного типа. В его самой простой форме инициализатор походит на метод экземпляра без параметров, записанное использование init ключевое слово:

Пример ниже определяет новую вызванную структуру Fahrenheit сохранить температуры, выраженные в Шкале Фаренгейта. Fahrenheit структура имеет сохраненное свойство того, temperature, который имеет тип Double:

Структура определяет единственный инициализатор, init, без параметров, который инициализирует сохраненную температуру со значением 32.0 (точка замерзания воды, когда выражено в Шкале Фаренгейта).

Значения свойств по умолчанию

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

Можно записать Fahrenheit структурируйте сверху в более простой форме путем обеспечения значения по умолчанию для temperature свойство в точке, которой объявляется свойство:

Параметры инициализации

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

Следующий пример определяет вызванную структуру Celsius, который хранит температуры, выраженные в Шкале Цельсия. Celsius структура реализует два пользовательских вызванные инициализатора init(fromFahrenheit:) и init(fromKelvin:), которые инициализируют новый экземпляр структуры со значением от различной шкалы температур:

Первый инициализатор имеет единственный параметр инициализации с внешним именем fromFahrenheit и локальное имя fahrenheit. Второй инициализатор имеет единственный параметр инициализации с внешним именем fromKelvin и локальное имя kelvin. Оба инициализатора преобразовывают свой отдельный аргумент в значение в Шкале Цельсия и хранят это значение в вызванном свойстве temperatureInCelsius.

Локальные и внешние названия параметра

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

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

Следующий пример определяет вызванную структуру Color, с тремя постоянными вызванными свойствами red, green, и blue. Эти свойства хранят значение между 0.0 и 1.0 указать сумму красного, зеленого цвета, и синий в цвете.

Color предоставляет инициализатору три соответственно именованных параметра типа Double для его красных, зеленых, и синих компонентов. Color также предоставляет второму инициализатору сингл white параметр, использующийся для обеспечения того же значения для всех трех компонентов цвета.

Оба инициализатора могут использоваться для создания нового Color экземпляр, путем обеспечения назвал значения для каждого параметра инициализатора:

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

Параметры инициализатора без внешних имен

Если Вы не хотите использовать внешнее имя для параметра инициализатора, запишите подчеркивание (_) вместо явного внешнего имени для того параметра для переопределения поведения по умолчанию.

Вот расширенная версия Celsius пример от ранее, с дополнительным инициализатором для создания нового Celsius экземпляр от a Double значение, которое уже находится в Шкале Цельсия:

Вызов инициализатора Celsius(37.0) ясно в его намерении без потребности во внешнем названии параметра. Является поэтому надлежащим записать этот инициализатор как init(_ celsius: Double) так, чтобы это можно было вызвать путем обеспечения ня назван Double значение.

Дополнительные типы свойства

Если Ваш пользовательский тип имеет сохраненное свойство, которому логически позволяют не иметь “никакого значения” — возможно, потому что его значение не может быть установлено во время инициализации, или потому что позволяется не иметь “никакого значения” в некоторой более поздней точке — объявляют свойство с дополнительным типом. Свойства дополнительного типа автоматически инициализируются со значением nil, указание, что свойство сознательно предназначается еще, чтобы не иметь “никакого значения” во время инициализации.

Следующий пример определяет вызванный класс SurveyQuestion, с дополнительным String свойство вызывают response:

Ответ на вопрос об исследовании не может быть известен, пока его не спрашивают, и таким образом, response свойство объявляется с типом String?, или “дополнительный String”. Это автоматически присваивается значение по умолчанию nil, значение “никакой строки все же”, когда новый экземпляр SurveyQuestion инициализируется.

Присвоение постоянных свойств во время инициализации

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

Можно пересмотреть SurveyQuestion пример сверху для использования постоянного свойства, а не переменного свойства для text свойство вопроса, чтобы указать, что вопрос не изменяется один раз экземпляр SurveyQuestion создается. Даже при том, что text свойство является теперь константой, оно может все еще быть установлено в инициализаторе класса:

Инициализаторы Memberwise для типов структуры

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

memberwise инициализатор является кратким способом инициализировать свойства элемента новых экземпляров структуры. Начальные значения для свойств нового экземпляра могут быть переданы memberwise инициализатору по имени.

Пример ниже определяет вызванную структуру Size с двумя вызванными свойствами width и height. Оба свойства выведены, чтобы иметь тип Double путем присвоения значения по умолчанию 0.0.

Size структура автоматически получает init(width:height:) инициализатор memberwise, который можно использовать для инициализации нового Size экземпляр:

Определяемые инициализаторы и инициализаторы удобства

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

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

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

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

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

Синтаксис для определяемого и инициализаторов удобства

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

Инициализаторы удобства записаны в том же стиле, но с convenience модификатор поместил перед init ключевое слово, разделенное пространством:

Делегация инициализатора к типам классов

Для упрощения отношений между определяемым и инициализаторами удобства Swift применяет соблюдающий трех правил для вызовов делегации между инициализаторами:

Правило 1

Определяемый инициализатор должен вызвать определяемый инициализатор от своего непосредственного суперкласса.

Правило 2

Инициализатор удобства должен вызвать другой инициализатор от того же класса.

Правило 3

Инициализатор удобства должен в конечном счете вызвать определяемый инициализатор.

Простой способ помнить это:

• Определяемые инициализаторы должны всегда делегировать.

• Инициализаторы удобства должны всегда делегировать через.

Эти правила проиллюстрированы в числе ниже:

Здесь, суперкласс имеет единственный определяемый инициализатор и два инициализатора удобства. Один инициализатор удобства вызывает другой инициализатор удобства, поочередно вызывающий единственный определяемый инициализатор. Это удовлетворяет правила 2 и 3 сверху. Суперкласс самостоятельно не имеет дальнейшего суперкласса, и таким образом, не применяется правило 1.

Подкласс в этом числе имеет два определяемых инициализатора и один инициализатор удобства. Инициализатор удобства должен вызвать один из двух определяемых инициализаторов, потому что это может только вызвать другой инициализатор от того же класса. Это удовлетворяет правила 2 и 3 сверху. Оба определяемых инициализатора должны вызвать единственный определяемый инициализатор от суперкласса, для удовлетворения правила 1 сверху.

Число ниже шоу более сложная иерархия классов для четырех классов. Это иллюстрирует, как определяемые инициализаторы в этой иерархии действуют как точки «трубы» для инициализации класса, упрощая взаимосвязи среди классов в цепочке:

Двухфазная инициализация

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

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

Компилятор Swift выполняет четыре полезных проверки безопасности, чтобы удостовериться, что двухфазная инициализация завершается без ошибки:

Проверка безопасности 1

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

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

Проверка безопасности 2

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

Проверка безопасности 3

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

Проверка безопасности 4

Инициализатор не может вызвать методы экземпляра, считать значения любых свойств экземпляра или относиться к self как значение, пока первая фаза инициализации не завершена.

Экземпляр класса не полностью допустим, пока не заканчивается первая фаза. К свойствам можно только получить доступ, и методы можно только вызвать, как только экземпляр класса, как известно, допустим в конце первой фазы.

Вот то, как двухфазная инициализация теряет значение, на основе этих четырех проверок безопасности выше:

Фаза 1

• Инициализатор определяемого или удобства вызывают на классе.

• Память для нового экземпляра того класса выделяется. Память еще не инициализируется.

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

• Определяемый инициализатор передает к инициализатору суперкласса для выполнения той же задачи для ее собственных сохраненных свойств.

• Это продолжает цепочку наследования классов, пока не достигнута вершина цепочки.

• Как только вершина цепочки достигнута, и заключительный класс в цепочке гарантировал, чтобы все ее сохраненные свойства имели значение, память экземпляра считается полностью инициализированной, и фаза 1 завершена.

Фаза 2

• Работа отступает от вершины цепочки, каждый определяемый инициализатор в цепочке имеет опцию настроить экземпляр далее. Инициализаторы теперь в состоянии получить доступ self и может изменить его свойства, вызвать его методы экземпляра, и т.д.

• Наконец, любые инициализаторы удобства в цепочке имеют опцию настроить экземпляр и работать с self.

Вот то, как фаза 1 ищет требование инициализации гипотетического подкласса и суперкласса:

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

Определяемый инициализатор удостоверяется, что все свойства подкласса имеют значение согласно проверке безопасности 1. Это тогда вызывает определяемый инициализатор на своем суперклассе для продолжения инициализации цепочка.

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

Как только все свойства суперкласса имеют начальное значение, его память считают полностью инициализированной, и Фаза 1 завершена.

Вот то, как фаза 2 ищет тот же вызов инициализации:

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

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

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

Наследование инициализатора и переопределение

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

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

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

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

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

Пример ниже определяет вызванный базовый класс Vehicle. Этот базовый класс объявляет сохраненное вызванное свойство numberOfWheels, со значением по умолчанию Int значение 0. numberOfWheels свойство используется вычисленным вызванным свойством description создать a String описание характеристик механизма:

Vehicle класс обеспечивает значение по умолчанию для своего единственного сохраненного свойства и не обеспечивает пользовательских инициализаторов самого. В результате это автоматически получает инициализатор по умолчанию, как описано в Инициализаторах По умолчанию. Инициализатор по умолчанию (когда доступный) всегда является определяемым инициализатором для класса и может использоваться для создания нового Vehicle экземпляр с a numberOfWheels из 0:

Следующий пример определяет подкласс Vehicle вызванный Bicycle:

Bicycle подкласс определяет пользовательский определяемый инициализатор, init(). Этот определяемый инициализатор соответствует определяемый инициализатор от суперкласса Bicycle, и так Bicycle версия этого инициализатора отмечена с override модификатор.

init() инициализатор для Bicycle запускается путем вызова super.init(), который вызывает инициализатор по умолчанию для Bicycle суперкласс класса, Vehicle. Это гарантирует что numberOfWheels унаследованное свойство инициализируется Vehicle прежде Bicycle имеет возможность изменить свойство. После вызова super.init(), исходное значение numberOfWheels заменяется новым значением 2.

Если Вы создаете экземпляр Bicycle, можно вызвать его наследованный description вычисленное свойство, чтобы видеть, как numberOfWheels свойство было обновлено:

Автоматическое наследование инициализатора

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

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

Правило 1

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

Правило 2

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

Даже если Ваш подкласс добавляет дальнейшие инициализаторы удобства, эти правила применяются.

Определяемый и инициализаторы удобства в действии

Следующий пример показывает определяемые инициализаторы, инициализаторы удобства и автоматическое наследование инициализатора в действии. Этот пример определяет иерархию трех вызванных классов Food, RecipeIngredient, и ShoppingListItem, и демонстрирует, как взаимодействуют их инициализаторы.

Базовый класс в иерархии вызывают Food, который является простым классом для инкапсуляции имени пищевых продуктов. Food класс представляет сингл String свойство вызывают name и обеспечивает два инициализатора для создания Food экземпляры:

Число ниже шоу цепочка инициализатора для Food класс:

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

init(name: String) инициализатор от Food класс предоставлен как определяемый инициализатор, потому что он гарантирует что все сохраненные свойства нового Food экземпляр полностью инициализируется. Food класс не имеет суперкласса, и таким образом, init(name: String) инициализатор не должен вызывать super.init() завершать его инициализацию.

Food класс также обеспечивает инициализатор удобства, init(), без параметров. init() инициализатор обеспечивает имя заполнителя по умолчанию для новой еды путем делегирования через к Food класс init(name: String) с a name значение [Unnamed]:

Второй класс в иерархии является подклассом Food вызванный RecipeIngredient. RecipeIngredient класс моделирует компонент в рецепте кулинарии. Это представляет Int свойство вызывают quantity (в дополнение к name свойство это наследовалось от Food) и определяет два инициализатора для создания RecipeIngredient экземпляры:

Число ниже шоу цепочка инициализатора для RecipeIngredient класс:

RecipeIngredient класс имеет единственный определяемый инициализатор, init(name: String, quantity: Int), который может использоваться для заполнения всех свойств нового RecipeIngredient экземпляр. Этот инициализатор запускается путем присвоения переданного quantity параметр quantity свойство, которое является единственным новым свойством, представленным RecipeIngredient. После выполнения так, инициализатор делегирует до init(name: String) инициализатор Food класс. Этот процесс удовлетворяет проверку безопасности 1 от Двухфазной Инициализации выше.

RecipeIngredient также определяет инициализатор удобства, init(name: String), который используется для создания a RecipeIngredient экземпляр по имени один. Этот инициализатор удобства принимает количество 1 для любого RecipeIngredient экземпляр, создающийся без явного количества. Определение этого инициализатора удобства делает RecipeIngredient экземпляры, более быстрые и более удобные для создания, и, избегают дублирования кода при создании нескольких единственных количеств RecipeIngredient экземпляры. Этот инициализатор удобства просто делегирует через к определяемому инициализатору класса, передающему в a quantity значение 1.

init(name: String) инициализатор удобства, предоставленный RecipeIngredient берет те же параметры в качестве init(name: String) определяемый инициализатор от Food. Поскольку этот инициализатор удобства переопределяет определяемый инициализатор от своего суперкласса, он должен быть отмечен с override модификатор (как описано в Наследовании Инициализатора и Переопределяющий).

Даже при том, что RecipeIngredient обеспечивает init(name: String) инициализатор как инициализатор удобства, RecipeIngredient тем не менее, обеспечил реализацию всех определяемых инициализаторов ее суперкласса. Поэтому RecipeIngredient автоматически наследовал все инициализаторы удобства его суперкласса также.

В этом примере, суперклассе для RecipeIngredient Food, который имеет единственный вызванный инициализатор удобства init(). Этот инициализатор поэтому наследован RecipeIngredient. Наследованная версия init() функции точно таким же образом как Food версия, за исключением того, что это делегирует к RecipeIngredient версия init(name: String) вместо Food версия.

Все три из этих инициализаторов могут использоваться для создания новый RecipeIngredient экземпляры:

Третий и заключительный класс в иерархии является подклассом RecipeIngredient вызванный ShoppingListItem. ShoppingListItem класс моделирует компонент рецепта, как это появляется в списке покупок.

Каждый элемент в списке покупок начинается, как «не куплено». Представлять этот факт, ShoppingListItem представляет вызванное булево свойство purchased, со значением по умолчанию false. ShoppingListItem также добавляет вычисленный description свойство, предоставляющее текстовое описание a ShoppingListItem экземпляр:

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

Число ниже шоу полная цепочка инициализатора для всех трех классов:

Можно использовать все три из наследованных инициализаторов для создания нового ShoppingListItem экземпляр:

Здесь, новый массив вызывают breakfastList создается из литерала массивов, содержащего три новых ShoppingListItem экземпляры. Тип массива выведен, чтобы быть [ShoppingListItem]. После того, как массив создается, имя ShoppingListItem в начале массива изменяется от "[Unnamed]" к "Orange juice" и это отмечено как купленный. Печать описания каждого элемента в массиве показывает, что их состояния по умолчанию были установлены как ожидалось.

Инициализаторы Failable для перечислений

Можно использовать failable инициализатор для выбора соответствующего элемента перечисления на основе одного или более параметров. Если предоставленные параметры не соответствуют соответствующему элементу перечисления, инициализатор может тогда перестать работать.

Пример ниже определяет вызванное перечисление TemperatureUnit, с тремя возможными состояниями (Kelvin, Celsius, и Fahrenheit). failable инициализатор используется для нахождения соответствующего элемента перечисления для a Character значение, представляющее температурный символ:

Если параметр не соответствует одно из этих состояний, можно использовать этот failable инициализатор, чтобы выбрать соответствующий элемент перечисления для трех возможных состояний и заставить инициализацию перестать работать:

Инициализаторы Failable для перечислений с необработанными значениями

Перечисления с необработанными значениями автоматически получают failable инициализатор, init?(rawValue:), это берет вызванный параметр rawValue из надлежащего типа необработанного значения и выбирает соответствующий элемент перечисления, если Вы найдены или инициировали отказ в инициализации, если не существует никакое совпадающее значение.

Можно переписать TemperatureUnit пример сверху для использования необработанных значений типа Character и использовать в своих интересах init?(rawValue:) инициализатор:

Инициализаторы Failable для классов

failable инициализатор для типа значения (т.е. структура или перечисление) может инициировать отказ в инициализации в любой точке в ее реализации инициализатора. В Animal пример структуры выше, инициализатор инициировал отказ в инициализации в, очень запускаются его реализации, перед species свойство было установлено.

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

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

Product класс, определенный выше, очень подобен Animal структура, замеченная ранее. Product класс имеет константу name свойство, которому нельзя позволить принять значение пустой строки. Осуществлять это требование, Product класс использует failable инициализатор, чтобы гарантировать, что значение свойства непусто прежде, чем позволить инициализации успешно выполняться.

Однако Product класс, не структура. Это означает это в отличие от этого Animal, любой failable инициализатор для Product класс должен обеспечить начальное значение для name свойство прежде, чем инициировать отказ в инициализации.

В примере выше, name свойство Product класс определяется как наличие неявно развернутого дополнительного строкового типа (String!). Поскольку это имеет дополнительный тип, это означает что name свойство имеет значение по умолчанию nil прежде чем это будет присвоено определенное значение во время инициализации. Это значение по умолчанию nil поочередно средние значения, что все свойства, представленные Product класс имеет допустимое начальное значение. В результате failable инициализатор для Product может инициировать отказ в инициализации в начале инициализатора, если он передается пустая строка, прежде, чем присвоить определенное значение name свойство в инициализаторе.

Поскольку name свойство является константой, можно быть уверены, что оно будет всегда содержать не -nil оцените, если успешно выполняется инициализация. Даже при том, что это определяется с помощью неявно развернутого дополнительного типа, можно всегда получать доступ к его неявно развернутому значению с уверенностью, не будучи должен проверить на значение nil:

Распространение отказа в инициализации

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

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

Пример ниже определяет подкласс Product вызванный CartItem. CartItem класс моделирует элемент в корзине онлайн-шоппинга. CartItem представляет сохраненное постоянное вызванное свойство quantity и гарантирует, что это свойство всегда имеет значение, по крайней мере, 1:

quantity свойство имеет неявно развернутый целый тип (Int!). Как с name свойство Product класс, это означает что quantity свойство имеет значение по умолчанию nil прежде чем это будет присвоено определенное значение во время инициализации.

failable инициализатор для CartItem запускается путем делегирования до init(name:) инициализатор от его суперкласса, Product. Это удовлетворяет требование, чтобы failable инициализатор всегда выполнял делегацию инициализатора прежде, чем инициировать отказ в инициализации.

Если инициализация суперкласса перестала работать из-за пустого name значение, весь процесс инициализации сразу перестал работать, и никакой дальнейший код инициализации не выполняется. Если инициализация суперкласса успешно выполняется, CartItem инициализатор проверяет это, он получил a quantity значение 1 или больше.

Если Вы создаете a CartItem экземпляр с непустым названием и количеством 1 или больше, инициализация успешно выполняется:

При попытке создать a CartItem экземпляр с a quantity значение 0, CartItem инициализатор заставляет инициализацию перестать работать:

Точно так же, при попытке создать a CartItem экземпляр с пустым name значение, суперкласс Product инициализатор заставляет инициализацию перестать работать:

Переопределение инициализатора Failable

Можно переопределить суперкласс failable инициализатор в подклассе, точно так же, как любой другой инициализатор. Также можно переопределить суперкласс failable инициализатор с подклассом non-failable инициализатор. Это позволяет Вам определить подкласс, для которого не может перестать работать инициализация, даже при том, что инициализации суперкласса позволяют перестать работать.

Обратите внимание на то, что при переопределении failable инициализатора суперкласса с nonfailable инициализатором подкласса инициализатор подкласса не может делегировать до инициализатора суперкласса. nonfailable инициализатор никогда не может делегировать к failable инициализатору.

Пример ниже определяет вызванный класс Document. Этот класс моделирует документ, который может быть инициализирован с a name свойство, которое является или значением непустой строки или nil, но не может быть пустая строка:

Следующий пример определяет подкласс Document вызванный AutomaticallyNamedDocument. AutomaticallyNamedDocument разделите на подклассы переопределяет оба из определяемых инициализаторов, представленных Document. Эти переопределения гарантируют что AutomaticallyNamedDocument экземпляр имеет начальную букву name значение "[Untitled]" если пустая строка передается, если экземпляр инициализируется без имени, или init(name:) инициализатор:

AutomaticallyNamedDocument переопределяет его failable суперкласс init?(name:) инициализатор с nonfailable init(name:) инициализатор. Поскольку AutomaticallyNamedDocument справляется со случаем пустой строки по-другому, чем его суперкласс, его инициализатор не должен перестать работать, и таким образом, он обеспечивает nonfailable версию инициализатора вместо этого.

init! Инициализатор Failable

Вы обычно определяете failable инициализатор, создающий дополнительный экземпляр надлежащего типа путем размещения вопросительного знака после init ключевое слово (init?). Также можно определить failable инициализатор, создающий неявно развернутый дополнительный экземпляр надлежащего типа. Сделайте это путем размещения восклицательного знака после init ключевое слово (init!) вместо вопросительного знака.

Можно делегировать от init? к init! и наоборот, и можно переопределить init? с init! и наоборот. Можно также делегировать от init к init!, несмотря на то, что выполнение так инициирует утверждение если init! инициализатор заставляет инициализацию перестать работать.