Авторские права Link to heading

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

5. В НИКАКОМ СЛУЧАЕ MINDVIEW LLC ИЛИ ЕГО ИЗДАТЕЛЬ НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПЕРЕД ЛЮБОЙ СТОРОНОЙ ПО ЛЮБОЙ ЮРИДИЧЕСКОЙ ТЕОРИИ ЗА ПРЯМЫЕ, КОСВЕННЫЕ, ОСОБЫЕ, СЛУЧАЙНЫЕ ИЛИ ПОСЛЕДУЮЩИЕ УБЫТКИ, ВКЛЮЧАЯ УПУЩЕННУЮ ПРИБЫЛЬ, ПРЕРВАНИЕ БИЗНЕСА, УБЫТКИ БИЗНЕС-ИНФОРМАЦИИ ИЛИ ЛЮБЫЕ ДРУГИЕ ДЕНЕЖНЫЕ УБЫТКИ, ИЛИ ЗА ЛИЧНЫЕ ТРАВМЫ, ВОЗНИКАЮЩИЕ В РЕЗУЛЬТАТЕ ИСПОЛЬЗОВАНИЯ ЭТОГО ИСТОЧНИКА КОДА И ЕГО ДОКУМЕНТАЦИИ, ИЛИ В РЕЗУЛЬТАТЕ НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАТЬ ЛЮБУЮ ПРОГРАММУ, ПОЛУЧЕННУЮ В РЕЗУЛЬТАТЕ, ДАЖЕ ЕСЛИ MINDVIEW LLC ИЛИ ЕГО ИЗДАТЕЛЬ БЫЛИ УВЕДОМЛЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ. MINDVIEW LLC ОТКАЗЫВАЕТСЯ ОТ ЛЮБЫХ ГАРАНТИЙ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, ПОДРАЗУМЕВАЕМЫМИ ГАРАНТИЯМИ ТОРГОВОЙ ПРИГОДНОСТИ И ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ. ИСТОЧНИК КОДА И ДОКУМЕНТАЦИЯ, ПРЕДОСТАВЛЕННЫЕ В НАСТОЯЩЕМ ДОКУМЕНТЕ, ПРЕДОСТАВЛЯЮТСЯ “КАК ЕСТЬ”, БЕЗ ЛЮБЫХ СООПРЕДЕЛЯЮЩИХ УСЛУГ ОТ MINDVIEW LLC, И MINDVIEW LLC НЕ ИМЕЕТ ОБЯЗАТЕЛЬСТВ ПО ПРЕДОСТАВЛЕНИЮ ОБСЛУЖИВАНИЯ, ПОДДЕРЖКИ, ОБНОВЛЕНИЙ, УЛУЧШЕНИЙ ИЛИ МОДИФИКАЦИЙ.

Обратите внимание, что MindView LLC поддерживает веб-сайт, который является единственной точкой распространения электронных копий Исходного кода, где он доступен бесплатно на условиях, указанных выше:
https://github.com/BruceEckel/AtomicKotlinExamples

Если вы думаете, что нашли ошибку в Исходном коде, пожалуйста, отправьте исправление по адресу:
https://github.com/BruceEckel/AtomicKotlinExamples/issues

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

AtomicKotlin (www.AtomicKotlin.com) от Bruce Eckel и Светланы Исаковой, ©2021 MindView LLC

Раздел I: Программирование Link to heading

Основы Link to heading

В программировании есть что-то удивительно притягательное — Винт Серф
Этот раздел предназначен для читателей, которые учатся программировать. Если вы опытный программист, переходите к Резюме 1 и Резюме 2.

Введение Link to heading

Эта книга предназначена как для новичков, так и для опытных программистов. Вы новичок, если у вас нет предварительных знаний в программировании, но “предназначена” потому, что мы даем вам достаточно информации, чтобы вы могли разобраться самостоятельно. Когда вы закончите, у вас будет прочная основа в программировании и в Kotlin. Если вы опытный программист, переходите к Резюме 1 и Резюме 2, а затем продолжайте оттуда. Часть названия книги “Атомные” относится к атомам как к наименьшим неделимым единицам. В этой книге мы стараемся вводить только одну концепцию за главу, поэтому главы не могут быть далее подразделены — таким образом, мы называем их атомами.

Концепции Link to heading

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

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

1. Маленькие шаги и небольшие победы. Мы сбрасываем тиранию главы. Вместо этого мы представляем каждый маленький шаг как атомарную концепцию или просто атом, который выглядит как маленькая глава. Мы стараемся представить только одну новую концепцию на атом. Типичный атом содержит один или несколько небольших, исполняемых фрагментов кода и вывод, который он производит.
2. Без ссылок вперед. Насколько это возможно, мы избегаем фраз вроде: “Эти функции объясняются в более позднем атоме.”
3. Без ссылок на другие языки программирования. Мы делаем это только когда это необходимо. Аналогия с функцией в языке, который вы не понимаете, не полезна.
4. Показывайте, а не рассказывайте. Вместо того чтобы устно описывать функцию, мы предпочитаем примеры и вывод. Лучше увидеть функцию в коде.
5. Практика перед теорией. Мы стараемся сначала показать механику языка, а затем объяснить, почему эти функции существуют. Это противоположно “традиционному” обучению, но часто кажется, что это работает лучше.

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

Где индекс? Link to heading

Эта книга написана в Markdown и издана с помощью Leanpub. К сожалению, ни Markdown, ни Leanpub не поддерживают индексы. Однако, создавая самые маленькие возможные главы (атомы), состоящие из одной темы в каждом атоме, оглавление выполняет функцию своего рода индекса. Кроме того, версии электронной книги позволяют осуществлять поиск по всему тексту.

Ссылки на другие разделы Link to heading

Ссылка на атом в книге выглядит так: Введение, что в данном случае относится к текущему атому. В различных форматах электронных книг это создает гиперссылку на этот атом.

Форматирование Link to heading

В этой книге: • Курсив вводит новый термин или концепцию, а иногда подчеркивает идею.
Atomic Kotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Введение 8
• Шрифт фиксированной ширины указывает на ключевые слова программы, идентификаторы и имена файлов.
Примеры кода также представлены в этом шрифте и окрашены в цвет в электронных версиях книги.
• В прозе мы следуем за именем функции пустыми скобками, как в func(). Это напоминает читателю, что он смотрит на функцию.
• Чтобы сделать электронную книгу удобной для чтения на всех устройствах и позволить пользователю увеличивать размер шрифта, мы ограничиваем ширину наших кодовых списков 47 символами. Иногда это требует компромисса, но мы считаем, что результаты того стоят. Для достижения этих ширин мы можем убрать пробелы, которые в противном случае могли бы быть включены во многие стили форматирования — в частности, мы используем отступы в два пробела вместо стандартных четырех пробелов.

“Пауза” Link to heading

Иногда вы будете видеть: • - Это указывает на паузу или своего рода небольшой сброс. В этой книге это часто встречается перед кратким резюме текущего подраздела, но там, где заголовок “Резюме” был бы избыточным. Некоторые книги используют подобный механизм, чтобы указать, что идея завершена, и мы начинаем что-то новое, но это все еще в рамках одной темы и недостаточно велико, чтобы оправдать подраздел или новый раздел. Markdown в Leanpub довольно ограничен, и использование одной или нескольких точек (моя первоначальная попытка) невозможно. Использование двух дефисов в markdown приводит к появлению точки и дефиса. Возможно, есть лучший способ сделать это, но я его не нашел, поэтому остановился на этом.

Пример книги Link to heading

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

Полная книга доступна для покупки как в печатном виде, так и в формате eBook. Если вам понравилось то, что мы сделали в бесплатном образце, пожалуйста, поддержите нас и помогите продолжить нашу работу над AtomicKotlin (www.AtomicKotlin.com) авторов Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC, оплатив то, что вы используете. Мы надеемся, что книга будет полезна, и мы ценим вашу поддержку.

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

Упражнения и решения Link to heading

Большинство атомов в Atomic Kotlin сопровождаются небольшим количеством упражнений. Чтобы улучшить ваше понимание, мы рекомендуем решать упражнения сразу после прочтения атома. Большинство упражнений проверяются автоматически с помощью интегрированной среды разработки (IDE) JetBrains IntelliJ IDEA, так что вы можете видеть свой прогресс и получать подсказки, если застрянете.

Вы можете найти следующие ссылки на http://AtomicKotlin.com/exercises/4. Чтобы решить упражнения, установите IntelliJ IDEA с плагином Edu Tools, следуя этим инструкциям:

1. Установите IntelliJ IDEA и плагин Edu Tools5.
2. Откройте курс Atomic Kotlin и решите упражнения6.

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

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

4 http://AtomicKotlin.com/exercises/
5 https://www.jetbrains.com/help/education/install-edutools-plugin.html
6 https://www.jetbrains.com/help/education/learner-start-guide.html?section=Atomic%20Kotlin
7 https://www.jetbrains.com/help/education/troubleshooting-guide.html

Atomic Kotlin (www.AtomicKotlin.com) Бруса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Введение 10

Если вы обнаружите ошибку в содержании курса (например, тест для задания выдает неправильный результат), пожалуйста, используйте наш трекер проблем, чтобы сообщить о проблеме с этой предзаполненной формой8. Обратите внимание, что вам нужно будет войти в YouTrack. Мы ценим ваше время, помогая улучшить курс!

Семинары Link to heading

Вы можете найти информацию о живых семинарах и других учебных инструментах на сайте AtomicKotlin.com.

Конференции Link to heading

Брюс организует конференции Open-Spaces, такие как Зимний Технический Форум. Присоединяйтесь к рассылке на AtomicKotlin.com, чтобы быть в курсе наших мероприятий и мест, где мы выступаем.

Поддержите нас Link to heading

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

О нас Link to heading

Брюс Эккель — автор многократно награждаемой книги Thinking in Java и Thinking in C++, а также ряда других книг по программированию, включая Atomic Kotlin (www.AtomicKotlin.com) в соавторстве с Светланой Исаковой, ©2021 MindView LLC, и Atomic Scala. Он провел сотни презентаций по всему миру и организует альтернативные конференции и мероприятия, такие как Winter Tech Forum и ретриты для разработчиков. Брюс имеет степень бакалавра в области прикладной физики и магистра в области компьютерной инженерии. Его блог доступен по адресу www.BruceEckel.com, а его консалтинговый, обучающий и конференционный бизнес называется Mindview LLC.

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

Благодарности Link to heading

• Команда по разработке языка Kotlin и contributors.
• Разработчики Leanpub, которые значительно упростили процесс публикации этой книги.
• Джеймс Уорд за конвертацию сборки Gradle в Kotlin и за его общую крутость.

Посвящения Link to heading

Моему любимому отцу, Э. Уэйну Эккелю. 1 апреля 1924 года — 23 ноября 2016 года. Вы первыми научили меня машинам, инструментам и дизайну.
Моему отцу, Сергею Львовичу Исакову, который ушел из жизни так рано и которого мы всегда будем помнить.

О обложке Link to heading

Дэниел Уилл-Харрис 14 разработал обложку на основе логотипа Kotlin.
10 http://www.atomicscala.com/
11 http://www.WinterTechForum.com
12 http://www.BruceEckel.com
13 https://www.mindviewllc.com/
14 http://www.will-harris.com
Atomic Kotlin (www.AtomicKotlin.com) от Брюса Эккела и Светланы Исаковой, ©2021 MindView LLC

Почему Kotlin? Link to heading

Программы должны быть написаны так, чтобы их могли читать люди, и лишь случайно — для выполнения машинами. — Гарольд Абельсон, соавтор книги “Структура и интерпретация компьютерных программ”.

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

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

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

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

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

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

Почему Kotlin?

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

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

Компиляторы и Интерпретаторы Link to heading

Инструкции интерпретируемого языка выполняются непосредственно программой, называемой интерпретатором. Kotlin компилируется, а не интерпретируется. Исходный код компилируемого языка преобразуется в другое представление, которое выполняется как собственная программа, либо непосредственно на аппаратном процессоре, либо на виртуальной машине, которая эмулирует процессор:
AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 14
Языки, такие как C, C++, Go и Rust, компилируются в машинный код, который выполняется непосредственно на базовом аппаратном центральном процессоре (ЦП). Языки, такие как Java и Kotlin, компилируются в байт-код, который является промежуточным уровнем формата, который не выполняется непосредственно на аппаратном ЦП, а вместо этого на виртуальной машине, которая является программой, выполняющей инструкции байт-кода. Программы, созданные с помощью версии Kotlin для JVM, выполняются на Java Virtual Machine (JVM).

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

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

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

Языки, оказавшие влияние на Kotlin Link to heading

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

FORTRAN: FORmula TRANslation (1957) Link to heading

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

LISP: LISt Processor (1958) Link to heading

Вместо того чтобы быть специфичным для приложений, LISP воплотил в себе основные концепции программирования; это был язык компьютерных ученых и первый язык функционального программирования (вы узнаете о функциональном программировании в этой книге). Компромиссом за его мощь и гибкость была эффективность: LISP обычно был слишком дорог для работы на ранних машинах, и только в последние десятилетия машины стали достаточно быстрыми, чтобы возродить использование LISP. Например, редактор GNU Emacs полностью написан на LISP и может быть расширен с помощью LISP.

ALGOL: ALGOrithmic Language (1958) Link to heading

Можно с уверенностью сказать, что это самый влиятельный язык 1950-х годов, так как он ввел синтаксис, который сохранился во многих последующих языках. Например, C и его производные являются “языками, подобными ALGOL”.

COBOL: Общий язык, ориентированный на бизнес (1959) Link to heading

Разработан для обработки бизнес-, финансовых и административных данных. Он имеет синтаксис, похожий на английский, и был предназначен для самодокументирования и высокой читаемости. Хотя эта цель в целом не была достигнута — COBOL известен ошибками, вызванными неправильно поставленной точкой — Министерство обороны США заставило широко внедрить его на мейнфреймах, и системы по-прежнему работают (и требуют обслуживания) сегодня.

BASIC: Универсальный Символический Язык Инструкций для Начинающих Link to heading

Код (1964) Link to heading

BASIC был одной из ранних попыток сделать программирование доступным. Хотя он имел большой успех, его возможности и синтаксис были ограничены, поэтому он был лишь частично полезен для людей, которым нужно было изучать более сложные языки. Это в основном интерпретируемый язык, что означает, что для его выполнения вам нужен оригинальный код программы. Несмотря на это, многие полезные программы были написаны на BASIC, в частности, как AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC.
Почему Kotlin? 16
как скриптовый язык для продуктов “Office” от Microsoft. BASIC можно даже считать первым “открытым” языком программирования, так как люди создавали множество его вариаций.

Simula 67, оригинальный объектно-ориентированный язык Link to heading

(1967) Link to heading

Симуляция обычно включает в себя множество «объектов», взаимодействующих друг с другом. Разные объекты имеют разные характеристики и поведения. Языки, существовавшие в то время, были неудобны для использования в симуляциях, поэтому был разработан язык Simula (еще один «язык, похожий на ALGOL»), чтобы обеспечить прямую поддержку для создания симуляционных объектов. Оказалось, что эти идеи также полезны для общего программирования, и это стало началом языков, ориентированных на объекты (ОО).

Pascal (1970) Link to heading

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

Реализация Pascal, Turbo Pascal от Borland, изначально работала на машинах CP/M, а затем перешла на ранние MS-DOS (предшественник Windows), позже эволюционировав в язык Delphi для Windows. Помещая все в память, Turbo Pascal компилировал с молниеносной скоростью на очень слабых машинах, значительно улучшая опыт программирования. Его создатель, Андерс Хейлсберг, позже разработал как C#, так и TypeScript.

Никлаус Вирт, изобретатель Pascal, создал последующие языки: Modula, Modula-2 и Oberon. Как следует из названия, Modula сосредоточилась на разделении программ на модули для лучшей организации и более быстрой компиляции. Большинство современных языков поддерживают отдельную компиляцию и какую-то форму модульной системы.

Atomic Kotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 17

C (1972) Link to heading

Несмотря на растущее количество языков более высокого уровня, программисты все еще писали на ассемблере. Это часто называют системным программированием, поскольку оно выполняется на уровне операционной системы, но также включает в себя встроенное программирование для специализированных физических устройств. Это не только трудоемко и дорого (Брюс начал свою карьеру, пиша на ассемблере для встроенных систем), но и не переносимо — ассемблерный код может выполняться только на процессоре, для которого он написан. C был разработан как «язык высокого уровня, близкий к ассемблеру», который все же достаточно близок к аппаратному обеспечению, чтобы вам редко приходилось писать на ассемблере. Более того, программа на C может выполняться на любом процессоре с компилятором C. C отделил программу от процессора, что решило огромную и дорогостоящую проблему. В результате бывшие программисты на ассемблере стали значительно более продуктивными на C. C оказался настолько эффективным, что современные языки (в частности, Go и Rust) все еще пытаются его вытеснить в области системного программирования.

Smalltalk (1972) Link to heading

Созданный с самого начала как чисто объектно-ориентированный, Smalltalk значительно продвинул теорию объектно-ориентированного программирования и языков, став платформой для экспериментов и демонстрации быстрого развития приложений. Однако он был создан в то время, когда языки все еще были собственническими, и стоимость системы Smalltalk могла достигать тысяч долларов. Он был интерпретируемым, поэтому для запуска программ требовалась среда Smalltalk. Реализации Smalltalk с открытым исходным кодом не появились до того, как мир программирования продвинулся дальше. Программисты Smalltalk внесли значительный вклад в понимание, которое принесло пользу более поздним объектно-ориентированным языкам, таким как C++ и Java.

C++: Лучший C с объектами (1983) Link to heading

Бьёрн Страуструп создал C++, потому что хотел улучшить C и добавить поддержку объектно-ориентированных конструкций, с которыми он столкнулся, используя Simula-67. Брюс был членом Комитета по стандартам C++ в течение первых восьми лет и написал три книги по C++, включая “Мысли на C++”.

Обратная совместимость с C была основополагающим принципом дизайна C++, поэтому код на C может компилироваться в C++ практически без изменений. Это обеспечивало легкий путь миграции — программисты могли продолжать писать на C, получать преимущества C++ и постепенно экспериментировать с его возможностями, оставаясь при этом продуктивными. Большинство критики C++ можно отследить до ограничения обратной совместимости с C.

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

Python: Дружелюбный и Гибкий (1990) Link to heading

Дизайнер Python, Гвидо ван Россум, создал язык, основываясь на своем вдохновении “программирования для всех”. Его забота о сообществе Python сделала его известным как самое дружелюбное и поддерживающее сообщество в мире программирования. Python был одним из первых языков с открытым исходным кодом, что привело к его реализации практически на каждой платформе, включая встроенные системы и машинное обучение. Его динамичность и простота в использовании делают его идеальным для автоматизации небольших, повторяющихся задач, но его возможности также поддерживают создание больших, сложных программ. Python — это настоящий “язык с низов”; у него никогда не было компании, продвигающей его, а отношение его поклонников заключалось в том, чтобы никогда не навязывать язык, а просто помогать всем, кто хочет его изучить. Язык продолжает постоянно улучшаться, и в последние годы его популярность стремительно возросла.

Python, возможно, был первым мейнстримным языком, который объединил функциональное и объектно-ориентированное программирование. Он предшествовал Java с автоматическим управлением памятью с использованием сборки мусора (вам обычно не нужно самостоятельно выделять или освобождать память) и возможностью запускать программы на нескольких платформах.

Haskell: Чистое функциональное программирование (1990) Link to heading

Вдохновленный Miranda (1985), проприетарным языком, Haskell был создан как открытый стандарт для исследований в области чистого функционального программирования, хотя он также использовался для продуктов. Синтаксис и идеи из Haskell оказали влияние на ряд последующих языков, включая Kotlin.
AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 19

Java: Виртуальные машины и сборка мусора (1995) Link to heading

Джеймс Гослинг и его команда получили задачу написать код для телевизионной приставки. Они решили, что им не нравится C++, и вместо создания приставки создали язык Java. Компания Sun Microsystems сделала огромный маркетинговый рывок в поддержку этого бесплатного языка (что на тот момент было новой идеей), чтобы попытаться доминировать на развивающемся интернет-ландшафте.

Это воспринимаемое окно возможностей для доминирования в Интернете оказало большое давление на дизайн языка Java, что привело к значительному количеству недостатков (книга “Thinking in Java” освещает эти недостатки, чтобы читатели были готовы с ними справляться). Брайан Гоетц из Oracle, текущий ведущий разработчик Java, сделал замечательные и удивительные улучшения в Java, несмотря на унаследованные ограничения. Хотя Java была невероятно успешной, важной целью дизайна Kotlin является исправление недостатков Java, чтобы программисты могли быть более продуктивными.

Успех Java был обусловлен двумя инновационными функциями: виртуальной машиной и сборкой мусора. Эти функции были доступны в других языках — например, LISP, Smalltalk и Python имеют сборку мусора, а UCSD Pascal работал на виртуальной машине — но никогда не считались практичными для мейнстримовых языков. Java изменила это, и, делая это, сделала программистов значительно более продуктивными.

Виртуальная машина является промежуточным слоем между языком и аппаратным обеспечением. Языку не нужно генерировать машинный код для конкретного процессора; ему нужно только генерировать промежуточный язык (байт-код), который работает на виртуальной машине. Виртуальные машины требуют вычислительной мощности и, до появления Java, считались непрактичными. Java Virtual Machine (JVM) дала начало слогану Java “напиши один раз, запускай везде”. Кроме того, другие языки могут быть более легко разработаны с нацеливанием на JVM; примеры включают Groovy, язык сценариев, похожий на Java, и Clojure, версию LISP.

