что значит в котлине
Проблема nullable-типов в том, что многие методы их узких классов-аналогов (без поддержки null) становятся недоступными.
На скрине показано, что несмотря на то, что переменная b не содержит null, использовать свойства и методы обычной строки нельзя.
Как быть в таких ситуациях? Очевидный ответ – проверить значение переменной на null. Если оно не является null, то с помощью оператора as привести его к узкому типу и только после этого вызывать методы.
Однако умный компилятор Kotlin позволяет не делать такое приведение вручную. Если сравнение в заголовке if возвращает истину (переменная не равна null), то в области действия сравнения компилятор будет считать это значение обычным. Как бы сам временно приведет переменную к ненуллабл-типу. Поэтому код выше упрощается до такого:
Если требуется сохранить в переменную длину строки, а также какой-либо числовой сигнал, если был null, потребуется ветка else:
Таким образом проблема nullable-типов в Kotlin решается просто. Однако несколько громоздко и, даже если записать if-else в одну строку, длинно. Поэтому в языке предусмотрены специальные операторы и функции для работы с nullable-типами. В этом уроке будут рассмотрены три оператора Kotlin – оператор безопасного вызова, оператор «элвис» и утверждение «это не null».
?. – оператор безопасного вызова
Оператор безопасного вызова, обозначаемый вопросительным знаком с точкой, похож на проверку на null с if в варианте без else. Он проверят, что значение слева от него не равно null. Если же оно равно null, то ничего не происходит. Точнее, все выражение возвращает null.
Поскольку выражение с оператором безопасного вызова метода потенциально может вернуть null, то значение всего выражения с этим оператором всегда будет принадлежать какому-либо nullable-типу.
?: – оператор «элвис»
Оператор, обозначаемый вопросительным знаком с двоеточием, подобен проверке на null в варианте if-else. Он возвращает значение слева от себя, если оно не null. И возвращает значение справа от себя, если то, что слева, – null.
Переменная c будет содержать либо строку, которую вернула функция readLine(), либо пустую строку, если readLine() вернет null. Избавимся от переменной c :
!! – утверждение «это не null»
Поэтому, несмотря на удобство этого оператора, его следует использовать только там, где вы уверенны, что null быть не может.
10 главных конструкций языка Kotlin
Почти как Java, но есть отличия.
Чтобы быстро начать программировать на языке, достаточно знать несколько основных конструкций и общих правил написания кода. Со временем вы освоите все нюансы, а на старте можно использовать что-то попроще.
Если вы не знаете, зачем нужен Kotlin и что на нём программируют, почитайте нашу статью про Kotlin. А если знаете — вот вам краткий справочник по основам языка.
👉 В Kotlin будет много конструкций, похожих на Java. Это нормально, потому что Kotlin работает тоже поверх виртуальной машины JVM, как и Java.
Точка с запятой в Котлине не нужна.
Комментарии
Всё как обычно — есть однострочные и многострочные комментарии:
// Это однострочный комментарий
// Для каждой строки нужно добавлять его отдельно
/* А это — многострочный
его можно сделать любой длины,
если в начале и в конце поставить нужные символы */
Многие программисты ругают Kotlin за то, что ключевые слова для переменной и константы отличаются всего на одну букву:
val — объявляет константу
var — объявляет переменную
Из-за этого легко ошибиться и сделать константу вместо переменной и наоборот.
Ввод и вывод
Чтобы ввести что-то с клавиатуры, нам нужна переменная, где будет храниться результат ввода и команда readLine(). Эта команда ждёт, когда пользователь введёт любые данные и нажмёт Enter. После этого всё, что ввёл пользователь, отправляется в ту переменную.
Для вывода используются команды print() и println() — первая оставляет курсор на той же строке, а вторая после вывода переводит курсор на новую строку.
Чтобы вывести значение переменной в команде вывода, перед переменной ставят знак доллара:
Присваивание и сравнение
Всё так же, как в Java, но без точек с запятой:
// это присваивание
x = 10
// а это — сравнение x и 10
// результат сравнения отправляется в переменную b
var bol: Boolean
b = (x == 10)
Условный оператор if
Работает как обычно: сначала проверяется условие, и если оно истинно — выполняется код, который идёт после условия. Если результат проверки ложный — выполняется код, написанный после else, или не выполняется ничего, если такого блока в условии нет. Условие пишется в скобках, фигурные скобки можно не писать, если нужно выполнить только одну команду.
Оператор множественного выбора when
Аналог классического Case или Switch из других языков программирования. Команда смотрит на значение переменной, которое к ней поступило, и сравнивает это значение со своим списком вариантов. Если есть совпадение — выполняется нужная команда.
Циклы
Проще всего работать с циклом for: достаточно указать имя переменной цикла и диапазон, в котором она будет меняться:
При желании можно указать шаг цикла внутри диапазона (по умолчанию он равен единице):
for (i in 1..6 step 2) <
print(«$i «) // на экране появятся числа 1, 3 и 5
>
Циклы с предусловием и с постусловием выглядят и работают как в обычном Java:
Функции
У функций в Kotlin полная свобода:
👉 А ещё в Kotlin, как и в Java, каждая программа состоит из функций и каждая команда должна быть внутри какой-то функции. Основная функция программы называется main.
Самое простое объявление и использование функций в Kotlin выглядит так:
Классы
Классы в Котлине поддерживают полноценные конструкторы и инициализации, но для старта достаточно объявить имя класса и его содержимое:
Объекты
Как и в большинстве ООП-языков, для создания нового объекта достаточно указать класс, от которого произойдёт объект. После этого с объектом можно работать по всем правилам объектно ориентированного программирования:
Основной синтаксис
Определение имени пакета
Имя пакета указывается в начале исходного файла, так же как и в Java:
Но в отличие от Java, нет необходимости, чтобы структура пакетов совпадала со структурой папок: исходные файлы могут располагаться в произвольном месте на диске.
Объявление функции
Функция принимает два аргумента Int и возвращает Int :
Функция с выражением в качестве тела и автоматически определенным типом возвращаемого значения:
Функция, не возвращающая никакого значения (void в Java):
Тип возвращаемого значения Unit может быть опущен:
Определение внутренних переменных
Неизменяемая (только для чтения) внутренняя переменная:
Комментарии
Также, как Java и JavaScript, Kotlin поддерживает однострочные комментарии.
В отличие от Java, блочные комментарии могут быть вложенными.
См. Документация Kotlin кода для информации о документации в комментариях.
Использование строковых шаблонов
Использование условных выражений
Nullable-значения и проверка на null
Возвращает null если str не содержит числа:
Использование функции, возвращающей null:
Проверка типа и автоматическое приведение типов
Оператор is проверяет, является ли выражение экземпляром заданного типа. Если неизменяемая внутренняя переменная или свойство уже проверены на определенный тип, то в дальнейшем нет необходимости явно приводить к этому типу:
Почему следует полностью переходить на Kotlin
Хочу рассказать вам о новом языке программирования, который называется Kotlin, и объяснить, почему вам стоит использовать его в своём следующем проекте. Раньше я предпочитал Java, но в последний год пишу на Kotlin везде, где только можно. И в данный момент я не представляю себе ситуации, в которой лучше было бы выбрать Java.
Kotlin разработан в JetBrains, и участие тех же людей в создании наборов IDE, таких как IntelliJ и ReSharper, хорошо заметно по самому языку. Он прагматичен и краток, благодаря чему написание кода превращается в приятный и эффективный процесс.
Хотя Kotlin компилируется в JavaScript и скоро будет компилироваться в машинный код, я сконцентрируюсь на его первичной среде — JVM.
Итак, несколько причин, почему вам следует полностью переходить на Kotlin (порядок случаен):
0# Совместимость с Java
Kotlin на 100 % совместим с Java. Вы можете в буквальном смысле продолжать работать над своим старым Java-проектом, но уже используя Kotlin. Все ваши любимые Java-фреймворки также будут доступны, и, в каком бы фреймворке вы ни писали, Kotlin будет легко принят упрямым любителем Java.
1# Знакомый синтаксис
2# Интерполяция строк
Это как бы более умная и читабельная версия String.format() из Java, встроенная в язык:
3# Выведение типа
Kotlin будет выводить ваши типы, если вы посчитаете, что это улучшит читабельность:
4# Умные приведения типов (Smart Casts)
Компилятор Kotlin отслеживает вашу логику и по мере возможности автоматически выполняет приведение типов, т. е. вам больше не нужны проверки instanceof после явных приведений:
5# Интуитивные равенства (Intuitive Equals)
6# Аргументы по умолчанию
Больше не нужно определять несколько одинаковых методов с разными аргументами:
7# Именованные аргументы
В сочетании с аргументами по умолчанию именованные аргументы избавляют от необходимости использовать Строителей:
8# Выражение When
Оператор ветвления заменён гораздо более читабельным и гибким в применении выражением when:
Оно работает и как выражение (expression), и как описание (statement), с аргументом или без него:
9# Свойства
Можно добавить публичным полям кастомное поведение set & get, т. е. перестать набивать код безумными геттерами и сеттерами.
10# Data Class
11# Перегрузка оператора (Operator Overloading)
Заранее определённый набор операторов, которые можно перегружать для улучшения читабельности:
12# Деструктурирующие объявления (Destructuring Declarations)
Некоторые объекты могут быть деструктурированы, что бывает полезно, к примеру, для итерирования map:
13# Диапазоны (Ranges)
Для улучшения читабельности:
14# Функции-расширения (Extension Functions)
Если бы существовал способ добавления новых функций в старые классы, тогда ваш IDE помог бы найти правильную функцию при завершении кода. Именно это можно делать в Kotlin:
Стандартная библиотека расширяет функциональность оригинальных Java-типов, что особенно полезно для String :
15# Безопасность Null
Kotlin заставляет вас бороться с NPE, когда вы обращаетесь к типу, допускающему null:
Возможно, выглядит громоздко, но благодаря нескольким своим возможностям действительно полезно. У нас всё ещё есть умные приведения типов, когда типы, допускающие null, преобразуются в не допускающие:
Если всё это вам не подходит и вам совершенно точно нужны NPE, то скажите об этом явно:
16# Улучшенные лямбды
Это хорошая система лямбд — идеальный баланс между читабельностью и лаконичностью благодаря нескольким толковым решениям. Синтаксис прост:
А вот и толковые решения:
Комбинация этих факторов делает эквивалентными эти три строки:
Это позволяет нам писать лаконичный функциональный код, вы только посмотрите на эту красоту:
Система лямбд, объединённая с функциями-расширениями, делает Kotlin идеальным инструментом для создания DSL. Anko — пример DSL, предназначенного для расширения возможностей Android-разработки:
17# Поддержка IDE
У вас есть целый ряд вариантов, как можно начать работать с Kotlin, но я крайне рекомендую использовать IntelliJ, идущий в комплекте поставки Kotlin — его возможности демонстрируют преимущество ситуации, когда одни и те же люди разрабатывают как язык, так и IDE.
Небольшой пример: это сообщение всплыло, когда я впервые попытался скопипастить Java-код со Stack Overflow:
IntelliJ заметит, что вы вставляете Java-код в файл Kotlin
На этом всё, спасибо за чтение! Если мне пока не удалось убедить вас насчёт Kotlin, то рекомендую почитать дополнительные материалы:
Kotlin. Основной синтаксис
В данной статье рассмотрим основной синтаксис языка Kotlin.
Переменные
Обратите внимание, что переменная, объявленная ключевым словом val хранит ссылку на объект. Именно ссылку невозможно изменить после инициализации. А вот объект, на который она ссылается может быть изменяемым.
При объявлении переменной сначала указывается ключевое слово, затем имя переменной и (в зависимости от ситуации) тип переменной.
В приведенном ниже примере count является переменной типа Int, которой присваивается начальное значение 10:
Приведение типов
Тип переменной не всегда нужно указывать, так как компилятор Kotlin может определить тип, основываясь на типе значения.
Поскольку значение Kotlin имеет тип String, то компилятор разумно предположит, что и переменная languageName имеет тип String.
Тип определяется во время компиляции и далее никогда не меняется.
Защита от null
В некоторых языках переменные ссылочного типа могут объявляться без исходного явного значения. В этих случаях переменные обычно содержат нулевые значения. В Kotlin переменные не могут содержать нулевые значения по умолчанию. Это означает, что следующий код вызовет ошибку:
Проверка на null (if / else, безопасные вызовы)
Если переменная объявлена как nullable, Kotlin будет проверять ее и предупреждать о возможной ошибке на этапе разработки. Это означает, что перед выполнением какого-либо действия, нужно убедиться, что в переменной хранится не нулевое значение. Сделать это можно с помощью обычной проверки if / else, тем самым обработав оба варианта.
Такая проверка сработает только в том случае, если переменная не может быть изменена во время этой проверки (например, если переменная локальная или объявлена ключевым словом val ). Иначе может оказаться так, что переменной присвоится значение null во время проверки.
Для проведения каких-либо операций исключительно над non-null значениями можно использовать оператор let вместе с оператором безопасного вызова:
Значение будет выведено на печать, если оно не null.
Условные выражения
Kotlin позволяет использовать if несколькими способами. Один из них ничем не отличается от применения if в Java:
Также if может выступать в качестве выражения, т.е. оно может вернуть значение и присвоить его переменной. В данном случае обязательным условием является использование else.
Каждая условная ветвь возвращает значение, указанное в последней строке. Поэтому не требуется использовать ключевое слово return.
По сути это тотже самый тернарный оператор в Java. Только в Kotlin от него отказались в пользу условных выражений.
По мере роста сложности условного выражения можно подумать о замене if-else на when. Ключевое слово when призвано заменить оператор switch, присутствующий в C-подобных языках. А его простейшая реализация может выглядеть так:
Каждая ветвь выражения when состоит из условия, стрелки -> и выполняемого действия (результата). Указанные значения последовательно сравниваются с предоставленным аргументом-условием пока не будет найдено совпадение. Если совпадения не найдено, то выполняется ветка else.
When можно использовать как выражение, т.е. оно может вернуть значение и присвоить его переменной. Если ветки покрывают не все возможные значения, то наличие ветки else обязательно.
Если для нескольких значений нужно выполнить одно и тоже действие, то их можно перечислить в одной ветке через запятую:
Помимо конкретных значений можно использовать произвольные выражения:
И даже проверять, входит ли значение в заданный интервал и есть ли оно в коллекции:
Циклы
Цикл for
Цикл for позволяет пройтись по всем элементам списка.
Из примера видно, что for имеет отличный от Java синтаксис: нет переменной цикла, изменяемой на каждом шаге, а также проверки выхода из цикла. Он чем-то напоминает forEach в Java.
Диапазон можно заменить переменной:
Если вам нужно узнать индекс позиции используйте функцию indices :
Циклы while, do-while
Данные циклы работают также как и в Java.
Цикл while будет выполнять команды в своём блоке, пока условие остаётся истинным.
Ну а do-while отличается от while тем, что сначала выполняет команды в блоке, а потом проверяет условие.
Цикл forEach
Операторы перехода
С помощью операторов перехода можно завершить работу функции, либо цикла. Виды операторов:
Метки
Данные метки используются совместно с операторами перехода для уточнения. Например, при наличии вложенных циклов можно явно указать, какой из них нужно остановить.
Если заменить оператор break на continue, то цикл с меткой loop продолжит работу со следующего шага.
Функции
Вместо того, чтобы повторять один и тот же ряд выражений везде, где требуется одинаковый результат, можно сгруппировать эти выражения в функцию и вызывать её. Объявляется функция с помощью ключевого слова fun, за которым следует её название, тип входных данных (если таковые имеются), тип возвращаемых данных (при необходимости) и тело функции.
Входные данные (параметры) записываются в виде имя: тип и разделяются запятыми.
При этом не обязательно объявлять функцию в теле класса. Т.е. можно создать файл, указать в нем название пакета и добавить в него нужные функции. Это удобно, когда есть методы, не относящиеся к реализации конкретного класса.
Параметры по умолчанию
Параметры функции могут иметь значения по умолчанию. Очень удобно использовать, если мы заранее знаем, что чаще всего у такого параметра будет одно и тоже значение. Если параметру задано значение по умолчанию, то при объявлении функции его можно не указывать. Запись будет иметь вид имя: тип = значение.
Переопределённые методы всегда используют значения по умолчанию, которые были заданы в базовом методе.
Именованные параметры
Если во входных данных функции несколько параметров и какие-то из них имеют значение по умолчанию, а какие-то нет, то при вызове такой функции Kotlin может запутаться.
В таких случаях следует использовать именованные параметры, т.е. явно указывать имена параметров при вызове функции.
Также именованные параметры удобно использовать, если у функции просто много параметров. Это позволяет сделать код визуально более понятным.
Функции с единственным выражением
Когда функция возвращает одно единственное значение, то ключевое слово return может быть заменено на оператор присваивания, а фигурные скобки опускаются.
Переменное число параметров
Последний параметр в функции можно пометить модификатором vararg.
Тогда при вызове функции мы сможем передать не одно, а несколько значений.
В одной функции таким образом можно пометить только один параметр. При этом, если этот параметр не будет последним, то значение для него можно будет передать только при помощи именованных параметров.
Классы
Объявляются классы с помощью ключевого слова class. По умолчанию всем классам присваивается модификатор public, поэтому дополнительно его указывать не требуется.
Конструкторы
При этом, ключевое слово constructor необязательно указывать, если у класса нет аннотаций и модификаторов.
Если при создании класса нужно что-либо инициализировать, то используется специальный блок init.
Параметры основного конструктора могут быть использовать либо в блоке init (как показано выше), либо при инициализации свойств в теле класса.
Дополнительные конструкторы всегда объявляются при помощи ключевого слова constructor в теле класса.
Геттеры и сеттеры
Наследование
Создание класса
Для создания экземпляра класса нужно вызвать его конструктор. В отличие от Java, ключевое слово new не используется.