Сборка мусора решает проблему забывания о высвобождении памяти или когда трудно понять, когда участок памяти больше не используется. Проекты значительно задерживались или даже отменялись из-за утечек памяти. Хотя сборка мусора присутствует в некоторых предыдущих языках, считалось, что она создает неприемлемое количество накладных расходов, пока Java не продемонстрировала ее практичность.

AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 20

JavaScript: Java только в названии (1995) Link to heading

Оригинальный веб-браузер просто копировал и отображал страницы с веб-сервера. Веб-браузеры начали proliferировать, становясь новой программной платформой, которая нуждалась в поддержке языка. Java хотела стать этим языком, но была слишком неудобной для этой задачи. JavaScript начинался как LiveScript и был встроен в NetScape Navigator, один из первых веб-браузеров. Переименование его в JavaScript было маркетинговым ходом от NetScape, так как язык имел лишь смутное сходство с Java.

С ростом популярности веба JavaScript стал чрезвычайно важным. Однако поведение JavaScript было настолько непредсказуемым, что Дуглас Крокфорд написал книгу с ироничным названием “JavaScript: Хорошие части”, в которой он продемонстрировал все проблемы языка, чтобы программисты могли их избежать. Последующие улучшения, внесенные комитетом ECMAScript, сделали JavaScript неузнаваемым для оригинального программиста JavaScript. Теперь его считают стабильным и зрелым языком.

WebAssembly (WASM) был разработан из JavaScript как своего рода байт-код для веб-браузеров. Он часто работает гораздо быстрее, чем JavaScript, и может быть сгенерирован другими языками. На момент написания команда Kotlin работает над добавлением WASM в качестве целевой платформы.

C#: Java для .NET (2000) Link to heading

C# был разработан для предоставления некоторых важных возможностей Java на платформе .NET (Windows), при этом освобождая разработчиков от необходимости следовать языку Java. Результатом стали многочисленные улучшения по сравнению с Java. Например, C# разработал концепцию расширяющих функций, которые активно используются в Kotlin. C# также стал значительно более функциональным, чем Java. Многие функции C# явно повлияли на дизайн Kotlin.

Scala: SCALAble (2003) Link to heading

Мартин Одерски создал Scala для работы на виртуальной машине Java: чтобы использовать уже проделанную работу над JVM, взаимодействовать с Java-программами и, возможно, с идеей о том, что она может вытеснить Java. Как исследователь, Одерски и его команда использовали Scala как платформу для экспериментов с языковыми особенностями, особенно с теми, которые не были включены в Java.
AtomicKotlin (www.AtomicKotlin.com) Бруса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 21
Эти эксперименты были познавательными, и ряд из них нашел свое отражение в Kotlin, обычно в модифицированной форме. Например, возможность переопределять операторы, такие как +, для использования в специальных случаях называется перегрузкой операторов. Это было включено в C++, но не в Java. Scala добавила перегрузку операторов, но также позволяет изобретать новые операторы, комбинируя любые последовательности символов. Это часто приводит к запутанному коду. Ограниченная форма перегрузки операторов включена в Kotlin, но вы можете перегружать только те операторы, которые уже существуют.
Scala также является объектно-функциональным гибридом, как Python, но с акцентом на чистые функции и строгие объекты. Это вдохновило выбор Kotlin также быть объектно-функциональным гибридом.
Как и Scala, Kotlin работает на JVM, но взаимодействует с Java гораздо проще, чем Scala (см. Приложение B). Кроме того, Kotlin нацелен на JavaScript, операционную систему Android и генерирует нативный код для других платформ.
AtomicKotlin развился из идей и материалов в AtomicScala15.

Groovy: Динамический язык JVM (2007) Link to heading

Динамические языки привлекательны, потому что они более интерактивны и лаконичны, чем статические языки. Было сделано множество попыток создать более динамичный опыт программирования на JVM, включая Jython (Python) и Clojure (диалект Lisp). Groovy стал первым, кто достиг широкого признания.

На первый взгляд, Groovy кажется упрощенной версией Java, обеспечивая более приятный опыт программирования. Большинство Java-кода будет работать без изменений в Groovy, поэтому программисты на Java могут быстро стать продуктивными, а затем изучить более сложные функции, которые обеспечивают заметные улучшения в программировании по сравнению с Java.

Операторы Kotlin ?. и ?:, которые решают проблему пустоты, впервые появились в Groovy.

Существует множество функций Groovy, которые можно узнать в Kotlin. Некоторые из этих функций также встречаются в других языках, что, вероятно, способствовало их включению в Kotlin.
15 http://www.AtomicScala.com
AtomicKotlin (www.AtomicKotlin.com) Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 22

Почему Kotlin? (Введён в 2011 году, Версия 1.0: Link to heading

2016) Link to heading

Точно так же, как C++ изначально задумывался как “лучший C”, Kotlin изначально был ориентирован на то, чтобы стать “лучшим Java”. С тех пор он значительно вышел за рамки этой цели. Kotlin прагматично выбирает только самые успешные и полезные функции из других языков программирования — после того, как эти функции были протестированы в реальных условиях и доказали свою ценность.

Таким образом, если вы приходите из другого языка, вы можете узнать некоторые функции этого языка в Kotlin. Это сделано намеренно: Kotlin максимизирует продуктивность, используя проверенные концепции.

Читаемость Link to heading

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

Инструменты Link to heading

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

Мультипарадигменный Link to heading

Kotlin поддерживает несколько парадигм программирования, которые мягко вводятся в этой книге: • Императивное программирование • Функциональное программирование • Объектно-ориентированное программирование
AtomicKotlin (www.AtomicKotlin.com) Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 23

Мультиплатформенность Link to heading

Исходный код на Kotlin может быть скомпилирован для различных целевых платформ: • JVM. Исходный код компилируется в байт-код JVM (файлы .class), который затем может быть выполнен на любой Java Virtual Machine (JVM). • Android. У Android есть собственная среда выполнения, называемая ART (предшественник назывался Dalvik). Исходный код Kotlin компилируется в формат Dalvik Executable (файлы .dex). • JavaScript, для выполнения в веб-браузере. • Нативные бинарные файлы путем генерации машинного кода для конкретных платформ и ЦПУ.

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

Две особенности Kotlin Link to heading

Этот атом не предполагает, что вы программист, что затрудняет объяснение большинства преимуществ Kotlin по сравнению с альтернативами. Тем не менее, есть две темы, которые имеют большое значение и могут быть объяснены на этом раннем этапе: совместимость с Java и вопрос указания «отсутствия значения».

Легкая совместимость с Java Link to heading

Чтобы стать «лучшей C», C++ должен быть обратно совместим с синтаксисом C, но Kotlin не обязан быть обратно совместим с синтаксисом Java — ему нужно просто работать с JVM. Это освобождает дизайнеров Kotlin для создания гораздо более чистого и мощного синтаксиса, без визуального шума и усложнений, которые загромождают Java.

Чтобы Kotlin стал «лучшей Java», опыт его использования должен быть приятным и без трений, поэтому Kotlin обеспечивает легкую интеграцию с существующими Java-проектами. Вы можете написать небольшой фрагмент функциональности на Kotlin и вставить его среди вашего существующего Java-кода. Java-код даже не знает, что Kotlin-код там присутствует — он просто выглядит как еще один Java-код.

Компании часто исследуют новый язык, создавая отдельную программу на этом языке. В идеале эта программа должна быть полезной, но не критически важной, чтобы в случае неудачи проекта его можно было завершить с минимальными потерями. Не каждая компания хочет тратить ресурсы на такого рода эксперименты. Поскольку Kotlin бесшовно интегрируется в существующую Java-систему (и получает выгоду от тестов этой системы), его становится очень дешево, а иногда и бесплатно, попробовать, чтобы увидеть, подходит ли он.

Кроме того, JetBrains, компания, создающая Kotlin, предоставляет IntelliJ IDEA в «Community» (бесплатной) версии, которая включает поддержку как Java, так и Kotlin, а также возможность легко интегрировать их. У него даже есть инструмент, который берет Java-код и (в основном) переписывает его на Kotlin.

Приложение B охватывает совместимость с Java.

Представление пустоты Link to heading

Особенно полезной особенностью Kotlin является его решение сложной проблемы программирования.
Что вы делаете, когда кто-то передает вам словарь и просит найти слово, которого не существует? Вы можете гарантировать результаты, придумав определения для неизвестных слов. Более полезный подход — просто сказать: «Для этого слова нет определения». Это демонстрирует значительную проблему в программировании: как указать «нет значения» для участка памяти, который не инициализирован, или для результата операции?
Ссылка null была изобретена в 1965 году для ALGOL Тони Хоаром, который позже назвал это «моей миллиардной ошибкой». Одна из проблем заключалась в том, что это было слишком просто — иногда сказать, что комната пуста, недостаточно. Вам может понадобиться знать, например, почему она пуста. Это приводит ко второй проблеме: реализации. Ради эффективности это обычно было просто специальное значение, которое могло поместиться в небольшом объеме памяти, и что может быть лучше, чем память, уже выделенная для этой информации?
Исходный язык C не инициализировал память автоматически, что вызывало множество проблем. C++ улучшил ситуацию, устанавливая вновь выделенную память в нули. Таким образом, если числовое значение не инициализировано, оно просто является числовым нулем.
Atomic Kotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Почему Kotlin? 25
Это не казалось таким уж плохим, но это позволяло неинициализированным значениям тихо ускользать из-под контроля (новые компиляторы C и C++ часто предупреждают вас об этом). Хуже того, если участок памяти был указателем — используемым для указания («указывать на») другой участок памяти — нулевой указатель указывал бы на нулевую позицию в памяти, что почти наверняка не то, что вам нужно.
Java предотвращает доступ к неинициализированным значениям, сообщая о таких ошибках во время выполнения. Хотя это и обнаруживает неинициализированные значения, это не решает проблему, потому что единственный способ проверить, что ваша программа не упадет, — это запустить ее. В коде Java существует множество таких ошибок, и программисты тратят огромное количество времени на их поиск.
Kotlin решает эту проблему, предотвращая операции, которые могут вызвать ошибки null на этапе компиляции, до того как программа сможет запуститься. Это самая отмечаемая особенность программистов Java, переходящих на Kotlin. Эта одна функция может минимизировать или устранить ошибки null в Java, сэкономив вашему проекту значительное количество времени и денег.

Изобилие преимуществ Link to heading

Две функции, которые мы смогли объяснить здесь (без необходимости в дополнительных знаниях программирования), существенно влияют на то, являетесь ли вы программистом на Java или нет. Если Kotlin — ваш первый язык, и вы попадаете в проект, который требует больше программистов, гораздо проще привлечь одного из многих существующих программистов на Java к работе с Kotlin.

У Kotlin есть много других преимуществ, которые мы не можем объяснить, пока вы не узнаете больше о программировании. Для этого и предназначена остальная часть книги.
• -
Языки часто выбираются по увлечению, а не по разуму… Я пытаюсь сделать так, чтобы Kotlin был языком, который любят по причине. — Андрей Бреслав, ведущий дизайнер языка Kotlin.
Atomic Kotlin (www.AtomicKotlin.com) Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Привет, мир! Link to heading

“Привет, мир!” — это программа, которая обычно используется для демонстрации базового синтаксиса языков программирования. Мы разрабатываем эту программу в несколько этапов, чтобы вы поняли ее части.

Сначала давайте рассмотрим пустую программу, которая ничего не делает: // HelloWorld/EmptyProgram.kt fun main() { // Код программы здесь … }

Пример начинается с комментария, который является пояснительным текстом и игнорируется Kotlin. // (двойной косой слэш) начинает комментарий, который продолжается до конца текущей строки: // Однострочный комментарий

Kotlin игнорирует // и все, что после него, до конца строки. На следующей строке он снова начинает обращать внимание. Первая строка каждого примера в этой книге — это комментарий, начинающийся с названия подкаталога, содержащего файл исходного кода (в данном случае HelloWorld), за которым следует имя файла: EmptyProgram.kt. Пример подкаталога для каждого атома соответствует имени этого атома.

Ключевые слова зарезервированы языком и имеют специальное значение. Ключевое слово fun является сокращением от function. Функция — это коллекция кода, которую можно выполнить, используя имя этой функции (мы уделяем много времени функциям на протяжении всей книги). Имя функции следует за ключевым словом fun, так что в данном случае это main() (в тексте мы следуем за именем функции с помощью скобок).

main() на самом деле является специальным именем для функции; оно указывает на “точку входа” для программы на Kotlin. Программа на Kotlin может иметь много функций с разными именами, но main() — это та, которая автоматически вызывается при выполнении программы.

Список параметров следует за именем функции и заключен в скобки. Здесь мы не передаем ничего в main(), поэтому список параметров пуст.

Тело функции появляется после списка параметров. Оно начинается с открывающей фигурной скобки ({) и заканчивается закрывающей фигурной скобкой (}). Тело функции содержит операторы и выражения. Оператор производит эффект, а выражение дает результат.

EmptyProgram.kt не содержит операторов или выражений в теле, только комментарий.

Давайте сделаем так, чтобы программа выводила “Привет, мир!”, добавив строку в тело main(): // HelloWorld/HelloWorld.kt fun main() { println(“Привет, мир!”) } /* Вывод: Привет, мир! */

Строка, которая выводит приветствие, начинается с println(). Как и main(), println() — это функция. Эта строка вызывает функцию, которая выполняет свое тело. Вы указываете имя функции, за которым следуют скобки, содержащие один или несколько параметров. В этой книге, когда мы ссылаемся на функцию в тексте, мы добавляем скобки после имени в качестве напоминания о том, что это функция. Здесь мы говорим println().

println() принимает один параметр, который является строкой. Вы определяете строку, помещая символы в кавычки.

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

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

Для некоторых примеров в книге мы показываем вывод в конце списка, внутри многострочного комментария. Многострочный комментарий начинается с /* (косая черта, за которой следует звездочка) и продолжается — включая переносы строк (которые мы называем новыми строками) — до тех пор, пока / (звездочка, за которой следует косая черта) не завершит комментарий: / Многострочный комментарий Не заботится о новых строках */

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

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

Упражнения и решения можно найти на www.AtomicKotlin.com.

var & val Link to heading

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

• var, сокращение от variable, что означает, что вы можете переназначить его содержимое.
• val, сокращение от value, что означает, что вы можете только инициализировать его; вы не можете переназначить его.

Вы определяете var следующим образом: var идентификатор = инициализация

Ключевое слово var следует за идентификатором, знаком равенства и затем значением инициализации. Идентификатор начинается с буквы или символа подчеркивания, за которым следуют буквы, цифры и символы подчеркивания. Регистр имеет значение (то есть thisValue и thisvalue — это разные идентификаторы).

Вот несколько определений var: // VarAndVal/Vars.kt fun main() { var whole = 11 // [1] var fractional = 1.4 // [2] var words = “Twas Brillig” // [3] println(whole) println(fractional) println(words) } /* Вывод: 11 1.4 Twas Brillig */

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

• [1] Создайте var с именем whole и сохраните в нем 11.
• [2] Сохраните “дробное число” 1.4 в var fractional.
• [3] Сохраните некоторый текст (строку) в var words.

Обратите внимание, что println() может принимать любое одно значение в качестве аргумента. Как подразумевает название variable, var может изменяться. То есть вы можете изменить данные, хранящиеся в var. Мы говорим, что var изменяемый (mutable):

// VarAndVal/AVarIsMutable.kt fun main() { var sum = 1 sum = sum + 2 sum += 3 println(sum) } /* Вывод: 6 */

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

Изменение значения, хранящегося в var, — это полезный способ выразить изменения. Однако, когда сложность программы увеличивается, ваш код становится более понятным, безопасным и легким для понимания, если значения, представленные вашими идентификаторами, не могут изменяться — то есть они не могут быть переназначены. Мы указываем неизменяемый идентификатор, используя ключевое слово val вместо var. val может быть назначен только один раз, когда он создается: val идентификатор = инициализация

Ключевое слово val происходит от value, указывая на что-то, что не может изменяться — оно неизменяемо (immutable). Выбирайте val вместо var всякий раз, когда это возможно. Пример из Vars.kt в начале этого атома можно переписать, используя val:

// VarAndVal/Vals.kt fun main() { val whole = 11 // whole = 15 // Ошибка // [1] val fractional = 1.4 val words = “Twas Brillig” println(whole) println(fractional) println(words) } /* Вывод: 11 1.4 Twas Brillig */

• [1] Как только вы инициализируете val, вы не можете его переназначить. Если мы попытаемся переназначить whole на другое число, Kotlin выдаст ошибку, сказав: “Val cannot be reassigned.”

Выбор описательных имен для ваших идентификаторов делает ваш код более понятным и часто уменьшает необходимость в комментариях. В Vals.kt вы не имеете представления о том, что представляет собой whole. Если ваша программа хранит число 11, чтобы обозначить время дня, когда вы получаете кофе, будет более очевидно для других, если вы назовете его coffeetime, и легче читать, если это coffeeTime (согласно стилю Kotlin, мы делаем первую букву строчной).

var полезны, когда данные должны изменяться во время выполнения программы. Это звучит как общая необходимость, но на практике оказывается, что это можно избежать. В общем, ваши программы легче расширять и поддерживать, если вы используете val. Однако в редких случаях слишком сложно решить проблему, используя только val. По этой причине Kotlin предоставляет вам гибкость var. Однако, проводя больше времени с val, вы обнаружите, что вам почти никогда не нужны var, и что ваши программы более безопасны и надежны без них.

Упражнения и решения можно найти на www.AtomicKotlin.com.

Типы данных Link to heading

Данные могут иметь разные типы. Чтобы решить математическую задачу, вы пишете выражение: 5.9 + 6
Вы знаете, что сложение этих чисел дает другое число. Kotlin тоже это знает. Вы знаете, что одно из них — это дробное число (5.9), которое Kotlin называет Double, а другое — целое число (6), которое Kotlin называет Int. Вы знаете, что результат — это дробное число.
Тип (также называемый типом данных) говорит Kotlin, как вы намерены использовать эти данные. Тип определяет множество значений, которые выражение этого типа может производить. Тип также определяет операции, которые могут быть выполнены над данными, значение данных и то, как значения этого типа могут быть сохранены.
Kotlin использует типы, чтобы проверить, что ваши выражения корректны. В приведенном выше выражении Kotlin создает новое значение типа Double для хранения результата.
Kotlin старается адаптироваться к вашим потребностям. Если вы попросите его сделать что-то, что нарушает правила типов, он выдаст сообщение об ошибке. Например, попробуйте сложить строку и число: // DataTypes/StringPlusNumber.kt fun main() {
println(“Sally” + 5.9)
}
/* Вывод:
Sally5.9
*/
Типы говорят Kotlin, как правильно их использовать. В этом случае правила типов говорят Kotlin, как сложить число и строку: путем объединения двух значений и создания строки для хранения результата.
Теперь попробуйте умножить строку и Double, изменив + в StringPlusNumber.kt на :
DataTypes 33
“Sally” * 5.9
Комбинирование типов таким образом не имеет смысла для Kotlin, поэтому он выдает вам ошибку.
В var и val мы хранили несколько типов. Kotlin сам определил типы для нас, исходя из того, как мы их использовали. Это называется выводом типа.
Мы можем быть более подробными и указать тип:
val идентификатор: Тип = инициализация
Вы начинаете с ключевого слова val или var, за которым следует идентификатор, двоеточие, тип, знак = и значение инициализации. Таким образом, вместо того чтобы говорить:
val n = 1
var p = 1.2
Вы можете сказать:
val n: Int = 1
var p: Double = 1.2
Мы сказали Kotlin, что n — это Int, а p — это Double, вместо того чтобы позволить ему вывести тип.
Вот некоторые из базовых типов Kotlin:
// DataTypes/Types.kt
fun main() {
val whole: Int = 11 // [1]
val fractional: Double = 1.4 // [2]
val trueOrFalse: Boolean = true // [3]
val words: String = “A value” // [4]
val character: Char = ‘z’ // [5]
val lines: String = “““Тройные кавычки позволяют
вам иметь много строк
в вашей строке””” // [6]
println(whole)
println(fractional)
println(trueOrFalse)
println(words)
println(character)
AtomicKotlin(www.AtomicKotlin.com)byBruceEckel&SvetlanaIsakova,©2021MindViewLLC
DataTypes 34
println(lines)
}
/ Вывод:
11
1.4
true
A value
z
Тройные кавычки позволяют
вам иметь много строк
в вашей строке
/
• [1] Тип данных Int — это целое число, что означает, что он хранит только целые числа.
• [2] Для хранения дробных чисел используйте Double.
• [3] Тип данных Boolean хранит только два специальных значения: true и false.
• [4] Строка хранит последовательность символов. Вы присваиваете значение, используя строку в двойных кавычках.
• [5] Char хранит один символ.
• [6] Если у вас много строк и/или специальных символов, окружите их тройными двойными кавычками (это строка с тройными кавычками).
Kotlin использует вывод типа, чтобы определить значение смешанных типов. Например, при сложении Int и Double Kotlin решает тип для результирующего значения:
// DataTypes/Inference.kt
fun main() {
val n = 1 + 1.2
println(n)
}
/ Вывод:
2.2
*/
Когда вы добавляете Int к Double, используя вывод типа, Kotlin определяет, что результат n — это Double, и гарантирует, что он соблюдает все правила для Double.
Вывод типа в Kotlin является частью его стратегии по выполнению работы для программиста. Если вы пропустите объявление типа, Kotlin обычно может его вывести.
Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin(www.AtomicKotlin.com)byBruceEckel&SvetlanaIsakova,©2021MindViewLLC

Функции Link to heading

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

**fun** functionName(p1: Type1, p2: Type2, ...): ReturnType {
    lines of code
    **return** result
}

p1 и p2 — это параметры: информация, которую вы передаете в функцию. Каждый параметр имеет имя идентификатора (p1, p2), за которым следует двоеточие и тип этого параметра. Закрывающая скобка списка параметров сопровождается двоеточием и типом результата, который возвращает функция. Строки кода в теле функции заключены в фигурные скобки. Выражение, следующее за ключевым словом return, — это результат, который функция производит по завершении.

Параметр — это то, как вы определяете, что передается в функцию — это заполнитель. Аргумент — это фактическое значение, которое вы передаете в функцию.

Сочетание имени, параметров и типа возвращаемого значения называется сигнатурой функции. Вот простая функция под названием multiplyByTwo():

// Functions/MultiplyByTwo.kt
**fun** multiplyByTwo(x: **Int** ): **Int** { // [1]
    println("Inside multiplyByTwo") // [2]
    **return** x * 2
}
**fun** main() {
    **val** r = multiplyByTwo(5) // [3]
    println(r)
}
/* Вывод:
Inside multiplyByTwo
10
*/

• [1] Обратите внимание на ключевое слово fun, имя функции и список параметров, состоящий из одного параметра. Эта функция принимает параметр типа Int и возвращает Int.
• [2] Эти две строки — это тело функции. Последняя строка возвращает значение своего вычисления x * 2 как результат функции.
• [3] Эта строка вызывает функцию с соответствующим аргументом и сохраняет результат в val r. Вызов функции имитирует форму ее объявления: имя функции, за которым следуют аргументы в круглых скобках.

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

println() также является вызовом функции — она просто предоставляется Kotlin. Мы называем функции, определенные в Kotlin, библиотечными функциями. Если функция не возвращает значимого результата, ее тип возвращаемого значения — Unit. Вы можете явно указать Unit, если хотите, но Kotlin позволяет вам опустить его:

// Functions/SayHello.kt
**fun** sayHello() {
    println("Hallo!")
}
**fun** sayGoodbye(): **Unit** {
    println("Auf Wiedersehen!")
}
**fun** main() {
    sayHello()
    sayGoodbye()
}
/* Вывод:
Hallo!
Auf Wiedersehen!
*/

Обе функции sayHello() и sayGoodbye() возвращают Unit, но sayHello() опускает явное объявление. Функция main() также возвращает Unit.

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

**fun** functionName(arg1: Type1, arg2: Type2, ...): ReturnType = expression

Тело функции, окруженное фигурными скобками, называется блочным телом. Тело функции, использующее синтаксис с равенством, называется телом выражения. Здесь multiplyByThree() использует тело выражения:

// Functions/MultiplyByThree.kt
**fun** multiplyByThree(x: **Int** ): **Int** = x * 3
**fun** main() {
    println(multiplyByThree(5))
}
/* Вывод:
15
*/

Это короткая версия для возврата x * 3 внутри блочного тела. Kotlin выводит тип возвращаемого значения функции, которая имеет тело выражения:

// Functions/MultiplyByFour.kt
**fun** multiplyByFour(x: **Int** ) = x * 4
**fun** main() {
    **val** result: **Int** = multiplyByFour(5)
    println(result)
}
/* Вывод:
20
*/

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

• При написании функций выбирайте описательные имена. Это делает код более читаемым и часто может уменьшить необходимость в комментариях к коду. Мы не всегда можем быть такими описательными, как нам хотелось бы, с именами функций в этой книге, потому что мы ограничены длиной строк.

Упражнения и решения можно найти на www.AtomicKotlin.com.

if-выражения Link to heading

Выражение if делает выбор. Ключевое слово if проверяет выражение, чтобы узнать, истинно оно или ложно, и выполняет действие на основе результата. Выражение, которое может быть истинным или ложным, называется логическим (Boolean), в честь математика Джорджа Буля, который изобрел логику, лежащую в основе этих выражений. Вот пример с использованием символов > (больше) и < (меньше):

// IfExpressions/If1.kt
fun main() {
    if (1 > 0)
        println("Это правда!")
    if (10 < 11) {
        println("10 < 11")
        println("десять меньше одиннадцати")
    }
}
/* Вывод:
Это правда!
10 < 11
десять меньше одиннадцати
*/

Выражение внутри скобок после if должно оцениваться как истинное или ложное. Если истинно, выполняется следующее выражение. Чтобы выполнить несколько строк, поместите их в фигурные скобки.

Мы можем создать логическое выражение в одном месте и использовать его в другом:

// IfExpressions/If2.kt
fun main() {
    val x: Boolean = 1 >= 1
    if (x)
        println("Это правда!")
}
/* Вывод:
Это правда!
*/

Поскольку x является логическим, if может проверить его напрямую, сказав if(x). Логический оператор >= возвращает true, если выражение слева от оператора больше или равно тому, что справа. Аналогично, <= возвращает true, если выражение слева меньше или равно тому, что справа.

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

// IfExpressions/If3.kt
fun main() {
    val n: Int = -11
    if (n > 0)
        println("Это положительное число")
    else
        println("Это отрицательное число или ноль")
}
/* Вывод:
Это отрицательное число или ноль
*/

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

// IfExpressions/If4.kt
fun main() {
    val n: Int = -11
    if (n > 0)
        println("Это положительное число")
    else if (n == 0)
        println("Это ноль")
    else
        println("Это отрицательное число")
}
/* Вывод:
Это отрицательное число
*/

Здесь мы используем == для проверки двух чисел на равенство. != проверяет на неравенство. Типичный шаблон — начать с if, за которым следуют столько else if, сколько вам нужно, заканчивая финальным else для всего, что не соответствует всем предыдущим тестам. Когда выражение if достигает определенного размера и сложности, вы, вероятно, будете использовать выражение when вместо этого. Выражение when описано позже в книге, в разделе “Выражения when”.

Оператор “не” ! проверяет противоположное логическому выражению:

// IfExpressions/If5.kt
fun main() {
    val y: Boolean = false
    if (!y)
        println("!y истинно")
}
/* Вывод:
!y истинно
*/

Чтобы выразить if(!y), скажите “если не y”. Все выражение if является выражением, поэтому оно может производить результат:

// IfExpressions/If6.kt
fun main() {
    val num = 10
    val result = if (num > 100) 4 else 42
    println(result)
}
/* Вывод:
42
*/

Здесь мы сохраняем значение, производимое всем выражением if, в промежуточном идентификаторе, называемом result. Если условие выполнено, первая ветвь производит result. Если нет, значение else становится result.

Давайте попрактикуемся в создании функций. Вот одна, которая принимает логический параметр:

// IfExpressions/TrueOrFalse.kt
fun trueOrFalse(exp: Boolean): String {
    if (exp)
        return "Это правда!" // [1]
    return "Это ложь" // [2]
}

fun main() {
    val b = 1
    println(trueOrFalse(b < 3))
    println(trueOrFalse(b >= 3))
}
/* Вывод:
Это правда!
Это ложь
*/

Логический параметр exp передается в функцию trueOrFalse(). Если аргумент передан как выражение, такое как b < 3, это выражение сначала оценивается, и результат передается в функцию. trueOrFalse() проверяет exp, и если результат истинный, выполняется строка [1], в противном случае выполняется строка [2].

• [1] return говорит: “Покиньте функцию и произведите это значение как результат функции.” Обратите внимание, что return может появляться в любом месте функции и не обязательно должен быть в конце.

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

// IfExpressions/OneOrTheOther.kt
fun oneOrTheOther(exp: Boolean): String =
    if (exp)
        "Правда!" // Нет необходимости в 'return'
    else
        "Ложь"

fun main() {
    val x = 1
    println(oneOrTheOther(x == 1))
    println(oneOrTheOther(x == 2))
}
/* Вывод:
Правда!
Ложь
*/

Вместо двух выражений в trueOrFalse(), oneOrTheOther() является единым выражением. Результат этого выражения является результатом функции, поэтому выражение if становится телом функции.

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Шаблоны строк Link to heading

Шаблон строки — это программный способ генерации строки. Если вы поставите знак $ перед именем идентификатора, шаблон строки вставит содержимое этого идентификатора в строку: // StringTemplates/StringTemplates.kt fun main() { val answer = 42 println(“Найдено $ answer!”) // [1] println(“печатаем $ 1”) // [2] } /* Вывод: Найдено 42! печатаем $1 */ • [1] $answer заменяет значение переменной answer. • [2] Если то, что следует за $, не распознается как идентификатор программы, ничего особенного не происходит.

Вы также можете вставлять значения в строку, используя конкатенацию (+): // StringTemplates/StringConcatenation.kt fun main() { val s = “привет\n” // \n — это символ новой строки val n = 11 val d = 3.14 println(“первый: " + s + “второй: " + n + “, третий: " + d) } /* Вывод: первый: привет второй: 11, третий: 3.14 / Шаблоны строк 45 Помещение выражения внутрь ${} вычисляет его. Возвращаемое значение преобразуется в строку и вставляется в результирующую строку: // StringTemplates/ExpressionInTemplate.kt fun main() { val condition = true println( " ${if (condition) ‘a’ else ‘b’ } “) // [1] val x = 11 println(” $ x + 4 = ${ x + 4 } “) } / Вывод: a 11 + 4 = 15 */ • [1] if(condition) 'a' else 'b' вычисляется, и результат заменяется на всё выражение ${}.

Когда строка должна включать специальный символ, такой как кавычка, вы можете либо экранировать этот символ с помощью \ (обратный слэш), либо использовать строковый литерал в тройных кавычках: // StringTemplates/TripleQuotes.kt fun main() { val s = “значение” println(“s = " $ s".”) println(“““s = " $ s”.”””) } /* Вывод: s = “значение”. s = “значение”. */ С помощью тройных кавычек вы вставляете значение выражения так же, как и для строки в одинарных кавычках.

Упражнения и решения можно найти на www.AtomicKotlin.com. AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Типы чисел Link to heading

Разные типы чисел хранятся по-разному. Если вы создаете идентификатор и присваиваете ему целочисленное значение, Kotlin выводит тип Int: // NumberTypes/InferInt.kt fun main() { val million = 1_000_000 // Выводит Int println(million) } /* Вывод: 1000000 / Для удобочитаемости Kotlin позволяет использовать подчеркивания в числовых значениях. Основные математические операторы для чисел — это те, которые доступны в большинстве языков программирования: сложение ( + ), вычитание ( - ), деление ( / ), умножение ( * ) и остаток ( % ), который возвращает остаток от целочисленного деления: // NumberTypes/Modulus.kt fun main() { val numerator: Int = 19 val denominator: Int = 10 println(numerator % denominator) } / Вывод: 9 / Целочисленное деление отсекает свой результат: // NumberTypes/IntDivisionTruncates.kt fun main() { val numerator: Int = 19 val denominator: Int = 10 println(numerator / denominator) } / Вывод: 1 / Если бы операция округлила результат, вывод был бы 2. Порядок операций следует основным арифметическим правилам: // NumberTypes/OpOrder.kt fun main() { println(45 + 5 * 6) } / Вывод: 75 / Операция умножения 5 * 6 выполняется первой, за ней следует сложение 45 + 30. Если вы хотите, чтобы 45 + 5 выполнялось первым, используйте скобки: // NumberTypes/OpOrderParens.kt fun main() { println((45 + 5) * 6) } / Вывод: 300 / Теперь давайте рассчитаем индекс массы тела (ИМТ), который равен весу в килограммах, деленному на квадрат роста в метрах. Если ваш ИМТ меньше 18.5, вы имеете недостаточный вес. Между 18.5 и 24.9 — нормальный вес. ИМТ 25 и выше — избыточный вес. Этот пример также показывает предпочтительный стиль форматирования, когда вы не можете уместить параметры функции в одной строке: AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC NumberTypes 48 // NumberTypes/BMIMetric.kt fun bmiMetric( weight: Double , height: Double ): String { val bmi = weight / (height * height) // [1] return if (bmi < 18.5) “Недостаточный вес” else if (bmi < 25) “Нормальный вес” else “Избыточный вес” } fun main() { val weight = 72.57 // 160 фунтов val height = 1.727 // 68 дюймов val status = bmiMetric(weight, height) println(status) } / Вывод: Нормальный вес / • [1] Если вы уберете скобки, вы разделите вес на рост, а затем умножите этот результат на рост. Это будет гораздо большее число и неправильный ответ. bmiMetric() использует Double для веса и роста. Double может хранить очень большие и очень маленькие числа с плавающей запятой. Вот версия, использующая английские единицы, представленные параметрами Int: // NumberTypes/BMIEnglish.kt fun bmiEnglish( weight: Int , height: Int ): String { val bmi = weight / (height * height) * 703.07 // [1] return if (bmi < 18.5) “Недостаточный вес” else if (bmi < 25) “Нормальный вес” else “Избыточный вес” } AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC NumberTypes 49 fun main() { val weight = 160 val height = 68 val status = bmiEnglish(weight, height) println(status) } / Вывод: Недостаточный вес / Почему результат отличается от bmiMetric(), который использует Double? Когда вы делите целое число на другое целое число, Kotlin возвращает целочисленный результат. Стандартный способ обработки остатка при целочисленном делении — это отбрасывание, что означает «отсечь и выбросить» (округления нет). Поэтому, если вы делите 5 на 2, вы получаете 2, а 7/10 — это ноль. Когда Kotlin вычисляет bmi в выражении [1], он делит 160 на 68 * 68 и получает ноль. Затем он умножает ноль на 703.07 и получает ноль. Чтобы избежать этой проблемы, переместите 703.07 в начало вычисления. Вычисления тогда будут принудительно выполнены как Double: val bmi = 703.07 * weight / (height * height) Параметры Double в bmiMetric() предотвращают эту проблему. Преобразуйте вычисления в нужный тип как можно раньше, чтобы сохранить точность. Все языки программирования имеют ограничения на то, что они могут хранить в целочисленном формате. Тип Int в Kotlin может принимать значения от -2^31 до +2^31-1, что является ограничением 32-битного представления Int. Если вы складываете или умножаете два достаточно больших Int, вы получите переполнение результата: AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC NumberTypes 50 // NumberTypes/IntegerOverflow.kt fun main() { val i: Int = Int .MAX_VALUE println(i + i) } / Вывод: -2 / Int.MAX_VALUE — это предопределенное значение, которое является наибольшим числом, которое может хранить Int. Переполнение приводит к результату, который явно неверен, так как он и отрицательный, и гораздо меньше, чем мы ожидаем. Kotlin выдает предупреждение всякий раз, когда он обнаруживает потенциальное переполнение. Предотвращение переполнения — это ваша ответственность как разработчика. Kotlin не всегда может обнаружить переполнение во время компиляции, и он не предотвращает переполнение, так как это приведет к неприемлемому влиянию на производительность. Если ваша программа содержит большие числа, вы можете использовать Long, которые могут хранить значения от -2^63 до +2^63-1. Чтобы определить val типа Long, вы можете явно указать тип или добавить L в конец числового литерала, что говорит Kotlin рассматривать это значение как Long: // NumberTypes/LongConstants.kt fun main() { val i = 0 // Выводит Int val l1 = 0L // L создает Long val l2: Long = 0 // Явный тип println(” $ l1 $ l2”) } / Вывод: 0 0 / Изменив на Long, мы предотвращаем переполнение в IntegerOverflow.kt: AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC NumberTypes 51 // NumberTypes/UsingLongs.kt fun main() { val i = Int .MAX_VALUE println(0L + i + i) // [1] println(1_000_000 * 1_000_000L) // [2] } / Вывод: 4294967294 1000000000000 / Использование числового литерала в обоих [1] и [2] принуждает вычисления к типу Long и также дает результат типа Long. Место, где появляется L, не имеет значения. Если одно из значений — Long, результирующее выражение будет Long. Хотя они могут хранить гораздо большие значения, чем Int, Long все еще имеют ограничения по размеру: // NumberTypes/BiggestLong.kt fun main() { println( Long .MAX_VALUE) } / Вывод: 9223372036854775807 */ Long.MAX_VALUE — это наибольшее значение, которое может хранить Long. Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Булевы значения Link to heading

Выражения if продемонстрировали оператор “не” !, который отрицает булевое значение. Этот атом вводит больше булевой алгебры. Мы начинаем с операторов “и” и “или”:

• && (и): Возвращает true только если булевое выражение слева от оператора и то, что справа, оба истинны.
• || (или): Возвращает true, если хотя бы одно из выражений слева или справа от оператора истинно, или если оба истинны.

В этом примере мы определяем, открыто ли предприятие, основываясь на времени:

// Booleans/Open1.kt
fun isOpen1(hour: Int) {
    val open = 9
    val closed = 20
    println("Часы работы: $open - $closed")
    val status = if (hour >= open && hour < closed) // [1]
        true
    else
        false
    println("Открыто: $status")
}

fun main() = isOpen1(6)
/* Вывод:
Часы работы: 9 - 20
Открыто: false
*/

main() — это единичный вызов функции, поэтому мы можем использовать тело выражения, как описано в разделе о функциях. Выражение if в [1] проверяет, находится ли час между временем открытия и закрытия, поэтому мы комбинируем выражения с булевым && (и). Выражение if можно упростить. Результат выражения if(cond) true else false — это просто cond:

// Booleans/Open2.kt
fun isOpen2(hour: Int) {
    val open = 9
    val closed = 20
    println("Часы работы: $open - $closed")
    val status = hour >= open && hour < closed
    println("Открыто: $status")
}

fun main() = isOpen2(6)
/* Вывод:
Часы работы: 9 - 20
Открыто: false
*/

Давайте изменим логику и проверим, закрыто ли предприятие в данный момент. Оператор “или” || возвращает true, если хотя бы одно из условий выполнено:

// Booleans/Closed.kt
fun isClosed(hour: Int) {
    val open = 9
    val closed = 20
    println("Часы работы: $open - $closed")
    val status = hour < open || hour >= closed
    println("Закрыто: $status")
}

fun main() = isClosed(6)
/* Вывод:
Часы работы: 9 - 20
Закрыто: true
*/

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

// Booleans/EvaluationOrder.kt
fun main() {
    val sunny = true
    val hoursSleep = 6
    val exercise = false
    val temp = 55
    // [1]:
    val happy1 = sunny && temp > 50 || exercise && hoursSleep > 7
    println(happy1)
    // [2]:
    val sameHappy1 = (sunny && temp > 50) || (exercise && hoursSleep > 7)
    println(sameHappy1)
    // [3]:
    val notSame = (sunny && temp > 50 || exercise) && hoursSleep > 7
    println(notSame)
}
/* Вывод:
true
true
false
*/

Булевые выражения — это sunny, temp > 50, exercise и hoursSleep > 7. Мы читаем happy1 как “Солнечно и температура выше 50 или я занимался спортом и спал больше 7 часов”. Но имеет ли && приоритет над ||, или наоборот?

Выражение в [1] использует порядок вычисления по умолчанию в Kotlin. Это дает тот же результат, что и выражение в [2], потому что без скобок “и” вычисляются первыми, а затем “или”. Выражение в [3] использует скобки, чтобы получить другой результат. В [3] мы счастливы только если получили как минимум 7 часов сна.

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Повторение с помощью while Link to heading

Компьютеры идеально подходят для повторяющихся задач.
Самая базовая форма повторения использует ключевое слово while. Это повторяет блок, пока управляющее логическое выражение истинно:
while ( логическое -выражение) {
// Код для повторения
}
Логическое выражение оценивается один раз в начале цикла и снова перед каждой дальнейшей итерацией через блок.
// RepetitionWithWhile/WhileLoop.kt
fun condition(i: Int) = i < 100 // [1]
fun main() {
var i = 0
while (condition(i)) { // [2]
print(”.")
i += 10 // [3]
}
}
/* Вывод:
……….
*/
• [1] Оператор сравнения < возвращает логический результат, поэтому Kotlin выводит логический тип как результат для condition().
• [2] Условное выражение для while говорит: “повторяйте операторы в теле, пока condition() возвращает true.”
• [3] Оператор += добавляет 10 к i и присваивает результат i в одной операции (i должен быть var, чтобы это работало). Это эквивалентно:
i = i + 10

Существует второй способ использования while, в сочетании с ключевым словом do:
do {
// Код для повторения
} while ( логическое -выражение)
Переписывание WhileLoop.kt с использованием do-while дает:
// RepetitionWithWhile/DoWhileLoop.kt
fun main() {
var i = 0
do {
print(".")
i += 10
} while (condition(i))
}
/* Вывод:
……….
*/
Единственное отличие между while и do-while заключается в том, что тело do-while всегда выполняется хотя бы один раз, даже если логическое выражение изначально возвращает false. В while, если условие ложно в первый раз, то тело никогда не выполняется. На практике do-while используется реже, чем while.

Короткие версии операторов присваивания доступны для всех арифметических операций: +=, -=, =, /= и %= . Это использует -= и %=:
AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Повторение с помощью while 58
// RepetitionWithWhile/AssignmentOperators.kt
fun main() {
var n = 10
val d = 3
print(n)
while (n > d) {
n -= d
print(" - $ d")
}
println(" = $ n")
var m = 10
print(m)
m %= d
println(" % $ d = $ m")
}
/ Вывод:
10 - 3 - 3 - 3 = 1
10 % 3 = 1
/
Чтобы вычислить остаток от целочисленного деления двух натуральных чисел, мы начинаем с цикла while, а затем используем оператор остатка.
Прибавление 1 и вычитание 1 из числа так распространены, что у них есть свои собственные операторы инкремента и декремента: ++ и –. Вы можете заменить i += 1 на i++:
// RepetitionWithWhile/IncrementOperator.kt
fun main() {
var i = 0
while (i < 4) {
print(".")
i++
}
}
/ Вывод:
….
*/
На практике циклы while не используются для итерации по диапазону чисел. Вместо этого используется цикл for. Это будет рассмотрено в следующем атоме.
AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Повторение с помощью while 59
Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Циклы и диапазоны Link to heading

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

for (v in values) {
    // Выполнить что-то с v
}

Каждый раз при проходе по циклу переменной v присваивается следующий элемент из values. Вот пример цикла for, который повторяет действие фиксированное количество раз:

// LoopingAndRanges/RepeatThreeTimes.kt
fun main() {
    for (i in 1..3) {
        println("Привет, $i!")
    }
}
/* Вывод:
Привет, 1!
Привет, 2!
Привет, 3!
*/

Вывод показывает, что индекс i получает каждое значение в диапазоне от 1 до 3. Диапазон — это интервал значений, определяемый парой конечных точек. Существует два основных способа определения диапазонов:

// LoopingAndRanges/DefiningRanges.kt
fun main() {
    val range1 = 1..10 // [1]
    val range2 = 0 until 10 // [2]
    println(range1)
    println(range2)
}
/* Вывод:
1..10
0..9
*/

• [1] Использование синтаксиса .. включает обе границы в результирующий диапазон.
• [2] until исключает конец. Вывод показывает, что 10 не является частью диапазона.

Отображение диапазона производит читаемый формат. Это сумма чисел от 10 до 100:

// LoopingAndRanges/SumUsingRange.kt
fun main() {
    var sum = 0
    for (n in 10..100) {
        sum += n
    }
    println("сумма = $sum")
}
/* Вывод:
сумма = 5005
*/

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

// LoopingAndRanges/ForWithRanges.kt
fun showRange(r: IntProgression) {
    for (i in r) {
        print(" $i ")
    }
    print(" // $r")
    println()
}

fun main() {
    showRange(1..5)
    showRange(0 until 5)
    showRange(5 downTo 1) // [1]
    showRange(0..9 step 2) // [2]
    showRange(0 until 10 step 3) // [3]
    showRange(9 downTo 2 step 3)
}
/* Вывод:
1 2 3 4 5 // 1..5
0 1 2 3 4 // 0..4
5 4 3 2 1 // 5 downTo 1 step 1
0 2 4 6 8 // 0..8 step 2
0 3 6 9 // 0..9 step 3
9 6 3 // 9 downTo 3 step 3
*/

• [1] downTo создает убывающий диапазон.
• [2] step изменяет интервал. Здесь диапазон увеличивается на два вместо одного.
• [3] until также может использоваться с step. Обратите внимание, как это влияет на вывод.

В каждом случае последовательность чисел образует арифметическую прогрессию. showRange() принимает параметр IntProgression, который является встроенным типом, включающим диапазоны Int. Обратите внимание, что строковое представление каждого IntProgression, как оно появляется в комментарии к выводу для каждой строки, часто отличается от диапазона, переданного в showRange() — IntProgression переводит входные данные в эквивалентную общую форму.

Вы также можете создать диапазон символов. Этот цикл проходит от a до z:

// LoopingAndRanges/ForWithCharRange.kt
fun main() {
    for (c in 'a'..'z') {
        print(c)
    }
}
/* Вывод:
abcdefghijklmnopqrstuvwxyz
*/

Вы можете итерировать по диапазону элементов, которые являются целыми количествами, такими как целые числа и символы, но не по значениям с плавающей запятой. Квадратные скобки позволяют получить доступ к символам по индексу. Поскольку мы начинаем считать символы в строке с нуля, s[0] выбирает первый символ строки s. Выбор s.lastIndex дает последний индекс:

// LoopingAndRanges/IndexIntoString.kt
fun main() {
    val s = "abc"
    for (i in 0..s.lastIndex) {
        print(s[i] + 1)
    }
}
/* Вывод:
bcd
*/

Иногда люди описывают s[0] как “нулевой символ”. Символы хранятся как числа, соответствующие их значениям Unicode, поэтому добавление целого числа к символу производит новый символ, соответствующий новому кодовому значению:

// LoopingAndRanges/AddingIntToChar.kt
fun main() {
    val ch: Char = 'a'
    println(ch + 25)
    println(ch < 'z')
}
/* Вывод:
z
true
*/

Второй println() показывает, что вы можете сравнивать коды символов. Цикл for может итерировать строку s напрямую:

// LoopingAndRanges/IterateOverString.kt
fun main() {
    for (ch in "Jnskhm ") {
        print(ch + 1)
    }
}
/* Вывод:
Kotlin!
*/

ch получает каждый символ по очереди. В следующем примере функция hasChar() итерирует по строке s и проверяет, содержит ли она данный символ ch. Возврат в середине функции останавливает выполнение функции, когда ответ найден:

// LoopingAndRanges/HasChar.kt
fun hasChar(s: String, ch: Char): Boolean {
    for (c in s) {
        if (c == ch) return true
    }
    return false
}

fun main() {
    println(hasChar("kotlin", 't'))
    println(hasChar("kotlin", 'a'))
}
/* Вывод:
true
false
*/

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

// LoopingAndRanges/RepeatHi.kt
fun main() {
    repeat(2) {
        println("привет!")
    }
}
/* Вывод:
привет!
привет!
*/

repeat() — это функция стандартной библиотеки, а не ключевое слово. Вы увидите, как она была создана гораздо позже в книге. Упражнения и решения можно найти на www.AtomicKotlin.com.

Ключевое слово in Link to heading

Ключевое слово in проверяет, находится ли значение в пределах диапазона. // InKeyword/MembershipInRange.kt fun main() { val percent = 35 println(percent in 1..100) } /* Вывод: true / В логических выражениях вы научились явно проверять границы: // InKeyword/MembershipUsingBounds.kt fun main() { val percent = 35 println(0 <= percent && percent <= 100) } / Вывод: true / 0 <= x && x <= 100 логически эквивалентно x in 0..100. IntelliJ IDEA предлагает автоматически заменить первую форму на вторую, которая легче для чтения и понимания.
Ключевое слово in используется как для итерации, так и для проверки членства. Использование in в управляющем выражении цикла for означает итерацию, в противном случае in проверяет членство:
Ключевое слово in 67 // InKeyword/IterationVsMembership.kt fun main() { val values = 1..3 for (v in values) { println(“итерация $ v”) } val v = 2 if (v in values) println(" $ v является членом $ values") } / Вывод: итерация 1 итерация 2 итерация 3 2 является членом 1..3 / Ключевое слово in не ограничивается диапазонами. Вы также можете проверить, является ли символ частью строки. В следующем примере используется in вместо hasChar() из предыдущего атома: // InKeyword/InString.kt fun main() { println(’t’ in “kotlin”) println(‘a’ in “kotlin”) } / Вывод: true false / Позже в книге вы увидите, что in работает и с другими типами.
Здесь in проверяет, принадлежит ли символ диапазону символов:
AtomicKotlin(www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC
Ключевое слово in 68 // InKeyword/CharRange.kt fun isDigit(ch: Char ) = ch in ‘0’..‘9’ fun notDigit(ch: Char ) = ch !in ‘0’..‘9’ // [1] fun main() { println(isDigit(‘a’)) println(isDigit(‘5’)) println(notDigit(‘z’)) } / Вывод: false true true / • [1] !in проверяет, что значение не принадлежит диапазону.
Вы можете создать диапазон Double, но можете использовать его только для проверки членства: // InKeyword/FloatingPointRange.kt fun inFloatRange(n: Double ) { val r = 1.0..10.0 println(" $ n в $ r? ${ n in r } “) } fun main() { inFloatRange(0.999999) inFloatRange(5.0) inFloatRange(10.0) inFloatRange(10.0000001) } / Вывод: 0.999999 в 1.0..10.0? false 5.0 в 1.0..10.0? true 10.0 в 1.0..10.0? true 10.0000001 в 1.0..10.0? false / Вы можете использовать только .. для определения диапазона с плавающей запятой в Kotlin.
Вы можете проверить, является ли строка членом диапазона строк:
AtomicKotlin(www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC
Ключевое слово in 69 // InKeyword/StringRange.kt fun main() { println(“ab” in “aa”..“az”) println(“ba” in “aa”..“az”) } / Вывод: true false */ Здесь Kotlin использует алфавитное сравнение.
Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin(www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC

Выражения и операторы Link to heading

Операторы и выражения — это наименьшие полезные фрагменты кода в большинстве языков программирования. Существует основное различие: оператор имеет эффект, но не производит результата. Выражение всегда производит результат. Поскольку оператор не производит результат, он должен изменить состояние окружающей среды, чтобы быть полезным. Другими словами, «оператор вызывается из-за его побочных эффектов» (то есть того, что он делает, кроме производства результата). В качестве напоминания:
Оператор изменяет состояние.

Одно из определений «выражать» — это «заставить или выжать», как в «выжать сок из апельсина». Таким образом,
Выражение выражает.
То есть, оно производит результат.

Цикл for является оператором в Kotlin. Вы не можете присвоить его, потому что у него нет результата:

// ExpressionsStatements/ForIsAStatement.kt
fun main() {
    // Нельзя сделать это:
    // val f = for(i in 1..10) {}
    // Сообщение об ошибке компилятора:
    // for не является выражением, и
    // здесь разрешены только выражения
}

Цикл for используется из-за своих побочных эффектов.
Выражение производит значение, которое можно присвоить или использовать как часть другого выражения, в то время как оператор всегда является элементом верхнего уровня.
Каждый вызов функции является выражением. Даже если функция возвращает Unit и вызывается только ради своих побочных эффектов, результат все равно может быть присвоен:

// ExpressionsStatements/UnitReturnType.kt
fun unitFun() = Unit
fun main() {
    println(unitFun())
    val u1: Unit = println(42)
    println(u1)
    val u2 = println(0) // Вывод типа
    println(u2)
}
/* Вывод:
kotlin.Unit
42
kotlin.Unit
0
kotlin.Unit
*/

Тип Unit содержит единственное значение, называемое Unit, которое вы можете вернуть напрямую, как видно в unitFun(). Вызов println() также возвращает Unit. Переменная val u1 захватывает возвращаемое значение println() и явно объявляется как Unit, в то время как u2 использует вывод типа.
Оператор if создает выражение, поэтому вы можете присвоить его результат:

// ExpressionsStatements/AssigningAnIf.kt
fun main() {
    val result1 = if (11 > 42) 9 else 5
    val result2 = if (1 < 2) {
        val a = 11
        a + 42
    } else 42
    val result3 =
        if ('x' < 'y')
            println("x < y")
        else
            println("x > y")
    println(result1)
    println(result2)
    println(result3)
}
/* Вывод:
x < y
5
53
kotlin.Unit
*/

Первая строка вывода — x < y, даже несмотря на то, что result3 не отображается до конца main(). Это происходит потому, что при оценке result3 вызывается println(), и оценка происходит, когда result3 определяется.
Обратите внимание, что a определяется внутри блока кода для result2. Результат последнего выражения становится результатом выражения if; здесь это сумма 11 и 42.
Но что насчет a? Как только вы покидаете блок кода (выходите за фигурные скобки), вы не можете получить доступ к a. Он временный и удаляется, как только вы выходите из области видимости этого блока.
Оператор инкремента i++ также является выражением, даже если он выглядит как оператор. Kotlin следует подходу, используемому в языках, подобных C, и предоставляет две версии операторов инкремента и декремента с немного различной семантикой. Префиксный оператор появляется перед операндом, как в ++i, и возвращает значение после того, как инкремент произошел. Вы можете прочитать это как «сначала выполните инкремент, затем верните полученное значение». Постфиксный оператор ставится после операнда, как в i++, и возвращает значение i до того, как произойдет инкремент. Вы можете прочитать это как «сначала получите результат, затем выполните инкремент».

// ExpressionsStatements/PostfixVsPrefix.kt
fun main() {
    var i = 10
    println(i++)
    println(i)
    var j = 20
    println(++j)
    println(j)
}
/* Вывод:
10
11
21
21
*/

Оператор декремента также имеет две версии: –i и i–. Использование операторов инкремента и декремента внутри других выражений не рекомендуется, так как это может привести к запутанному коду:

// ExpressionsStatements/Confusing.kt
fun main() {
    var i = 1
    println(i++ + ++i)
}

Попробуйте угадать, каков будет вывод, а затем проверьте.
Упражнения и решения можно найти на www.AtomicKotlin.com.

Резюме 1 Link to heading

Этот атом подводит итоги и рассматривает атомы в Разделе I, начиная с “Привет, мир!” и заканчивая “Выражения и операторы”. Если вы опытный программист, это должен быть ваш первый атом. Новым программистам следует прочитать этот атом и выполнить упражнения в качестве повторения Раздела I. Если что-то вам неясно, изучите соответствующий атом по этой теме (подзаголовки соответствуют названиям атомов).

Привет, мир Link to heading

Kotlin поддерживает как // однострочные комментарии, так и /* -до- */ многострочные комментарии. Точка входа в программу — это функция main():

// Summary1/Hello.kt
**fun** main() {
    println("Hello, world!")
}
/* Вывод:
Hello, world!
*/

Первая строка каждого примера в этой книге — это комментарий, содержащий имя подкаталога атома, за которым следует / и имя файла. Вы можете найти все извлеченные примеры кода на сайте AtomicKotlin.com18.

Функция println() является стандартной библиотечной функцией, которая принимает один параметр типа String (или параметр, который может быть преобразован в String). Функция println() перемещает курсор на новую строку после отображения своего параметра, в то время как функция print() оставляет курсор на той же строке.

18 http://AtomicKotlin.com
Summary1 75
Kotlin не требует точки с запятой в конце выражения или оператора. Точки с запятой необходимы только для разделения нескольких выражений или операторов в одной строке.

var & val, Типы Данных Link to heading

Чтобы создать неизменяемый идентификатор, используйте ключевое слово val, за которым следует имя идентификатора, двоеточие и тип для этого значения. Затем добавьте знак равенства и значение, которое нужно присвоить этому val: val идентификатор: Тип = инициализация
Как только val присвоен, его нельзя переназначить.
Вывод типов в Kotlin обычно может автоматически определить тип на основе значения инициализации. Это приводит к более простой записи: val идентификатор = инициализация
Оба следующих варианта являются допустимыми: val daysInFebruary = 28
val daysInMarch: Int = 31

Определение var (переменной) выглядит так же, с использованием var вместо val: var идентификатор1 = инициализация
var идентификатор2: Тип = инициализация
В отличие от val, вы можете изменять var, поэтому следующее является законным: var hoursSpent = 20
hoursSpent = 25

Однако тип не может быть изменен, поэтому вы получите ошибку, если скажете: hoursSpent = 30.5
Kotlin выводит тип Int, когда hoursSpent определяется, поэтому он не примет изменение на значение с плавающей точкой.

Функции Link to heading

Функции — это именованные подпрограммы: AtomicKotlin (www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC
Резюме 1 76
fun имяФункции(арг1: Тип1, арг2: Тип2, …): ТипВозврата {
// Строки кода …
return результат
}
Ключевое слово fun следует за именем функции и списком параметров в круглых скобках. Каждый параметр должен иметь явный тип, так как Kotlin не может вывести типы параметров. Сама функция также имеет тип, который определяется так же, как для переменной var или val (двоеточие, за которым следует тип). Тип функции — это тип возвращаемого результата.
Подпись функции сопровождается телом функции, заключенным в фигурные скобки. Оператор return предоставляет значение, возвращаемое функцией.
Вы можете использовать сокращенный синтаксис, когда функция состоит из одного выражения:
fun имяФункции(арг1: Тип1, арг2: Тип2, …): ТипВозврата = результат
Эта форма называется телом выражения. Вместо открывающей фигурной скобки используйте знак равенства, за которым следует выражение. Вы можете опустить тип возврата, так как Kotlin может его вывести.
Вот функция, которая вычисляет куб своего параметра, и другая, которая добавляет восклицательный знак к строке:

// Резюме 1/ОсновныеФункции.kt
**fun** куб(x: **Int** ): **Int** {  
**return** x * x * x  
}  
**fun** восклицание(s: **String** ) = s + "!"  
**fun** main() {  
println(куб(3))  
println(восклицание("pop"))  
}  
/* Вывод:  
27  
pop!  
*/  

AtomicKotlin (www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC
Резюме 1 77
куб() имеет блочное тело с явным оператором return. восклицание() — это тело выражения, производящее значение, возвращаемое функцией. Kotlin выводит тип возврата восклицание() как String.

Булевы значения Link to heading

Для булевой алгебры Kotlin предоставляет такие операторы, как: • ! (не) логически отрицает значение (превращает true в false и наоборот). • && (и) возвращает true только если оба условия истинны. • || (или) возвращает true, если хотя бы одно из условий истинно. // Summary1/Booleans.kt fun main() { val opens = 9 val closes = 20 println(“Часы работы: $ opens - $ closes”) val hour = 6 println(“Текущее время: " + hour) val isOpen = hour >= opens && hour < closes println(“Открыто: " + isOpen) println(“Закрыто: " + !isOpen) val isClosed = hour < opens || hour >= closes println(“Закрыто: " + isClosed) } /* Вывод: Часы работы: 9 - 20 Текущее время: 6 Открыто: false Закрыто: true */ Инициализатор isOpen использует && для проверки, истинны ли оба условия. Первое условие hour >= opens ложно, поэтому результат всего выражения становится ложным. Инициализатор для isClosed использует ||, возвращая true, если хотя бы одно из условий истинно. Выражение hour < opens истинно, поэтому всё выражение истинно. AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC Summary1 78

if Выражения Link to heading

Поскольку if является выражением, оно производит результат. Этот результат может быть присвоен переменной var или val. Здесь вы также видите использование ключевого слова else: // Summary1/IfResult.kt fun main() { val result = if (99 < 100) 4 else 42 println(result) } /* Вывод: 4 / Любая ветка выражения if может быть многострочным блоком кода, окруженным фигурными скобками: // Summary1/IfExpression.kt fun main() { val activity = “плавание” val hour = 10 val isOpen = if ( activity == “плавание” || activity == “катание на коньках”) { val opens = 9 val closes = 20 println(“Часы работы: " + opens + " - " + closes) hour >= opens && hour < closes } else { false } println(isOpen) } / Вывод: Часы работы: 9 - 20 true */ AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккела и Светланы Исаковой, ©2021 MindView LLC Summary1 79 Значение, определенное внутри блока кода, такого как opens, недоступно за пределами области видимости этого блока. Поскольку они определены глобально для выражения if, activity и hour доступны внутри выражения if. Результат выражения if — это результат последнего выражения выбранной ветки. Здесь это hour >= opens && hour <= closes, что является истинным.

Шаблоны строк Link to heading

Вы можете вставить значение в строку, используя шаблоны строк. Используйте символ $ перед именем идентификатора: // Summary1/StrTemplates.kt fun main() { val answer = 42 println(“Найдено $ answer!”) // [1] val condition = true println( " ${if (condition) ‘a’ else ‘b’ } “) // [2] println(“печатаем a $ 1”) // [3] } /* Вывод: Найдено 42! a печатаем a $1 / • [1] $answer заменяет значение, содержащееся в answer. • [2] ${if(condition) ‘a’ else ‘b’} вычисляет и заменяет результат выражения внутри ${}. • [3] Если $ следует за чем-то, что не распознается как идентификатор программы, ничего особенного не происходит. Используйте тройные кавычки для хранения многострочного текста или текста со специальными символами: AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC Summary1 80 // Summary1/ThreeQuotes.kt fun json(q: String, a: Int) = “””{ “вопрос” : " $ q”, “ответ” : $ a }””” fun main() { println(json(“Ультимативный”, 42)) } / Вывод: { “вопрос” : “Ультимативный”, “ответ” : 42 } */ Вам не нужно экранировать специальные символы, такие как " внутри строки с тройными кавычками. (В обычной строке вы пишете " для вставки двойной кавычки). Как и в обычных строках, вы можете вставить идентификатор или выражение, используя $ внутри строки с тройными кавычками.

Типы чисел Link to heading

Kotlin предоставляет целочисленные типы (Int, Long) и типы с плавающей точкой (Double). Константа целого числа по умолчанию является Int, а Long, если вы добавите L. Константа является Double, если она содержит десятичную точку: // Summary1/NumberTypes.kt fun main() { val n = 1000 // Int val l = 1000L // Long val d = 1000.0 // Double println(” $ n $ l $ d”) } /* Вывод: 1000 1000 1000.0 / Int может хранить значения от -2^31 до +2^31-1. Целочисленные значения могут переполняться; например, добавление чего-либо к Int.MAX_VALUE приводит к переполнению: AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC Summary1 81 // Summary1/Overflow.kt fun main() { println( Int .MAX_VALUE + 1) println( Int .MAX_VALUE + 1L) } / Вывод: -2147483648 2147483648 */ Во втором операторе println() мы добавляем L к 1, заставляя всё выражение быть типа Long, что предотвращает переполнение. (Long может хранить значения от -2^63 до +2^63-1).

Когда вы делите Int на другой Int, Kotlin возвращает результат типа Int, и любое остаток отбрасывается. Таким образом, 1/2 дает 0. Если участвует Double, Int преобразуется в Double перед операцией, поэтому 1.0/2 дает 0.5.

Вы можете ожидать, что d1 в следующем примере даст 3.4: // Summary1/Truncation.kt fun main() { val d1: Double = 3.0 + 2 / 5 println(d1) val d2: Double = 3 + 2.0 / 5 println(d2) } /* Вывод: 3.0 3.4 */ Из-за порядка вычислений это не так. Kotlin сначала делит 2 на 5, и целочисленная арифметика дает 0, в результате чего получается 3.0. Тот же порядок вычислений действительно дает ожидаемый результат для d2. Деление 2.0 на 5 дает 0.4. Число 3 преобразуется в Double, потому что мы добавляем его к Double (0.4), что дает 3.4.

Понимание порядка вычислений помогает вам расшифровать, что делает программа, как с логическими операциями (булевыми выражениями), так и с математическими операциями. Если вы не уверены в порядке вычислений, используйте скобки, чтобы уточнить свои намерения. Это также делает ваши намерения ясными для тех, кто читает ваш код. AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC Summary1 82

Повторение с помощью while Link to heading

Цикл while продолжается до тех пор, пока управляющее логическое выражение возвращает true: while ( логическое -выражение) { // Код, который будет повторяться } Логическое выражение оценивается один раз в начале цикла и снова перед каждой последующей итерацией. // Summary1/While.kt fun testCondition(i: Int ) = i < 100 fun main() { var i = 0 while (testCondition(i)) { print(".") i += 10 } } /* Вывод: ………. */ Kotlin выводит логический тип как результат для testCondition(). Сокращенные версии операторов присваивания доступны для всех математических операций ( += , -= , = , /= , %= ). Kotlin также поддерживает операторы инкремента и декремента ++ и –, как в префиксной, так и в постфиксной форме. while может использоваться с ключевым словом do: do { // Код, который будет повторяться } while ( логическое -выражение) Переписываем While.kt: AtomicKotlin (www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC Summary1 83 // Summary1/DoWhile.kt fun main() { var i = 0 do { print(".") i += 10 } while (testCondition(i)) } / Вывод: ………. */ Единственное отличие между while и do-while заключается в том, что тело do-while всегда выполняется хотя бы один раз, даже если логическое выражение возвращает false в первый раз.

Циклы и диапазоны Link to heading

Во многих языках программирования индексация в итерируемом объекте осуществляется с помощью целых чисел. В Kotlin оператор for позволяет извлекать элементы непосредственно из итерируемых объектов, таких как диапазоны и строки. Например, этот цикл for выбирает каждый символ в строке “Kotlin”:

// Summary1/StringIteration.kt
fun main() {
    for (c in "Kotlin") {
        print(" $c ")
        // c += 1 // ошибка: 
        // val не может быть переназначен
    }
}
/* Вывод:
K o t l i n
*/

Переменная c не может быть явно определена как var или val — Kotlin автоматически делает её val и выводит её тип как Char (вы можете явно указать тип, но на практике это редко делается).

Вы можете перебирать целочисленные значения, используя диапазоны:

// Summary1/RangeOfInt.kt
fun main() {
    for (i in 1..10) {
        print(" $i ")
    }
}
/* Вывод:
1 2 3 4 5 6 7 8 9 10
*/

Создание диапазона с помощью .. включает оба конца, но until исключает верхнюю границу: 1 until 10 эквивалентно 1..9. Вы можете указать значение шага, используя step: 1..21 step 3.

Ключевое слово in Link to heading

Тот же оператор in, который используется для итерации в цикле for, также позволяет проверять принадлежность к диапазону. Оператор !in возвращает true, если проверяемое значение не находится в диапазоне: // Summary1/Membership.kt fun inNumRange(n: Int) = n in 50..100
fun notLowerCase(ch: Char) = ch !in ‘a’..‘z’
fun main() {
val i1 = 11
val i2 = 100
val c1 = ‘K’
val c2 = ‘k’
println(" $ i1 ${ inNumRange(i1) } “)
println(” $ i2 ${ inNumRange(i2) } “)
println(” $ c1 ${ notLowerCase(c1) } “)
println(” $ c2 ${ notLowerCase(c2) } “)
}
/* Вывод: 11 false AtomicKotlin(www.AtomicKotlin.com) авторы Bruce Eckel и Svetlana Isakova, ©2021 MindView LLC Summary1 85 100 true K true k false */
in также может использоваться для проверки принадлежности к диапазонам с плавающей запятой, хотя такие диапазоны могут быть определены только с помощью .., а не до.

Выражения и операторы Link to heading

Наименьший полезный фрагмент кода в большинстве языков программирования — это либо оператор, либо выражение. У них есть одно основное различие:

• Оператор изменяет состояние.
• Выражение выражает.

То есть выражение производит результат, в то время как оператор — нет. Поскольку оператор не возвращает ничего, он должен изменить состояние своего окружения (то есть создать побочный эффект), чтобы сделать что-то полезное.

Практически все в Kotlin является выражением:

val hours = 10
val minutesPerHour = 60
val minutes = hours * minutesPerHour

В каждом случае всё, что находится справа от =, является выражением, которое производит результат, присваиваемый идентификатору слева.

Функции, такие как println(), не кажутся производящими результат, но поскольку они все еще являются выражениями, они должны что-то возвращать. В Kotlin для этого существует специальный тип Unit:

// Summary1/UnitReturn.kt
fun main() {
    val result = println("возвращает Unit")
    println(result)
}
/* Вывод:
возвращает Unit
kotlin.Unit
*/

Опытные программисты должны перейти к Резюме 2 после выполнения упражнений для этого атома. Упражнения и решения можно найти на www.AtomicKotlin.com.

Раздел II: Введение в Link to heading

Объекты Link to heading

Объекты являются основой для множества современных языков, включая Kotlin. В объектно-ориентированном (ОО) языке программирования вы обнаруживаете «существительные» в решаемой вами задаче и переводите эти существительные в объекты. Объекты хранят данные и выполняют действия. Объектно-ориентированный язык создает и использует объекты. Kotlin не только объектно-ориентированный; он также функциональный. Функциональные языки сосредотачиваются на действиях, которые вы выполняете («глаголы»). Kotlin является гибридным объектно-функциональным языком.

• Этот раздел объясняет основы объектно-ориентированного программирования.
• Раздел IV: Функциональное программирование вводит в функциональное программирование.
• Раздел V: Объектно-ориентированное программирование подробно рассматривает объектно-ориентированное программирование.

Объекты повсюду Link to heading

Объекты хранят данные, используя свойства (val и var), и выполняют операции с этими данными, используя функции.
Некоторые определения:
• Класс: Определяет свойства и функции для того, что по сути является новым типом данных. Классы также называются пользовательскими типами.
• Член: Либо свойство, либо функция класса.
• Член-функция: Функция, которая работает только с конкретным классом объектов.
• Создание объекта: Создание val или var класса. Также называется созданием экземпляра этого класса.
Поскольку классы определяют состояние и поведение, мы можем даже ссылаться на экземпляры встроенных типов, таких как Double или Boolean, как на объекты.
Рассмотрим класс IntRange в Kotlin:

// ObjectsEverywhere/IntRanges.kt
fun main() {
    val r1 = IntRange(0, 10)
    val r2 = IntRange(5, 7)
    println(r1)
    println(r2)
}
/* Вывод:
0..10
5..7
*/

Мы создаем два объекта (экземпляра) класса IntRange. Каждый объект имеет свой собственный участок памяти. IntRange — это класс, но конкретный диапазон r1 от 0 до 10 является объектом, который отличается от диапазона r2.
Для объекта IntRange доступно множество операций. Некоторые из них просты, такие как sum(), а другие требуют большего понимания, прежде чем вы сможете их использовать. Если вы попытаетесь вызвать функцию, которая требует аргументов, IDE запросит эти аргументы.
Чтобы узнать о конкретной член-функции, посмотрите ее в документации Kotlin. Обратите внимание на значок лупы в верхнем правом углу страницы. Нажмите на него и введите IntRange в поле поиска. Нажмите на kotlin.ranges > IntRange из полученного поиска. Вы увидите документацию для класса IntRange. Вы можете изучить все член-функции — интерфейс программирования приложений (API) — этого класса. Хотя вы не поймете большую часть из этого на данный момент, полезно привыкнуть искать информацию в документации Kotlin.
IntRange — это своего рода объект, и определяющей характеристикой объекта является то, что вы выполняете операции с ним. Вместо “выполнения операции” мы говорим “вызов член-функции”. Чтобы вызвать член-функцию для объекта, начните с идентификатора объекта, затем поставьте точку, а затем укажите имя операции:

// ObjectsEverywhere/RangeSum.kt
fun main() {
    val r = IntRange(0, 10)
    println(r.sum())
}
/* Вывод:
55
*/

Поскольку sum() — это член-функция, определенная для IntRange, вы вызываете ее, написав r.sum(). Это суммирует все числа в этом IntRange.
Ранее объектно-ориентированные языки использовали фразу “отправка сообщения”, чтобы описать вызов член-функции для объекта. Иногда вы все еще увидите эту терминологию.
Классы могут иметь множество операций (член-функций). Легко исследовать классы, используя IDE (интегрированную среду разработки), которая включает функцию, называемую автозаполнением кода. Например, если вы наберете .s после идентификатора объекта в IntelliJ IDEA, она покажет все члены этого объекта, которые начинаются с s:
19 https://kotlinlang.org/api/latest/jvm/stdlib/index.html
AtomicKotlin(www.AtomicKotlin.com) by Bruce Eckel & Svetlana Isakova, ©2021 MindView LLC
Объекты повсюду 90
Автозаполнение кода
Попробуйте использовать автозаполнение кода на других объектах. Например, вы можете развернуть строку или преобразовать все символы в нижний регистр:

// ObjectsEverywhere/Strings.kt
fun main() {
    val s = "AbcD"
    println(s.reversed())
    println(s.lowercase())
}
/* Вывод:
DcbA
abcd
*/

Вы можете легко преобразовать строку в целое число и обратно:

// ObjectsEverywhere/Conversion.kt
fun main() {
    val s = "123"
    println(s.toInt())
    val i = 123
    println(i.toString())
}
/* Вывод:
123
123
*/

Позже в книге мы обсудим стратегии обработки ситуаций, когда строка, которую вы хотите преобразовать, не представляет собой корректное целое значение.
Вы также можете преобразовать один числовой тип в другой. Чтобы избежать путаницы, преобразования между числовыми типами являются явными. Например, вы можете преобразовать Int i в Long, вызвав i.toLong(), или в Double с помощью i.toDouble():

// ObjectsEverywhere/NumberConversions.kt
fun fraction(numerator: Long, denom: Long) =
    numerator.toDouble() / denom

fun main() {
    val num = 1
    val den = 2
    val f = fraction(num.toLong(), den.toLong())
    println(f)
}
/* Вывод:
0.5
*/

Хорошо определенные классы легко понять программисту и они производят код, который легко читать.
Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin(www.AtomicKotlin.com) by Bruce Eckel & Svetlana Isakova, ©2021 MindView LLC

Создание классов Link to heading

Вы можете не только использовать предопределенные типы, такие как IntRange и String, но и создавать свои собственные типы объектов. Действительно, создание новых типов составляет большую часть деятельности в объектно-ориентированном программировании. Вы создаете новые типы, определяя классы. Объект — это часть решения проблемы, которую вы пытаетесь решить. Начните с того, чтобы рассматривать объекты как выражение концепций. В качестве первого приближения, если вы обнаружите «вещь» в вашей проблеме, представьте эту вещь как объект в вашем решении.

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

// CreatingClasses/Animals.kt
// Создаем несколько классов:
class Giraffe
class Bear
class Hippo

fun main() {
    // Создаем несколько объектов:
    val g1 = Giraffe()
    val g2 = Giraffe()
    val b = Bear()
    val h = Hippo()
    // Каждый объект() уникален:
    println(g1)
    println(g2)
    println(h)
    println(b)
}
/* Пример вывода:
Giraffe@28d93b30
Giraffe@1b6d3586
Hippo@4554617c
Bear@74a14482
*/

Чтобы определить класс, начните с ключевого слова class, за которым следует идентификатор для вашего нового класса. Имя класса должно начинаться с буквы (A-Z, верхний или нижний регистр), но может включать такие вещи, как цифры и подчеркивания. Следуя общепринятой практике, мы пишем с заглавной буквы первую букву имени класса, а первую букву всех val и var — строчной. Animals.kt начинается с определения трех новых классов, а затем создает четыре объекта (также называемых экземплярами) этих классов. Giraffe — это класс, но конкретный пятилетний самец жирафа, который живет в Ботсване, — это объект. Каждый объект отличается от всех остальных, поэтому мы даем им имена, такие как g1 и g2.

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

Определенные здесь классы (Giraffe, Bear и Hippo) максимально просты: вся определение класса занимает одну строку. Более сложные классы используют фигурные скобки ({ и }) для создания тела класса, содержащего характеристики и поведение для этого класса. Функция, определенная внутри класса, принадлежит этому классу. В Kotlin мы называем эти функции членами класса. Некоторые объектно-ориентированные языки, такие как Java, предпочитают называть их методами, термин, который пришел из ранних объектно-ориентированных языков, таких как Smalltalk. Чтобы подчеркнуть функциональную природу Kotlin, разработчики решили отказаться от термина метод, так как некоторые начинающие программисты находили это различие запутанным. Вместо этого термин функция используется на протяжении всего языка.

Если это однозначно, мы просто скажем «функция». Если нам нужно сделать различие:

• Члены функций принадлежат классу.
• Функции верхнего уровня существуют сами по себе и не являются частью класса.

Вот пример, где bark() принадлежит классу Dog:

// CreatingClasses/Dog.kt
class Dog {
    fun bark() = "гав!"
}

fun main() {
    val dog = Dog()
}

В main() мы создаем объект Dog и присваиваем его переменной val dog. Kotlin выдает предупреждение, потому что мы никогда не используем dog. Члены функций вызываются (инвокируются) с именем объекта, за которым следует точка (.), затем имя функции и список параметров. Здесь мы вызываем функцию meow() и отображаем результат:

// CreatingClasses/Cat.kt
class Cat {
    fun meow() = "мяу!"
}

fun main() {
    val cat = Cat()
    // Вызываем 'meow()' для 'cat':
    val m1 = cat.meow()
    println(m1)
}
/* Вывод:
мяу!
*/

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

При вызове члена функции Kotlin отслеживает интересующий объект, тихо передавая ссылку на этот объект. Эта ссылка доступна внутри члена функции с помощью ключевого слова this. Члены функций имеют специальный доступ к другим элементам внутри класса, просто называя эти элементы. Вы также можете явно квалифицировать доступ к этим элементам, используя this. Здесь exercise() вызывает speak() с и без квалификации:

// CreatingClasses/Hamster.kt
class Hamster {
    fun speak() = "Пи-пи! "
    fun exercise() =
        this.speak() + // Квалифицировано с 'this'
        speak() + // Без 'this'
        "Бег на колесе"
}

fun main() {
    val hamster = Hamster()
    println(hamster.exercise())
}
/* Вывод:
Пи-пи! Пи-пи! Бег на колесе
*/

В exercise() мы сначала вызываем speak() с явным this, а затем опускаем квалификацию. Иногда вы увидите код, содержащий ненужный явный this. Такой код часто исходит от программистов, которые знают другой язык, где this либо требуется, либо является частью его стиля. Использование функции без необходимости сбивает с толку читателя, который тратит время на то, чтобы понять, почему вы это делаете. Мы рекомендуем избегать ненужного использования this.

Снаружи класса вы должны использовать hamster.exercise() и hamster.speak(). Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Свойства Link to heading

Свойство — это var или val, которые являются частью класса. Определение свойства поддерживает состояние внутри класса. Поддержание состояния является основной причиной создания класса, а не просто написания одной или нескольких независимых функций. Свойство var может быть переназначено, в то время как свойство val — нет. Каждый объект получает свое собственное хранилище для свойств:

// Properties/Cup.kt
class Cup {
    var percentFull = 0
}

fun main() {
    val c1 = Cup()
    c1.percentFull = 50
    val c2 = Cup()
    c2.percentFull = 100
    println(c1.percentFull)
    println(c2.percentFull)
}
/* Вывод:
50
100
*/

Определение var или val внутри класса выглядит так же, как и определение их внутри функции. Однако var или val становятся частью этого класса, и вы должны ссылаться на них, указывая его объект с помощью точечной нотации, ставя точку между объектом и именем свойства. Вы можете видеть, как используется точечная нотация для каждой ссылки на percentFull. Свойство percentFull представляет состояние соответствующего объекта Cup. c1.percentFull и c2.percentFull содержат разные значения, показывая, что каждый объект имеет свое собственное хранилище.

Член-функция может ссылаться на свойство внутри своего объекта без использования точечной нотации (то есть без квалификации):

// Properties/Cup2.kt
class Cup2 {
    var percentFull = 0
    val max = 100

    fun add(increase: Int): Int {
        percentFull += increase
        if (percentFull > max)
            percentFull = max
        return percentFull
    }
}

fun main() {
    val cup = Cup2()
    cup.add(50)
    println(cup.percentFull)
    cup.add(70)
    println(cup.percentFull)
}
/* Вывод:
50
100
*/

Функция add() пытается добавить increase к percentFull, но гарантирует, что оно не превысит 100%. Вы должны квалифицировать как свойства, так и член-функции снаружи класса.

Вы можете определить свойства верхнего уровня:

// Properties/TopLevelProperty.kt
val constant = 42
var counter = 0

fun inc() {
    counter++
}

Определение свойства верхнего уровня val безопасно, потому что его нельзя изменить. Однако определение изменяемого (var) свойства верхнего уровня считается антипаттерном. По мере усложнения вашей программы становится труднее правильно рассуждать о совместимом изменяемом состоянии. Если каждый в вашей кодовой базе может получить доступ к var counter, вы не можете гарантировать, что он будет изменяться правильно: пока inc() увеличивает counter на один, какая-то другая часть программы может уменьшить counter на десять, что приведет к неясным ошибкам. Лучше всего защищать изменяемое состояние внутри класса. В разделе “Ограничение видимости” вы увидите, как сделать его действительно скрытым.

Сказать, что var можно изменять, а val — нет, является упрощением. В качестве аналогии рассмотрим дом как val, а диван внутри дома как var. Вы можете изменить диван, потому что это var. Однако вы не можете переназначить дом, потому что это val:

// Properties/ChangingAVal.kt
class House {
    var sofa: String = ""
}

fun main() {
    val house = House()
    house.sofa = "Простой диван-кровать: $89.00"
    println(house.sofa)
    house.sofa = "Новый кожаный диван: $3,099.00"
    println(house.sofa)
    // Нельзя переназначить val на новый House:
    // house = House()
}
/* Вывод:
Простой диван-кровать: $89.00
Новый кожаный диван: $3,099.00
*/

Хотя house является val, его объект может быть изменен, потому что sofa в классе House является var. Определение house как val только предотвращает его переназначение на новый объект.

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

// Properties/AnUnchangingVar.kt
class Sofa {
    val cover: String = "Чехол для дивана"
}

fun main() {
    var sofa = Sofa()
    // Не разрешено:
    // sofa.cover = "Новый чехол"
    // Переназначение var:
    sofa = Sofa()
}

Хотя sofa является var, его объект не может быть изменен, потому что cover в классе Sofa является val. Однако sofa может быть переназначен на новый объект.

Мы говорили о идентификаторах, таких как house и sofa, как будто они были объектами. На самом деле это ссылки на объекты. Один из способов увидеть это — наблюдать, что два идентификатора могут ссылаться на один и тот же объект:

// Properties/References.kt
class Kitchen {
    var table: String = "Круглый стол"
}

fun main() {
    val kitchen1 = Kitchen()
    val kitchen2 = kitchen1
    println("kitchen1: ${kitchen1.table} ")
    println("kitchen2: ${kitchen2.table} ")
    kitchen1.table = "Квадратный стол"
    println("kitchen1: ${kitchen1.table} ")
    println("kitchen2: ${kitchen2.table} ")
}
/* Вывод:
kitchen1: Круглый стол
kitchen2: Круглый стол
kitchen1: Квадратный стол
kitchen2: Квадратный стол
*/

Когда kitchen1 изменяет table, kitchen2 видит это изменение. kitchen1.table и kitchen2.table отображают один и тот же вывод.

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

Изменяемость означает, что объект может изменять свое состояние. В приведенных выше примерах классы House и Kitchen определяют изменяемые объекты, в то время как класс Sofa определяет неизменяемые объекты.

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Конструкторы Link to heading

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

// Constructors/Wombat.kt
class Wombat
fun main() {
    val wombat = Wombat()
}

В main(), вызов Wombat() создает объект Wombat. Если вы приходите из другого объектно-ориентированного языка, вы можете ожидать увидеть здесь ключевое слово new, но new было бы избыточным в Kotlin, поэтому оно было опущено. Вы передаете информацию в конструктор, используя список параметров, так же как и в функции. Здесь конструктор Alien принимает единственный аргумент:

// Constructors/Arg.kt
class Alien(name: String) {
    val greeting = "Poor $name!"
}
fun main() {
    val alien = Alien("Mr. Meeseeks")
    println(alien.greeting)
    // alien.name // Ошибка // [1]
}
/* Вывод:
Poor Mr. Meeseeks!
*/

Создание объекта Alien требует аргумент (попробуйте сделать это без него). name инициализирует свойство greeting внутри конструктора, но оно недоступно вне конструктора — попробуйте раскомментировать строку [1]. Если вы хотите, чтобы параметр конструктора был доступен вне тела класса, определите его как var или val в списке параметров:

// Constructors/VisibleArgs.kt
class MutableNameAlien(var name: String)
class FixedNameAlien(val name: String)
fun main() {
    val alien1 = MutableNameAlien("Reverse Giraffe")
    val alien2 = FixedNameAlien("Krombopulos Michael")
    alien1.name = "Parasite"
    // Нельзя сделать это:
    // alien2.name = "Parasite"
}

Эти определения классов не имеют явных тел классов — тела подразумеваются. Когда name определяется как var или val, он становится свойством и, таким образом, доступен вне конструктора. Параметры конструктора val не могут быть изменены, в то время как параметры конструктора var изменяемы. Ваш класс может иметь множество параметров конструктора:

// Constructors/MultipleArgs.kt
class AlienSpecies(
    val name: String,
    val eyes: Int,
    val hands: Int,
    val legs: Int
) {
    fun describe() =
        "$name with $eyes eyes, " +
        "$hands hands and $legs legs"
}
fun main() {
    val kevin = AlienSpecies("Zigerion", 2, 2, 2)
    val mortyJr = AlienSpecies("Gazorpian", 2, 6, 2)
    println(kevin.describe())
    println(mortyJr.describe())
}
/* Вывод:
Zigerion with 2 eyes, 2 hands and 2 legs
Gazorpian with 2 eyes, 6 hands and 2 legs
*/

В разделе “Сложные конструкторы” вы увидите, что конструкторы также могут содержать сложную логику инициализации. Если объект используется, когда ожидается строка, Kotlin вызывает функцию-член toString() этого объекта. Если вы не напишете одну, вы все равно получите значение по умолчанию для toString():

// Constructors/DisplayAlienSpecies.kt
fun main() {
    val krombopulosMichael = AlienSpecies("Gromflomite", 2, 2, 2)
    println(krombopulosMichael)
}
/* Пример вывода:
AlienSpecies@4d7e1886
*/

Значение по умолчанию для toString() не очень полезно — оно выдает имя класса и физический адрес объекта (это варьируется от одного выполнения программы к другому). Вы можете определить свой собственный toString():

// Constructors/Scientist.kt
class Scientist(val name: String) {
    override fun toString() =
        "Scientist('$name')"
}
fun main() {
    val zeep = Scientist("Zeep Xanflorp")
    println(zeep)
}
/* Вывод:
Scientist('Zeep Xanflorp')
*/

override — это новое для нас ключевое слово. Оно требуется здесь, потому что toString() уже имеет определение, которое выдает примитивный результат. override говорит Kotlin, что да, мы действительно хотим заменить значение по умолчанию для toString() нашим собственным определением. Ясность override проясняет код и предотвращает ошибки. toString(), который отображает содержимое объекта в удобной форме, полезен для поиска и исправления ошибок программирования. Чтобы упростить процесс отладки, IDE предоставляют отладчики, которые позволяют вам наблюдать за каждым шагом выполнения программы и заглядывать внутрь ваших объектов.

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Ограничение видимости Link to heading

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

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

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

Чтобы контролировать видимость, Kotlin и некоторые другие языки предоставляют модификаторы доступа. Создатели библиотек решают, что доступно, а что нет для клиентского программиста, используя модификаторы public, private, protected и internal. Этот раздел охватывает public и private, с кратким введением в internal. Мы объясним protected позже в книге.

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

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

private классы, функции верхнего уровня и свойства верхнего уровня доступны только внутри этого файла:

// Visibility/RecordAnimals.kt
private var index = 0 // [1]
private class Animal (val name: String) // [2]
private fun recordAnimal( // [3]
    animal: Animal
) {
    println("Animal #$index: ${animal.name}")
    index++
}
fun recordAnimals() {
    recordAnimal(Animal("Tiger"))
    recordAnimal(Animal("Antelope"))
}
fun recordAnimalsCount() {
    println("$index animals are here!")
}

Вы можете получить доступ к private свойствам верхнего уровня ( [1] ), классам ( [2] ) и функциям ( [3] ) из других функций и классов внутри RecordAnimals.kt. Kotlin предотвращает доступ к private элементам верхнего уровня из другого файла, сообщая вам, что это private в файле:

// Visibility/ObserveAnimals.kt
fun main() {
    // Нельзя получить доступ к private членам,
    // объявленным в другом файле.
    // Класс является private:
    // val rabbit = Animal("Rabbit")
    // Функция является private:
    // recordAnimal(rabbit)
    // Свойство является private:
    // index++
    recordAnimals()
    recordAnimalsCount()
}
/* Вывод:
Animal #0: Tiger
Animal #1: Antelope
2 animals are here!
*/

Часто private используется для членов класса:

// Visibility/Cookie.kt
class Cookie (
    private var isReady: Boolean // [1]
) {
    private fun crumble() = // [2]
        println("crumble")
    public fun bite() = // [3]
        println("bite")
    fun eat() { // [4]
        isReady = true // [5]
        crumble()
        bite()
    }
}
fun main() {
    val x = Cookie(false)
    x.bite()
    // Нельзя получить доступ к private членам:
    // x.isReady
    // x.crumble()
    x.eat()
}
/* Вывод:
bite
crumble
bite
*/

• [1] private свойство, недоступное вне содержащего класса.
• [2] private член-функция.
• [3] public член-функция, доступная любому.
• [4] Отсутствие модификатора доступа означает public.
• [5] Только члены одного и того же класса могут получать доступ к private членам.

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

Любая член-функция, которая является вспомогательной функцией для класса, может быть сделана private, чтобы гарантировать, что вы случайно не используете ее в другом месте в пакете и тем самым не запрещаете себе изменять или удалять эту функцию. То же самое верно и для private свойства внутри класса. Если вам не нужно раскрывать основную реализацию (что менее вероятно, чем вы могли бы подумать), сделайте свойства private. Однако просто потому, что ссылка на объект является private внутри класса, это не означает, что какой-то другой объект не может иметь публичную ссылку на тот же объект:

// Visibility/MultipleRef.kt
class Counter (var start: Int) {
    fun increment() {
        start += 1
    }
    override fun toString() = start.toString()
}
class CounterHolder (counter: Counter) {
    private val ctr = counter
    override fun toString() =
        "CounterHolder: " + ctr
}
fun main() {
    val c = Counter(11) // [1]
    val ch = CounterHolder(c) // [2]
    println(ch)
    c.increment() // [3]
    println(ch)
    val ch2 = CounterHolder(Counter(9)) // [4]
    println(ch2)
}
/* Вывод:
CounterHolder: 11
CounterHolder: 12
CounterHolder: 9
*/

• [1] c теперь определен в области, окружающей создание объекта CounterHolder на следующей строке.
• [2] Передача c в качестве аргумента конструктору CounterHolder означает, что новый CounterHolder теперь ссылается на тот же объект Counter, на который ссылается c.
• [3] Counter, который предположительно является private внутри ch, все еще может быть изменен через c.
• [4] Counter(9) не имеет других ссылок, кроме как внутри CounterHolder, поэтому его нельзя получить или изменить ничем, кроме ch2.

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

Модули Link to heading

В отличие от небольших примеров в этой книге, реальные программы часто бывают большими. Полезно делить такие программы на один или несколько модулей. Модуль — это логически независимая часть кодовой базы. То, как вы делите проект на модули, зависит от системы сборки (например, Gradle22 или Maven23) и выходит за рамки этой книги.

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

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

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.
22 https://gradle.org/
23 https://maven.apache.org/
AtomicKotlin (www.AtomicKotlin.com) Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Пакеты Link to heading

Фундаментальным принципом программирования является акроним DRY: Не Повторяй Себя. Несколько идентичных фрагментов кода требуют обслуживания каждый раз, когда вы вносите исправления или улучшения. Поэтому дублирование кода — это не просто лишняя работа: каждое дублирование создает возможности для ошибок. Ключевое слово import повторно использует код из других файлов. Один из способов использования import — указать имя класса, функции или свойства: import packagename.ClassName import packagename.functionName import packagename.propertyName Пакет — это связанная коллекция кода. Каждый пакет обычно предназначен для решения конкретной задачи и часто содержит несколько функций и классов. Например, мы можем импортировать математические константы и функции из библиотеки kotlin.math: // Packages/ImportClass.kt import kotlin.math.PI import kotlin.math.cos // Косинус fun main() { println(PI) println(cos(PI)) println(cos(2 * PI)) } /* Вывод: 3.141592653589793 -1.0 1.0 / Иногда вам нужно использовать несколько сторонних библиотек, содержащих классы или функции с одинаковыми именами. Ключевое слово as позволяет вам изменить имена при импорте: // Packages/ImportNameChange.kt import kotlin.math.PI as circleRatio import kotlin.math.cos as cosine fun main() { println(circleRatio) println(cosine(circleRatio)) println(cosine(2 * circleRatio)) } / Вывод: 3.141592653589793 -1.0 1.0 / as полезно, если имя библиотеки выбрано неудачно или слишком длинное. Вы можете полностью квалифицировать импорт в теле вашего кода. В следующем примере код может быть менее читаемым из-за явных имен пакетов, но происхождение каждого элемента абсолютно ясно: // Packages/FullyQualify.kt fun main() { println(kotlin.math.PI) println(kotlin.math.cos(kotlin.math.PI)) println(kotlin.math.cos(2 * kotlin.math.PI)) } / Вывод: 3.141592653589793 -1.0 1.0 / Чтобы импортировать все из пакета, используйте звездочку: AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC // Packages/ImportEverything.kt import kotlin.math. fun main() { println(E) println(E.roundToInt()) println(E.toInt()) } /* Вывод: 2.718281828459045 3 2 / Пакет kotlin.math содержит удобный метод roundToInt(), который округляет значение типа Double до ближайшего целого числа, в отличие от toInt(), который просто отсекает все после десятичной точки. Чтобы повторно использовать ваш код, создайте пакет с помощью ключевого слова package. Оператор package должен быть первым некомментарий оператором в файле. После package следует имя вашего пакета, которое по соглашению пишется строчными буквами: // Packages/PythagoreanTheorem.kt package pythagorean import kotlin.math.sqrt class RightTriangle ( val a: Double , val b: Double ) { fun hypotenuse() = sqrt(a * a + b * b) fun area() = a * b / 2 } Вы можете назвать файл исходного кода как угодно, в отличие от Java, которая требует, чтобы имя файла совпадало с именем класса. Kotlin позволяет вам выбирать любое имя для вашего пакета, но считается хорошим стилем, если имя пакета совпадает с именем директории, в которой находятся файлы пакета (это не всегда будет так для примеров в этой книге). Элементы в пакете pythagorean теперь доступны с помощью import: // Packages/ImportPythagorean.kt import pythagorean.RightTriangle fun main() { val rt = RightTriangle(3.0, 4.0) println(rt.hypotenuse()) println(rt.area()) } / Вывод: 5.0 6.0 */ В оставшейся части этой книги мы используем операторы package для любого файла, который определяет функции, классы и т. д., вне main(), чтобы предотвратить конфликты имен с другими файлами в книге, но обычно мы не будем помещать оператор package в файл, который содержит только main(). Упражнения и решения можно найти на www.AtomicKotlin.com. AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Тестирование Link to heading

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

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

Использование println() для проверки корректности кода — это слабый подход: вам нужно каждый раз внимательно проверять вывод и сознательно удостоверяться, что он правильный.

Чтобы упростить ваш опыт работы с этой книгой, мы создали нашу собственную небольшую систему тестирования. Цель — минимальный подход, который:

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

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

• JUnit — один из самых популярных тестовых фреймворков для Java и легко используется из Kotlin.
• Kotest разработан специально для Kotlin и использует возможности языка Kotlin.
• Spek Framework производит другую форму тестирования, называемую Спецификационным тестированием.

Чтобы использовать наш тестовый фреймворк, мы сначала должны его импортировать. Основные элементы фреймворка — это eq (равно) и neq (не равно):

// Testing/TestingExample.kt
import atomictest.*

fun main() {
    val v1 = 11
    val v2 = "Ontology"
    // 'eq' означает "равно":
    v1 eq 11
    v2 eq "Ontology"
    // 'neq' означает "не равно"
    v2 neq "Epistemology"
    // [Ошибка] Epistemology != Ontology
    // v2 eq "Epistemology"
}

/* Вывод:
11
Ontology
Ontology
*/

Код для пакета atomictest находится в Приложении A: AtomicTest. Мы не предполагаем, что вы поймете все в AtomicTest.kt прямо сейчас, потому что он использует некоторые функции, которые появятся позже в книге.

Чтобы создать чистый и удобный вид, AtomicTest использует функцию Kotlin, которую вы еще не видели: возможность записывать вызов функции в текстовом виде a.function(b) в форме a function b. Это называется инфиксной нотацией. Только функции, определенные с использованием ключевого слова infix, могут быть вызваны таким образом. AtomicTest.kt определяет инфиксные функции eq и neq, используемые в TestingExample.kt:

expression eq expected
expression neq expected

eq и neq являются гибкими — почти все работает как тестовое выражение. Если expected является строкой, то expression преобразуется в строку, и две строки сравниваются. В противном случае expression и expected сравниваются напрямую (без предварительного преобразования). В любом случае результат expression отображается на консоли, так что вы видите что-то, когда программа выполняется. Даже когда тесты проходят успешно, вы все равно видите результат слева от eq или neq. Если expression и expected не эквивалентны, AtomicTest показывает ошибку, когда программа выполняется.

Последний тест в TestingExample.kt намеренно не проходит, чтобы вы увидели пример вывода ошибки. Если два значения не равны, Kotlin отображает соответствующее сообщение, начинающееся с [Ошибка]. Если вы раскомментируете последнюю строку и запустите пример выше, вы увидите, после всех успешных тестов:

[Ошибка] Epistemology != Ontology

Фактическое значение, хранящееся в v2, не соответствует тому, что утверждается в выражении “ожидаемое”. AtomicTest отображает строковые представления как ожидаемых, так и фактических значений.

eq и neq — это основные (инфиксные) функции, определенные для AtomicTest — это действительно минимальная тестовая система. Когда вы вставляете выражения eq и neq в свои примеры, вы создаете как тест, так и некоторый вывод в консоль. Вы проверяете корректность программы, запуская ее.

В AtomicTest есть второй инструмент. Объект trace захватывает вывод для последующего сравнения:

// Testing/Trace1.kt
import atomictest.*

fun main() {
    trace("line 1")
    trace(47)
    trace("line 2")
    trace eq """
    line 1
    47
    line 2
    """
}

Добавление результатов в trace выглядит как вызов функции, так что вы можете эффективно заменить println() на trace().

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

С этого момента мы редко используем закомментированные блоки вывода, потому что AtomicTest сделает все за нас. Однако иногда мы все же включаем закомментированные блоки вывода, когда это дает более полезный эффект.

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

Тестирование как часть программирования Link to heading

Тестирование наиболее эффективно, когда оно встроено в процесс разработки программного обеспечения. Написание тестов гарантирует, что вы получите ожидаемые результаты. Многие специалисты рекомендуют писать тесты до написания кода реализации — вы сначала заставляете тест не проходить, прежде чем напишете код, который его пройдет. Эта техника, называемая Разработкой через Тестирование (TDD), является способом убедиться, что вы действительно тестируете то, что думаете. Более полное описание TDD можно найти на Wikipedia (поиск по запросу “TestDrivenDevelopment”).

Существует еще одно преимущество написания тестируемого кода — это меняет способ, которым вы создаете свой код. Вы могли бы просто выводить результаты на консоль. Но в тестовом мышлении вы задаетесь вопросом: “Как я это протестирую?” Когда вы создаете функцию, вы решаете, что должны вернуть что-то из функции, если не по другой причине, то чтобы протестировать этот результат. Функции, которые делают только то, что принимают входные данные и производят выходные данные, как правило, приводят к лучшим проектам.

Вот упрощенный пример использования TDD для реализации расчета ИМТ (индекса массы тела) из раздела “Типы чисел”. Сначала мы пишем тесты вместе с начальной реализацией, которая не проходит (поскольку мы еще не реализовали функциональность):

// Testing/TDDFail.kt
package testing1
import atomictest.eq

fun main() {
    calculateBMI(160, 68) eq "Normal weight"
    // calculateBMI(100, 68) eq "Underweight"
    // calculateBMI(200, 68) eq "Overweight"
}

fun calculateBMI(lbs: Int, height: Int) = "Normal weight"

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

// Testing/TDDStillFails.kt
package testing2
import atomictest.eq

fun main() {
    // Все тесты не проходят:
    // calculateBMI(160, 68) eq "Normal weight"
    // calculateBMI(100, 68) eq "Underweight"
    // calculateBMI(200, 68) eq "Overweight"
}

fun calculateBMI(
    lbs: Int,
    height: Int
): String {
    val bmi = lbs / (height * height) * 703.07
    return if (bmi < 18.5) "Underweight"
    else if (bmi < 25) "Normal weight"
    else "Overweight"
}

Мы используем Int вместо Double, что приводит к нулевому результату. Тесты направляют нас к исправлению:

// Testing/TDDWorks.kt
package testing3
import atomictest.eq

fun main() {
    calculateBMI(160.0, 68.0) eq "Normal weight"
    calculateBMI(100.0, 68.0) eq "Underweight"
    calculateBMI(200.0, 68.0) eq "Overweight"
}

fun calculateBMI(
    lbs: Double,
    height: Double
): String {
    val bmi = lbs / (height * height) * 703.07
    return if (bmi < 18.5) "Underweight"
    else if (bmi < 25) "Normal weight"
    else "Overweight"
}

Вы можете выбрать добавление дополнительных тестов для граничных условий. В упражнениях для этой книги мы включаем тесты, которые ваш код должен пройти. Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Исключения Link to heading

Слово “исключение” используется в том же смысле, что и фраза “Я возражаю против этого”. Исключительное состояние предотвращает продолжение текущей функции или области. В момент, когда возникает проблема, вы можете не знать, что с ней делать, но не можете продолжать в текущем контексте. У вас недостаточно информации, чтобы исправить проблему. Поэтому вы должны остановиться и передать проблему в другой контекст, который сможет предпринять соответствующие действия. Этот атом охватывает основы исключений как механизма отчетности об ошибках. В разделе VI: Предотвращение сбоев мы рассмотрим другие способы решения проблем.

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

Рассмотрим функцию toInt(), которая преобразует строку в целое число. Что произойдет, если вы вызовете эту функцию для строки, которая не содержит целочисленного значения?

// Exceptions/ToIntException.kt
package exceptions

fun erroneousCode() {
    // Раскомментируйте эту строку, чтобы получить исключение:
    // val i = "1$".toInt() // [1]
}

fun main() {
    erroneousCode()
}

Раскомментирование строки [1] вызывает исключение. Здесь неудачная строка закомментирована, чтобы не остановить сборку книги, которая проверяет, компилируется ли каждый пример и работает ли он как ожидалось.

Когда исключение выбрасывается, путь выполнения — тот, который нельзя продолжить — останавливается, и объект исключения выталкивается из текущего контекста. Здесь он выходит из контекста erroneousCode() и переходит в контекст main(). В этом случае Kotlin просто сообщает об ошибке; программист, предположительно, допустил ошибку и должен исправить код.

Когда исключение не перехватывается, программа прерывается и отображает трассировку стека, содержащую подробную информацию. Раскомментирование строки [1] в ToIntException.kt приводит к следующему выводу:

Exception in thread "main" java.lang.NumberFormatException: For input string: "1$"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Integer.parseInt(Integer.java:580)
at java.lang.Integer.parseInt(Integer.java:615)
at ToIntExceptionKt.erroneousCode(at ToIntException.kt:6)
at ToIntExceptionKt.main(at ToIntException.kt:10)

Трассировка стека дает детали, такие как файл и строка, где произошло исключение, так что вы можете быстро обнаружить проблему. Последние две строки показывают проблему: в строке 10 функции main() мы вызываем erroneousCode(). Затем, более точно, в строке 6 функции erroneousCode() мы вызываем toInt().

Чтобы избежать комментирования и раскомментирования кода для отображения исключений, мы используем функцию capture() из пакета AtomicTest:

// Exceptions/IntroducingCapture.kt
import atomictest.*

fun main() {
    capture {
        "1$".toInt()
    } eq "NumberFormatException: " +
    """For input string: "1$""""
}

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

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

Стандартная библиотека Kotlin содержит String.toIntOrNull(), которая выполняет преобразование, если строка содержит целое число, или возвращает null, если преобразование невозможно — null является простым способом указать на сбой:

// Exceptions/IntroducingNull.kt
import atomictest.eq

fun main() {
    "1$".toIntOrNull() eq null
}

Предположим, мы рассчитываем средний доход за период месяцев:

// Exceptions/AverageIncome.kt
package firstversion

import atomictest.*

fun averageIncome(income: Int, months: Int) =
    income / months

fun main() {
    averageIncome(3300, 3) eq 1100
    capture {
        averageIncome(5000, 0)
    } eq "ArithmeticException: / by zero"
}

Если months равен нулю, деление в averageIncome() вызывает ArithmeticException. К сожалению, это не говорит нам ничего о том, почему произошла ошибка, что означает делитель и может ли он законно быть равен нулю в первую очередь. Это явно ошибка в коде — averageIncome() должен справляться с нулевыми месяцами таким образом, чтобы предотвратить ошибку деления на ноль.

Давайте изменим averageIncome(), чтобы предоставить больше информации о источнике проблемы. Если months равен нулю, мы не можем вернуть обычное целое значение в качестве результата. Одна из стратегий — вернуть null:

// Exceptions/AverageIncomeWithNull.kt
package withnull

import atomictest.eq

fun averageIncome(income: Int, months: Int) =
    if (months == 0)
        null
    else
        income / months

fun main() {
    averageIncome(3300, 3) eq 1100
    averageIncome(5000, 0) eq null
}

Если функция может вернуть null, Kotlin требует, чтобы вы проверили результат перед его использованием (это рассматривается в “Nullable Types”). Даже если вы хотите просто отобразить вывод пользователю, лучше сказать: “Не прошло полных месяцев”, чем “Ваш средний доход за период: null.”

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

// Exceptions/AverageIncomeWithException.kt
package properexception

import atomictest.*

fun averageIncome(income: Int, months: Int) =
    if (months == 0)
        throw IllegalArgumentException( // [1]
            "Months can't be zero")
    else
        income / months

fun main() {
    averageIncome(3300, 3) eq 1100
    capture {
        averageIncome(5000, 0)
    } eq "IllegalArgumentException: " +
    "Months can't be zero"
}

• [1] При выбрасывании исключения ключевое слово throw следует за исключением, которое должно быть выброшено, вместе с любыми аргументами, которые могут понадобиться. Здесь мы используем стандартный класс исключения IllegalArgumentException.

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

Упражнения и решения можно найти на www.AtomicKotlin.com.

Списки Link to heading

Список — это контейнер, который является объектом, содержащим другие объекты. Контейнеры также называются коллекциями. Когда нам нужен базовый контейнер для примеров в этой книге, мы обычно используем список. Списки являются частью стандартных пакетов Kotlin, поэтому они не требуют импорта. Следующий пример создает список, заполненный целыми числами (Int), вызывая стандартную библиотечную функцию listOf() с начальными значениями:

// Lists/Lists.kt
import atomictest.eq

fun main() {
    val ints = listOf(99, 3, 5, 7, 11, 13)
    ints eq "[99, 3, 5, 7, 11, 13]" // [1]
    // Выбор каждого элемента в списке:
    var result = ""
    for (i in ints) { // [2]
        result += " $i "
    }
    result eq "99 3 5 7 11 13"
    // "Индексация" в списке:
    ints[4] eq 11 // [3]
}

• [1] Список использует квадратные скобки при отображении.
• [2] Циклы for хорошо работают со списками: for(i in ints) означает, что i получает каждое значение из ints. Вам не нужно объявлять val i или задавать ему тип; Kotlin знает из контекста, что i является идентификатором цикла for.
• [3] Квадратные скобки индексируют список. Список сохраняет свои элементы в порядке инициализации, и вы выбираете их по номеру. Как и в большинстве языков программирования, Kotlin начинает индексацию с нуля, что в этом случае дает значение 99. Таким образом, индекс 4 дает значение 11.

Забывание о том, что индексация начинается с нуля, приводит к так называемой ошибке “off-by-one”. В языке, таком как Kotlin, мы часто не выбираем элементы по одному, а вместо этого проходим через весь контейнер, используя in. Это устраняет ошибки “off-by-one”. Если вы используете индекс, выходящий за пределы последнего элемента в списке, Kotlin выбрасывает исключение ArrayIndexOutOfBoundsException:

// Lists/OutOfBounds.kt
import atomictest.*

fun main() {
    val ints = listOf(1, 2, 3)
    capture {
        ints[3]
    } contains listOf("ArrayIndexOutOfBoundsException")
}

Список может содержать все разные типы. Вот список из чисел с плавающей запятой (Double) и список строк (String):

// Lists/ListUsefulFunction.kt
import atomictest.eq

fun main() {
    val doubles = listOf(1.1, 2.2, 3.3, 4.4)
    doubles.sum() eq 11.0
    val strings = listOf("Twas", "Brillig", "And", "Slithy", "Toves")
    strings eq listOf("Twas", "Brillig", "And", "Slithy", "Toves")
    strings.sorted() eq listOf("And", "Brillig", "Slithy", "Toves", "Twas")
    strings.reversed() eq listOf("Toves", "Slithy", "And", "Brillig", "Twas")
    strings.first() eq "Twas"
    strings.takeLast(2) eq listOf("Slithy", "Toves")
}

Это демонстрирует некоторые операции со списками. Обратите внимание на название “sorted” вместо “sort”. Когда вы вызываете sorted(), он создает новый список, содержащий те же элементы, что и старый, в отсортированном порядке — но оставляет оригинальный список без изменений. Называя его “sort”, подразумевается, что оригинальный список изменяется напрямую (т.е. сортируется на месте). На протяжении всего Kotlin вы видите эту тенденцию “оставлять оригинальный объект без изменений и создавать новый объект”. reversed() также создает новый список.

Параметризованные типы Link to heading

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

// Lists/ParameterizedTypes.kt
import atomictest.eq

fun main() {
    // Тип выводится автоматически:
    val numbers = listOf(1, 2, 3)
    val strings = listOf("one", "two", "three")
    
    // Точно так же, но с явным указанием типа:
    val numbers2: List<Int> = listOf(1, 2, 3)
    val strings2: List<String> = listOf("one", "two", "three")
    
    numbers eq numbers2
    strings eq strings2
}

Kotlin использует значения инициализации, чтобы вывести, что numbers содержит List целых чисел (Int), в то время как strings содержит List строк (String). numbers2 и strings2 — это версии с явным указанием типа для numbers и strings, созданные путем добавления объявлений типов List<Int> и List<String>. Вы, возможно, видели угловые скобки раньше — они обозначают параметр типа, позволяя вам сказать: «этот контейнер содержит объекты ‘параметра’». Мы произносим List<Int> как «список целых чисел».

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

// Lists/ParameterizedReturn.kt
package lists

import atomictest.eq

// Возвращаемый тип выводится автоматически:
fun inferred(p: Char, q: Char) = listOf(p, q)

// Явный возвращаемый тип:
fun explicit(p: Char, q: Char): List<Char> = listOf(p, q)

fun main() {
    inferred('a', 'b') eq "[a, b]"
    explicit('y', 'z') eq "[y, z]"
}

Kotlin выводит возвращаемый тип для inferred(), в то время как explicit() указывает тип возвращаемого значения функции. Вы не можете просто сказать, что она возвращает List; Kotlin будет жаловаться, поэтому вы должны также указать параметр типа. Когда вы указываете возвращаемый тип функции, Kotlin обеспечивает соблюдение вашего намерения.

Списки только для чтения и изменяемые списки Link to heading

Если вы явно не укажете, что хотите изменяемый список, вы его не получите. listOf() создает список только для чтения, который не имеет функций изменения. Если вы создаете список постепенно (то есть у вас нет всех элементов на момент создания), используйте mutableListOf(). Это создаст изменяемый список, который можно модифицировать:

// Lists/MutableList.kt
import atomictest.eq

fun main() {
    val list = mutableListOf<Int>()
    list.add(1)
    list.addAll(listOf(2, 3))
    list += 4
    list += listOf(5, 6)
    list eq listOf(1, 2, 3, 4, 5, 6)
}

Поскольку у списка нет начальных элементов, мы должны указать Kotlin, какого типа он, предоставив спецификацию <Int> в вызове mutableListOf(). Вы можете добавлять элементы в изменяемый список, используя add() и addAll(), или оператор +=, который добавляет либо один элемент, либо другую коллекцию.

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

// Lists/MutListIsList.kt
package lists

import atomictest.eq

fun makeList(): List<Int> = mutableListOf(1, 2, 3)

fun main() {
    // makeList() создает список только для чтения:
    val list = makeList()
    // list.add(3) // Неразрешенная ссылка: add
    list eq listOf(1, 2, 3)
}

Список не имеет функций изменения, несмотря на то, что он изначально был создан с использованием mutableListOf() внутри makeList(). Обратите внимание, что тип результата makeList() — List<Int>. Исходный объект все еще является изменяемым списком, но он рассматривается через призму списка.

Список является только для чтения — вы можете читать его содержимое, но не записывать в него. Если базовая реализация является изменяемым списком и вы сохраняете изменяемую ссылку на эту реализацию, вы все равно можете модифицировать его через эту изменяемую ссылку, и любые ссылки только для чтения увидят эти изменения. Это еще один пример алиасинга, введенного в разделе “Ограничение видимости”:

// Lists/MultipleListRefs.kt
import atomictest.eq

fun main() {
    val first = mutableListOf(1)
    val second: List<Int> = first
    second eq listOf(1)
    first.add(2)
    // second видит изменение:
    second eq listOf(1, 2)
}

first — это неизменяемая ссылка (val) на изменяемый объект, созданный с помощью mutableListOf(1). Когда second ссылается на first, он становится представлением того же объекта. second является только для чтения, потому что List<Int> не включает функции изменения. Без явного объявления типа List<Int> Kotlin бы вывел, что second также является ссылкой на изменяемый объект.

Мы можем добавить элемент (2) в объект, потому что first является ссылкой на изменяемый список. Обратите внимание, что second наблюдает за этими изменениями — он не может изменить список, хотя список изменяется через first.

Загадка с += Link to heading

Оператор += может создать иллюзию того, что неизменяемый список на самом деле изменяемый:
AtomicKotlin (www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC
Списки 132

// Lists/ApparentlyMutableList.kt
import atomictest.eq

fun main() {
    var list = listOf('X') // Неизменяемый
    list += 'Y' // Кажется, что он изменяемый
    list eq "[X, Y]"
}

Функция listOf() создает неизменяемый список, но list += ‘Y’ кажется, что модифицирует этот список. Нарушает ли += как-то неизменяемость?
Это происходит только потому, что list является var. Вот более детальный пример, который показывает различные комбинации изменяемых/неизменяемых списков с val/var:

// Lists/PlusAssignPuzzle.kt
import atomictest.eq

fun main() {
    // Изменяемый список, присвоенный 'val'/'var':
    val list1 = mutableListOf('A') // или 'var'
    list1 += 'A' // То же самое, что и:
    list1.plusAssign('A') // [1]
    
    // Неизменяемый список, присвоенный 'val':
    val list2 = listOf('B')
    // list2 += 'B' // То же самое, что и:
    // list2 = list2 + 'B' // [2]
    
    // Неизменяемый список, присвоенный 'var':
    var list3 = listOf('C')
    list3 += 'C' // То же самое, что и:
    val newList = list3 + 'C' // [3]
    list3 = newList // [4]
    
    list1 eq "[A, A, A]"
    list2 eq "[B]"
    list3 eq "[C, C, C]"
}

• [1] list1 ссылается на изменяемый объект, который, следовательно, может быть изменен на месте. Компилятор переводит += в вызов plusAssign(). Не имеет значения, является ли list1 val или var, потому что после создания ничего не переназначается в list1 — он всегда ссылается на один и тот же изменяемый список. Сделайте его var, и IntelliJ укажет, что он никогда не меняется, и предложит сделать его val.
• [2] Это пытается создать новый список, комбинируя list2 и ‘B’, но не может переназначить этот новый список в list2, потому что list2 является val. Без возможности выполнить это переназначение += не может быть скомпилирован.
• [3] Создает newList, не модифицируя существующий неизменяемый список, на который ссылается list3.
• [4] Поскольку list3 является var, компилятор присваивает newList обратно в list3. Предыдущие содержимое list3 затем забывается, и кажется, что list3 был изменен. На самом деле старый list3 был утилизирован и заменен вновь созданным newList, создавая иллюзию, что list3 изменяемый.
Это поведение += также происходит с другими коллекциями. Результирующая путаница — еще одна причина выбрать val вместо var для ваших идентификаторов.
Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin (www.AtomicKotlin.com) авторы Брюс Эккель и Светлана Исакова, ©2021 MindView LLC

Списки переменных аргументов Link to heading

Ключевое слово vararg создает список аргументов переменной длины. В разделе “Списки” мы представили функцию listOf(), которая принимает любое количество параметров и возвращает List: // Varargs/ListOf.kt import atomictest.eq
fun main() {
listOf(1) eq “[1]”
listOf(“a”, “b”) eq “[a, b]”
}
Используя ключевое слово vararg, вы можете определить функцию, которая принимает любое количество аргументов, так же как это делает listOf(). vararg является сокращением для “список переменных аргументов”: // Varargs/VariableArgList.kt package varargs
fun v(s: String, vararg d: Double) {}
fun main() {
v(“abc”, 1.0, 2.0)
v(“def”, 1.0, 2.0, 3.0, 4.0)
v(“ghi”, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
}
В определении функции может быть указан только один параметр как vararg. Хотя возможно указать любой элемент в списке параметров как vararg, обычно проще сделать это для последнего.
vararg позволяет передавать любое количество (включая ноль) аргументов. Все аргументы должны быть указанного типа. Аргументы vararg доступны с использованием имени параметра, которое становится массивом: // Varargs/VarargSum.kt package varargs
import atomictest.eq
fun sum(vararg numbers: Int): Int {
var total = 0
for (n in numbers) {
total += n
}
return total
}
fun main() {
sum(13, 27, 44) eq 84
sum(1, 3, 5, 7, 9, 11) eq 36
sum() eq 0
}
Хотя массивы (Array) и списки (List) выглядят похоже, они реализованы по-разному — List является обычным классом библиотеки, в то время как Array имеет специальную поддержку на низком уровне. Массивы необходимы для совместимости с другими языками, особенно с Java.
В повседневном программировании используйте List, когда вам нужна простая последовательность. Используйте массивы только тогда, когда сторонний API требует массив, или когда вы работаете с vararg.
В большинстве случаев вы можете просто игнорировать тот факт, что vararg создает массив, и обращаться с ним так, как если бы это был List: // Varargs/VarargLikeList.kt package varargs
import atomictest.eq
fun evaluate(vararg ints: Int) =
“Size: ${ ints.size } \n” +
“Sum: ${ ints.sum() } \n” +
“Average: ${ ints.average() } "
fun main() {
evaluate(10, -3, 8, 1, 9) eq "””
Size: 5
Sum: 25
Average: 5.0
"""
}
Вы можете передавать массив элементов туда, где принимается vararg. Чтобы создать массив, используйте arrayOf() так же, как вы используете listOf(). Массив всегда изменяемый. Чтобы преобразовать массив в последовательность аргументов (а не только в один элемент типа Array), используйте оператор распаковки *: // Varargs/SpreadOperator.kt import varargs.sum
import atomictest.eq
fun main() {
val array = intArrayOf(4, 5)
sum(1, 2, 3, *array, 6) eq 21 // [1]
// Не компилируется:
// sum(1, 2, 3, array, 6)
val list = listOf(9, 10, 11)
sum(*list.toIntArray()) eq 30 // [2]
}
Если вы передаете массив примитивных типов (таких как Int, Double или Boolean), как в приведенном выше примере, функция создания массива должна быть конкретно типизирована. Если вы используете arrayOf(4, 5) вместо intArrayOf(4, 5), строка [1] вызовет ошибку, сообщающую, что ожидается IntArray, но был получен Array<Int>.
Оператор распаковки работает только с массивами. Если у вас есть List, который вы хотите передать в качестве последовательности аргументов, сначала преобразуйте его в массив, а затем примените оператор распаковки, как в [2]. Поскольку результатом является массив примитивного типа, мы снова должны использовать конкретную функцию преобразования toIntArray().
Оператор распаковки особенно полезен, когда вам нужно передать аргументы vararg в другую функцию, которая также ожидает vararg: // Varargs/TwoFunctionsWithVarargs.kt package varargs
import atomictest.eq
fun first(vararg numbers: Int): String {
var result = ""
for (i in numbers) {
result += “[ $ i]”
}
return result
}
fun second(vararg numbers: Int) =
first(*numbers)
fun main() {
second(7, 9, 32) eq “[7][9][32]”
}

Аргументы командной строки Link to heading

При вызове программы из командной строки вы можете передать ей переменное количество аргументов. Чтобы захватить аргументы командной строки, вы должны предоставить определённый параметр для main():

// Varargs/MainArgs.kt
fun main(args: Array< String >) {
    for (a in args) {
        println(a)
    }
}

Параметр традиционно называется args (хотя вы можете назвать его как угодно), а тип для args может быть только Array (массив строк). Если вы используете IntelliJ IDEA, вы можете передать аргументы программы, отредактировав соответствующую “Конфигурацию запуска”, как показано в последнем упражнении для этого атома.

Вы также можете использовать компилятор kotlinc для создания программы командной строки. Если kotlinc не установлен на вашем компьютере, следуйте инструкциям на главном сайте Kotlin. После того как вы ввели и сохранили код для MainArgs.kt, введите следующее в командной строке:

kotlinc MainArgs.kt

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

kotlin MainArgsKt hamster 42 3.14159

Вы увидите следующий вывод:

hamster
42
3.14159

Если вы хотите преобразовать строковый параметр в конкретный тип, Kotlin предоставляет функции преобразования, такие как toInt() для преобразования в Int и toFloat() для преобразования в Float. Использование этих функций предполагает, что аргументы командной строки появляются в определённом порядке. Здесь программа ожидает строку, за которой следует что-то, что можно преобразовать в Int, а затем что-то, что можно преобразовать в Float:

// Varargs/MainArgConversion.kt
fun main(args: Array< String >) {
    if (args.size < 3) return
    val first = args[0]
    val second = args[1].toInt()
    val third = args[2].toFloat()
    println(" $first $second $third")
}

Первая строка в main() завершает программу, если недостаточно аргументов. Если вы не предоставите что-то, что можно преобразовать в Int и Float в качестве второго и третьего аргументов командной строки, вы увидите ошибки во время выполнения (попробуйте, чтобы увидеть ошибки). Скомпилируйте и запустите MainArgConversion.kt с теми же аргументами командной строки, которые мы использовали ранее, и вы увидите:

hamster 42 3.14159

Упражнения и решения можно найти на www.AtomicKotlin.com.

Множества Link to heading

Множество — это коллекция, которая позволяет иметь только один элемент каждого значения. Наиболее распространённая операция с множествами — это проверка на принадлежность с помощью in или contains():

// Sets/Sets.kt
import atomictest.eq

fun main() {
    val intSet = setOf(1, 1, 2, 3, 9, 9, 4)
    // Дубликаты отсутствуют:
    intSet eq setOf(1, 2, 3, 4, 9)
    // Порядок элементов не важен:
    setOf(1, 2) eq setOf(2, 1)
    // Принадлежность множеству:
    (9 in intSet) eq true
    (99 in intSet) eq false
    intSet.contains(9) eq true
    intSet.contains(99) eq false
    // Содержит ли это множество другое множество?
    intSet.containsAll(setOf(1, 9, 2)) eq true
    // Объединение множеств:
    intSet.union(setOf(3, 4, 5, 6)) eq setOf(1, 2, 3, 4, 5, 6, 9)
    // Пересечение множеств:
    intSet intersect setOf(0, 1, 2, 7, 8) eq setOf(1, 2)
    // Разность множеств:
    intSet subtract setOf(0, 1, 9, 10) eq setOf(2, 3, 4)
    intSet - setOf(0, 1, 9, 10) eq setOf(2, 3, 4)
}

Этот пример показывает:

1. Помещение дублирующихся элементов в множество автоматически удаляет эти дубликаты.
2. Порядок элементов не важен для множеств. Два множества равны, если они содержат одни и те же элементы.
3. Оба оператора in и contains() проверяют на принадлежность.
4. Вы можете выполнять обычные операции Венна, такие как проверка на подмножество, объединение, пересечение и разность, используя либо точечную нотацию (set.union(other)), либо инфиксную нотацию (set intersect other). Функции union, intersect и subtract могут использоваться в инфиксной нотации.
5. Разность множеств может быть выражена с помощью subtract() или оператора минус.

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

// Sets/RemoveDuplicates.kt
import atomictest.eq

fun main() {
    val list = listOf(3, 3, 2, 1, 2)
    list.toSet() eq setOf(1, 2, 3)
    list.distinct() eq listOf(3, 2, 1)
    "abbcc".toSet() eq setOf('a', 'b', 'c')
}

Вы также можете использовать distinct(), который возвращает список. Вы можете вызвать toSet() на строке, чтобы преобразовать её в множество уникальных символов.

Как и в случае со списками, Kotlin предоставляет две функции для создания множеств. Результат setOf() является только для чтения. Чтобы создать изменяемое множество, используйте mutableSetOf():

// Sets/MutableSet.kt
import atomictest.eq

fun main() {
    val mutableSet = mutableSetOf<Int>()
    mutableSet += 42
    mutableSet += 42
    mutableSet eq setOf(42)
    mutableSet -= 42
    mutableSet eq setOf<Int>()
}

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

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Карты Link to heading

Карта связывает ключи со значениями и ищет значение, когда дан ключ. Вы создаете карту, предоставляя пары ключ-значение в mapOf(). Используя to, мы разделяем каждый ключ от его связанного значения: // Maps/Maps.kt import atomictest.eq
fun main() {
val constants = mapOf(
“Pi” to 3.141,
“e” to 2.718,
“phi” to 1.618
)
constants eq
“{Pi=3.141, e=2.718, phi=1.618}”
// Получить значение по ключу:
constants[“e”] eq 2.718 // [1]
constants.keys eq setOf(“Pi”, “e”, “phi”)
constants.values eq “[3.141, 2.718, 1.618]”
var s = ""
// Перебор пар ключ-значение:
for (entry in constants) { // [2]
s += " ${ entry.key } = ${ entry.value } , "
}
s eq “Pi=3.141, e=2.718, phi=1.618,”
s = ""
// Распаковка во время итерации:
for ((key, value) in constants) // [3]
s += " $ key= $ value, "
s eq “Pi=3.141, e=2.718, phi=1.618,”
}
Карты 143
• [1] Оператор [] ищет значение, используя ключ. Вы можете получить все ключи, используя keys, и все значения, используя values. Вызов keys возвращает Set, потому что все ключи в карте должны быть уникальными, иначе у вас возникнет неоднозначность при поиске.
• [2] Перебор карты возвращает пары ключ-значение в виде записей карты.
• [3] Вы можете распаковывать ключи и значения во время итерации.
Обычная карта является только для чтения. Вот MutableMap:
// Maps/MutableMaps.kt
import atomictest.eq
fun main() {
val m =
mutableMapOf(5 to “five”, 6 to “six”)
m[5] eq “five”
m[5] = “5ive”
m[5] eq “5ive”
m += 4 to “four”
m eq mapOf(5 to “5ive”,
4 to “four”, 6 to “six”)
}
map[key] = value добавляет или изменяет значение, связанное с ключом. Вы также можете явно добавить пару, сказав map += key to value.
mapOf() и mutableMapOf() сохраняют порядок, в котором элементы добавляются в карту. Это не гарантируется для других типов карт.
Карта только для чтения не позволяет вносить изменения:
AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Карты 144
// Maps/ReadOnlyMaps.kt
import atomictest.eq
fun main() {
val m = mapOf(5 to “five”, 6 to “six”)
m[5] eq “five”
// m[5] = “5ive” // Ошибка
// m += (4 to “four”) // Ошибка
m + (4 to “four”) // Не изменяет m
m eq mapOf(5 to “five”, 6 to “six”)
val m2 = m + (4 to “four”)
m2 eq mapOf(
5 to “five”, 6 to “six”, 4 to “four”)
}
Определение m создает карту, связывающую Int с String. Если мы попытаемся заменить строку, Kotlin выдаст ошибку.
Выражение с + создает новую карту, которая включает как старые элементы, так и новый, но не влияет на оригинальную карту. Единственный способ “добавить” элемент в карту только для чтения — это создать новую карту.
Карта возвращает null, если она не содержит записи для данного ключа. Если вам нужен результат, который не может быть null, используйте getValue() и ловите NoSuchElementException, если ключ отсутствует:
// Maps/GetValue.kt
import atomictest.*
fun main() {
val map = mapOf(‘a’ to “attempt”)
map[‘b’] eq null
capture {
map.getValue(‘b’)
} eq “NoSuchElementException: " +
“Ключ b отсутствует в карте.”
map.getOrDefault(‘a’, “??”) eq “attempt”
map.getOrDefault(‘b’, “??”) eq “??”
}
getOrDefault() обычно является безопасной альтернативой null или исключению.
AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC
Карты 145
Вы можете хранить экземпляры классов в качестве значений в карте. Вот карта, которая извлекает Contact, используя номер телефона в виде строки:
// Maps/ContactMap.kt
package maps
import atomictest.eq
class Contact (
val name: String,
val phone: String
) {
override fun toString() =
“Contact(’ $ name’, ’ $ phone’)”
}
fun main() {
val miffy = Contact(“Miffy”, “1-234-567890”)
val cleo = Contact(“Cleo”, “098-765-4321”)
val contacts = mapOf(
miffy.phone to miffy,
cleo.phone to cleo)
contacts[“1-234-567890”] eq miffy
contacts[“1-111-111111”] eq null
}
Возможно использовать экземпляры классов в качестве ключей в карте, но это сложнее, поэтому мы обсудим это позже в книге.
• -
Карты выглядят как простые небольшие базы данных. Их иногда называют ассоциативными массивами, потому что они связывают ключи со значениями. Хотя они довольно ограничены по сравнению с полнофункциональной базой данных, они тем не менее удивительно полезны (и гораздо более эффективны, чем база данных).
Упражнения и решения можно найти на www.AtomicKotlin.com.
AtomicKotlin(www.AtomicKotlin.com) от Брюса Эккеля и Светланы Исаковой, ©2021 MindView LLC

Доступ к свойствам Link to heading

Чтобы прочитать свойство, используйте его имя. Чтобы присвоить значение изменяемому свойству, используйте оператор присваивания =. Это читает и записывает свойство i:

// PropertyAccessors/Data.kt
package propertyaccessors
import atomictest.eq

class Data(var i: Int)

fun main() {
    val data = Data(10)
    data.i eq 10 // Чтение свойства 'i'
    data.i = 20 // Запись в свойство 'i'
}

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

Аксессор, используемый для получения значения свойства, называется геттером. Вы создаете геттер, определяя get() сразу после определения свойства. Аксессор, используемый для изменения изменяемого свойства, называется сеттером. Вы создаете сеттер, определяя set() сразу после определения свойства.

Аксессоры свойств, определенные в следующем примере, имитируют реализации по умолчанию, генерируемые Kotlin. Мы отображаем дополнительную информацию, чтобы вы могли увидеть, что аксессоры свойств действительно вызываются во время чтения и записи. Мы отступаем get() и set(), чтобы визуально ассоциировать их со свойством, но фактическая ассоциация происходит потому, что get() и set() определены сразу после этого свойства (Kotlin не заботится о выравнивании):

// PropertyAccessors/Default.kt
package propertyaccessors
import atomictest.*

class Default {
    var i: Int = 0
        get() {
            trace("get()")
            return field // [1]
        }
        set(value) {
            trace("set($value)")
            field = value // [2]
        }
}

fun main() {
    val d = Default()
    d.i = 2
    trace(d.i)
    trace eq """
        set(2)
        get()
        2
    """
}

Порядок определения get() и set() не важен. Вы можете определить get() без определения set(), и наоборот.

Поведение по умолчанию для свойства возвращает его сохраненное значение из геттера и изменяет его с помощью сеттера — действия [1] и [2]. Внутри геттера и сеттера сохраненное значение манипулируется косвенно с использованием ключевого слова field, которое доступно только внутри этих двух функций.

В следующем примере используется реализация по умолчанию геттера и добавляется сеттер для отслеживания изменений свойства n:

// PropertyAccessors/LogChanges.kt
package propertyaccessors
import atomictest.*

class LogChanges {
    var n: Int = 0
        set(value) {
            trace("$field становится $value")
            field = value
        }
}

fun main() {
    val lc = LogChanges()
    lc.n eq 0
    lc.n = 2
    lc.n eq 2
    trace eq "0 становится 2"
}

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

// PropertyAccessors/Counter.kt
package propertyaccessors
import atomictest.eq

class Counter {
    var value: Int = 0
        private set

    fun inc() = value++
}

fun main() {
    val counter = Counter()
    repeat(10) {
        counter.inc()
    }
    counter.value eq 10
}

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

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

// PropertyAccessors/Hamsters.kt
package propertyaccessors
import atomictest.eq

class Hamster(val name: String)

class Cage(private val maxCapacity: Int) {
    private val hamsters = mutableListOf<Hamster>()

    val capacity: Int
        get() = maxCapacity - hamsters.size

    val full: Boolean
        get() = hamsters.size == maxCapacity

    fun put(hamster: Hamster): Boolean =
        if (full) false
        else {
            hamsters += hamster
            true
        }

    fun take(): Hamster =
        hamsters.removeAt(0)
}

fun main() {
    val cage = Cage(2)
    cage.full eq false
    cage.capacity eq 2
    cage.put(Hamster("Alice")) eq true
    cage.put(Hamster("Bob")) eq true
    cage.full eq true
    cage.capacity eq 0
    cage.put(Hamster("Charlie")) eq false
    cage.take()
    cage.capacity eq 1
}

Свойства capacity и full не содержат подлежащего состояния — они вычисляются в момент каждого доступа. Оба свойства capacity и full похожи на функции, и вы можете определить их как таковые:

// PropertyAccessors/Hamsters2.kt
package propertyaccessors

class Cage2(private val maxCapacity: Int) {
    private val hamsters = mutableListOf<Hamster>()

    fun capacity(): Int =
        maxCapacity - hamsters.size

    fun isFull(): Boolean =
        hamsters.size == maxCapacity
}

В этом случае использование свойств улучшает читаемость, потому что capacity и full являются свойствами клетки. Однако не стоит просто преобразовывать все ваши функции в свойства — сначала посмотрите, как они читаются.

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

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

Упражнения и решения можно найти на сайте www.AtomicKotlin.com.

Резюме 2 Link to heading

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

Пакеты и тестирование Link to heading

Любое количество переиспользуемых компонентов библиотеки может быть объединено под одним именем библиотеки с помощью ключевого слова package: // Summary2/ALibrary.kt package com.yoururl.libraryname // Компоненты для переиспользования … fun f() = “result” Вы можете разместить несколько компонентов в одном файле или распределить компоненты по нескольким файлам под одним и тем же именем пакета. В данном примере мы определили f() как единственный компонент. Чтобы сделать его уникальным, имя пакета обычно начинается с вашего доменного имени в обратном порядке. В этом примере доменное имя — yoururl.com.

В Kotlin имя пакета может быть независимым от директории, в которой находятся его содержимое. Java требует, чтобы структура директорий соответствовала полному имени пакета, поэтому пакет com.yoururl.libraryname должен находиться в директории com/yoururl/libraryname. Для смешанных проектов на Kotlin и Java стиль руководства Kotlin рекомендует ту же практику. Для чисто Kotlin проектов поместите директорию libraryname на верхний уровень структуры директорий вашего проекта.

Оператор импорта приносит одно или несколько имен в текущее пространство имен: // Summary2/UseALibrary.kt import com.yoururl.libraryname.* fun main() { val x = f() } Звезда после libraryname говорит Kotlin импортировать все компоненты библиотеки. Вы также можете выбирать компоненты по отдельности; подробности приведены в разделе “Пакеты”.

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

Важной библиотекой для этой книги является atomictest, наша простая тестовая рамка. atomictest определен в Приложении A: AtomicTest, хотя он использует языковые функции, которые вы не поймете на данном этапе книги.

После импорта atomictest вы используете eq (равно) и neq (не равно) почти так, как если бы это были ключевые слова языка: AtomicKotlin (www.AtomicKotlin.com) Брус Эккель и Светлана Исакова, ©2021 MindView LLC // Summary2/UsingAtomicTest.kt import atomictest.* fun main() { val pi = 3.14 val pie = “Круглый десерт” pi eq 3.14 pie eq “Круглый десерт” pi neq pie } /* Вывод: 3.14 Круглый десерт 3.14 */ Возможность использовать eq / neq без каких-либо точек или скобок называется инфиксной нотацией. Вы можете вызывать инфиксные функции либо обычным способом: pi.eq(3.14), либо используя инфиксную нотацию: pi eq 3.14. Оба eq и neq являются утверждениями истинности, которые также отображают результат с левой стороны выражения eq / neq и сообщение об ошибке, если выражение справа от eq не эквивалентно левому (или эквивалентно, в случае neq). Таким образом, вы видите проверенные результаты в исходном коде.

atomictest.trace использует синтаксис вызова функции для добавления результатов, которые затем могут быть проверены с помощью eq: // Testing/UsingTrace.kt import atomictest.* fun main() { trace(“Привет,”) trace(47) trace(“Мир!”) trace eq "”" Привет, 47 Мир! """ } Вы можете эффективно заменить println() на trace(). AtomicKotlin (www.AtomicKotlin.com) Брус Эккель и Светлана Исакова, ©2021 MindView LLC

Объекты повсюду Link to heading

Kotlin — это гибридный объектно-функциональный язык: он поддерживает как объектно-ориентированные, так и функциональные парадигмы программирования. Объекты содержат val и var, чтобы хранить данные (они называются свойствами) и выполнять операции с помощью функций, определенных внутри класса, которые называются членами класса (когда это однозначно, мы просто говорим «функции»). Класс определяет свойства и функции-члены для того, что по сути является новым, пользовательским типом данных. Когда вы создаете val или var класса, это называется созданием объекта или созданием экземпляра.

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

// Summary2/ListCollection.kt
import atomictest.eq

fun main() {
    val lst = listOf(19.2, 88.3, 22.1)
    lst[1] eq 88.3 // Индексация
    lst.reversed() eq listOf(22.1, 88.3, 19.2)
    lst.sorted() eq listOf(19.2, 22.1, 88.3)
    lst.sum() eq 129.6
}

Не требуется оператор импорта для использования List. Kotlin использует квадратные скобки для индексации в последовательностях. Индексация начинается с нуля. Этот пример также показывает несколько из множества функций стандартной библиотеки, доступных для List: sorted(), reversed() и sum(). Чтобы понять эти функции, обратитесь к онлайн-документации по Kotlin.

Когда вы вызываете sorted() или reversed(), lst не изменяется. Вместо этого создается и возвращается новый List, содержащий желаемый результат. Этот подход, при котором оригинальный объект никогда не модифицируется, последователен во всех библиотеках Kotlin, и вы должны стремиться следовать этой модели при написании собственного кода.

Создание классов Link to heading

Определение класса состоит из ключевого слова class, имени класса и необязательного тела. Тело содержит определения свойств (val и var) и определения функций. Этот пример определяет класс NoBody без тела и классы с свойствами val:

// Summary2/ClassBodies.kt
package summary2
class NoBody
class SomeBody {
    val name = "Janet Doe"
}
class EveryBody {
    val all = listOf(SomeBody(), SomeBody(), SomeBody())
}
fun main() {
    val nb = NoBody()
    val sb = SomeBody()
    val eb = EveryBody()
}

Чтобы создать экземпляр класса, поставьте скобки после его имени, вместе с аргументами, если они необходимы. Свойства внутри тел классов могут быть любого типа. SomeBody содержит свойство типа String, а свойство EveryBody — это список, содержащий объекты SomeBody.

Вот класс с членами-функциями:

// Summary2/Temperature.kt
package summary2
import atomictest.eq

class Temperature {
    var current = 0.0
    var scale = "f"
    
    fun setFahrenheit(now: Double) {
        current = now
        scale = "f"
    }
    
    fun setCelsius(now: Double) {
        current = now
        scale = "c"
    }
    
    fun getFahrenheit(): Double =
        if (scale == "f") current
        else current * 9.0 / 5.0 + 32.0
    
    fun getCelsius(): Double =
        if (scale == "c") current
        else (current - 32.0) * 5.0 / 9.0
}

fun main() {
    val temp = Temperature() // [1]
    temp.setFahrenheit(98.6)
    temp.getFahrenheit() eq 98.6
    temp.getCelsius() eq 37.0
    temp.setCelsius(100.0)
    temp.getFahrenheit() eq 212.0
}

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

• [1] Хотя temp является val, мы позже модифицируем объект Temperature. Определение val предотвращает переназначение ссылки temp на новый объект, но не ограничивает поведение самого объекта.

Следующие два класса являются основой для игры в крестики-нолики:

// Summary2/TicTacToe.kt
package summary2
import atomictest.eq

class Cell {
    var entry = ' ' // [1]
    
    fun setValue(e: Char): String = // [2]
        if (entry == ' ' && (e == 'X' || e == 'O')) {
            entry = e
            "Успешный ход"
        } else {
            "Недопустимый ход"
        }
}

class Grid {
    val cells = listOf(
        listOf(Cell(), Cell(), Cell()),
        listOf(Cell(), Cell(), Cell()),
        listOf(Cell(), Cell(), Cell())
    )
    
    fun play(e: Char, x: Int, y: Int): String =
        if (x !in 0..2 || y !in 0..2) {
            "Недопустимый ход"
        } else {
            cells[x][y].setValue(e) // [3]
        }
}

fun main() {
    val grid = Grid()
    grid.play('X', 1, 1) eq "Успешный ход"
    grid.play('X', 1, 1) eq "Недопустимый ход"
    grid.play('O', 1, 3) eq "Недопустимый ход"
}

Класс Grid содержит список, состоящий из трех списков, каждый из которых содержит три ячейки — матрицу.

• [1] Свойство entry в Cell является var, поэтому его можно модифицировать. Одинарные кавычки в инициализации создают тип Char, поэтому все присваивания entry также должны быть Char.

• [2] setValue() проверяет, доступна ли ячейка и передан ли правильный символ. Он возвращает строковый результат, чтобы указать на успех или неудачу.

• [3] play() проверяет, находятся ли аргументы x и y в пределах диапазона, затем индексирует их в матрице, полагаясь на проверки, выполненные setValue().

Конструкторы Link to heading

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

// Summary2/WildAnimals.kt
package summary2
import atomictest.eq

class Badger(id: String, years: Int) {
    val name = id
    val age = years
    override fun toString() = "Badger: $name, age: $age"
}

class Snake(
    var type: String,
    var length: Double
) {
    override fun toString() = "Snake: $type, length: $length"
}

class Moose(
    val age: Int,
    val height: Double
) {
    override fun toString() = "Moose, age: $age, height: $height"
}

fun main() {
    Badger("Bob", 11) eq "Badger: Bob, age: 11"
    Snake("Garden", 2.4) eq "Snake: Garden, length: 2.4"
    Moose(16, 7.2) eq "Moose, age: 16, height: 7.2"
}

Параметры id и years в классе Badger доступны только в теле конструктора. Тело конструктора состоит из строк кода, отличных от определений функций; в данном случае это определения для name и age.

Часто вы хотите, чтобы параметры конструктора были доступны в других частях класса, а не только в теле конструктора, но без необходимости явно определять новые идентификаторы, как мы сделали с name и age. Если вы определяете свои параметры как var или val, они становятся свойствами и доступны повсюду в классе. Оба класса Snake и Moose используют этот подход, и вы можете видеть, что параметры конструктора теперь доступны внутри их соответствующих функций toString().

Параметры конструктора, объявленные с помощью val, не могут быть изменены, но те, которые объявлены с помощью var, могут.

Когда вы используете объект в ситуации, где ожидается String, Kotlin создает строковое представление этого объекта, вызывая его функцию-член toString(). Чтобы определить toString(), вы должны понять новое ключевое слово: override. Это необходимо (Kotlin настаивает на этом), потому что toString() уже определен. override говорит Kotlin, что мы действительно хотим заменить стандартный toString() нашим собственным определением. Ясность override делает это понятным для читателя и помогает предотвратить ошибки.

Обратите внимание на форматирование многострочного списка параметров для Snake и Moose — это рекомендуемый стандарт, когда у вас слишком много параметров, чтобы уместить их в одной строке, как для конструкторов, так и для функций.

Ограничение видимости Link to heading

Kotlin предоставляет модификаторы доступа, аналогичные тем, что доступны в других языках, таких как C++ или Java. Эти модификаторы позволяют создателям компонентов решать, что доступно клиентскому программисту. Модификаторы доступа в Kotlin включают ключевые слова public, private, protected и internal. protected будет объяснен позже.

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

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

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

Если вы определяете класс, функцию верхнего уровня или свойство как private, оно доступно только в этом файле: // Summary2/Boxes.kt package summary2
import atomictest.*
private var count = 0 // [1]
private class Box (val dimension: Int) { // [2]
fun volume() =
dimension * dimension * dimension
override fun toString() =
“Box volume: ${ volume() } "
}
private fun countBox(box: Box) { // [3]
trace(” $ box")
count++
}
fun countBoxes() {
countBox(Box(4))
countBox(Box(5))
}
fun main() {
countBoxes()
trace(" $ count boxes")
trace eq """
Box volume: 64
Box volume: 125
2 boxes
"""
}

Вы можете получить доступ к private свойствам ([1]), классам ([2]) и функциям ([3]) только из других функций и классов в файле Boxes.kt. Kotlin предотвращает доступ к private элементам верхнего уровня из другого файла.

Члены класса могут быть private:
// Summary2/JetPack.kt
package summary2
import atomictest.eq
class JetPack (
private var fuel: Double // [1]
) {
private var warning = false
private fun burn() = // [2]
if (fuel - 1 <= 0) {
fuel = 0.0
warning = true
} else
fuel -= 1
public fun fly() = burn() // [3]
fun check() = // [4]
if (warning) // [5]
“Warning”
else
“OK”
}
fun main() {
val jetPack = JetPack(3.0)
while (jetPack.check() != “Warning”) {
jetPack.check() eq “OK”
jetPack.fly()
}
jetPack.check() eq “Warning”
}

• [1] fuel и warning — это оба private свойства и не могут использоваться не членами класса JetPack.
• [2] burn() является private, и, следовательно, доступна только внутри JetPack.
• [3] fly() и check() являются public и могут использоваться везде.
• [4] Отсутствие модификатора доступа означает публичную видимость.
• [5] Только члены одного и того же класса могут получать доступ к private членам.

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

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

Полезно делить большие программы на модули. Модуль — это логически независимая часть кодовой базы. Определение internal доступно только внутри модуля, в котором оно определено. Способ, которым вы делите проект на модули, зависит от системы сборки (например, Gradle или Maven) и выходит за рамки этой книги.

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

Исключения Link to heading

Рассмотрим функцию toDouble(), которая преобразует строку в Double. Что произойдет, если вы вызовете ее для строки, которая не может быть преобразована в Double?

// Summary2/ToDoubleException.kt
fun main() {
    // val i = "$1.9".toDouble()
}

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

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

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

// Summary2/AtomicTestCapture.kt
import atomictest.*

fun main() {
    capture {
        "$1.9".toDouble()
    } eq "NumberFormatException: " +
        """For input string: "$1.9""""
}

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

Еще одна стратегия, когда ваша функция не может успешно вернуть ожидаемый результат, — это вернуть null. Позже в разделе о Nullable Types мы обсудим, как null влияет на тип результирующего выражения.

Чтобы выбросить исключение, используйте ключевое слово throw, за которым следует исключение, которое вы хотите выбросить, вместе с любыми аргументами, которые могут понадобиться. Функция quadraticZeroes() в следующем примере решает квадратное уравнение, которое определяет параболу:

ax² + bx + c = 0

Решение — это квадратная формула:

Квадратная формула

Пример находит нули параболы, где линии пересекают ось x. Мы выбрасываем исключения для двух ограничений:

1. a не может быть нулем.
2. Чтобы нули существовали, b² - 4ac не может быть отрицательным.

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

// Summary2/Quadratic.kt
package summary2

import kotlin.math.sqrt
import atomictest.*

class Roots(
    val root1: Double,
    val root2: Double
)

fun quadraticZeroes(
    a: Double,
    b: Double,
    c: Double
): Roots {
    if (a == 0.0)
        throw IllegalArgumentException("a is zero")
    val underRadical = b * b - 4 * a * c
    if (underRadical < 0)
        throw IllegalArgumentException("Negative underRadical: $underRadical")
    val squareRoot = sqrt(underRadical)
    val root1 = (-b - squareRoot) / (2 * a)
    val root2 = (-b + squareRoot) / (2 * a)
    return Roots(root1, root2)
}