Я хочу рассказать вам о языке программирования Kotlin и о том, почему вы должны рассмотреть его для своего следующего проекта. Раньше я предпочитал Java, но за прошедший год обнаружил, что кодирую на Kotlin при любой возможности, и сейчас я действительно не могу придумать ситуацию, в которой Java был бы лучшим выбором.
Он разработан компанией JetBrains, и тот факт, что именно эти люди стоят в создании такого набора IDE, как IntelliJ и ReSharper, в полной мере отражается и в Kotlin. Он прагматичен и лаконичен, делает кодирование приятным и эффективным занятием.
Хотя Kotlin компилируется как в JavaScript, а скоро и в машинный код, я сосредоточусь на его основной среде - JVM.
Итак, вот несколько причин, по которым вы должны полностью перейти на Kotlin (нумерация случайна, без определенного порядка):
Kotlin на 100% совместим с Java. Вы можете в буквальном смысле продолжать работать над своими старыми Java-проектами, используя Kotlin. Все ваши любимые Java-фреймворки по-прежнему доступны, и любой фреймворк, который вы напишете на Kotlin, будет легко принят вашим упертым другом, любящим Java.
Kotlin - это не какой-то необычный язык, рожденный в академических кругах. Его синтаксис знаком любому программисту, пришедшему из области ООП, и может быть более или менее понятен с самого начала. Конечно, есть некоторые отличия от Java, например, переработанные конструкторы или объявления переменных val var. В приведенном ниже сниппете представлена большая часть базового синтаксиса:
class Foo {
val b: String = "b" // val means unmodifiable
var i: Int = 0 // var means modifiable
fun hello() {
val str = "Hello"
print("$str World")
}
fun sum(x: Int, y: Int): Int {
return x + y
}
fun maxOf(a: Float, b: Float) = if (a > b) a else b
}Это как если бы в язык была встроена более умная и читабельная версия функции String.format() из Java:
val x = 4
val y = 7
print("sum of $x and $y is ${x + y}") // sum of 4 and 7 is 113# Вывод типов
Kotlin будет выводить ваши типы, если вы посчитаете, что это улучшит читабельность:
val a = "abc" // type inferred to String
val b = 4 // type inferred to Int
val c: Double = 0.7 // type declared explicitly
val d: List<String> = ArrayList() // type declared explicitly4# "Умные" преобразования. (Smart Casts)
Компилятор Kotlin отслеживает вашу логику и по возможности автоматически выполняет приведение типов, что означает избавление от проверок instanceof и явных преобразований:
if (obj is String) {
print(obj.toUpperCase()) // obj is now known to be a String
}Вы можете перестать явно вызывать equals(), потому что оператор == теперь проверяет структурное равенство:
val john1 = Person("John")
val john2 = Person("John")
john1 == john2 // true (structural equality)
john1 === john2 // false (referential equality)Нет необходимости определять несколько одинаковых методов с разными аргументами:
fun build(title: String, width: Int = 800, height: Int = 600) {
Frame(title, width, height)
}В сочетании с аргументами по умолчанию именованные аргументы избавляют от необходимости использовать строителей (builders):
build("PacMan", 400, 300) // equivalent
build(title = "PacMan", width = 400, height = 300) // equivalent
build(width = 400, height = 300, title = "PacMan") // equivalentВ качестве замены оператору switch используется гораздо более удобное и гибкое выражение when:
when (x) {
1 -> print("x is 1")
2 -> print("x is 2")
3, 4 -> print("x is 3 or 4")
in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
else -> print("x is out of range")
}Оно работает как выражение, и как оператор, с аргументом, и без него:
val res: Boolean = when {
obj == null -> false
obj is String -> true
else -> throw IllegalStateException()
}9# Свойства
К публичным полям может быть добавлено кастомное поведение set и get, что позволит нам остановить загромождение кода бессмысленными геттерами и сеттерами.
class Frame {
var width: Int = 800
var height: Int = 600
val pixels: Int
get() = width * height
}Это POJO (Plain Old Java Object) с функциями toString(), equals(), hashCode() и copy(), и в отличие от Java он не занимает почти 100 строк кода:
data class Person(val name: String,
var email: String,
var age: Int)
val john = Person("John", "john@gmail.com", 112)Предопределенный набор операторов может быть перегружен для улучшения читабельности:
data class Vec(val x: Float, val y: Float) {
operator fun plus(v: Vec) = Vec(x + v.x, y + v.y)
}
val v = Vec(2f, 3f) + Vec(4f, 1f)12# Объявления деструктуризации
Некоторые объекты могут быть деструктурированы, что, например, полезно для итерации карт:
for ((key, value) in map) {
print("Key: $key")
print("Value: $value")
}13# Диапазоны
Для улучшения читабельности:
for (i in 1..100) { ... }
for (i in 0 until 100) { ... }
for (i in 2..10 step 2) { ... }
for (i in 10 downTo 1) { ... }
if (x in 1..10) { ... }Помните, когда вам впервые понадобилось отсортировать List в Java? Вы не могли найти функцию sort() и вам в результате пришлось узнать о Collections.sort(). А позже, когда вам нужно было написать String с заглавной буквы, то это привело к написанию собственной вспомогательной функции, потому что вы не знали о StringUtils.capitalize().
Если бы только существовал способ добавить новые функции в старые классы; тогда ваша IDE смогла бы помочь вам найти нужную функцию при автоматическом дополнении кода. В Kotlin вы можете сделать именно это:
fun String.replaceSpaces(): String {
return this.replace(' ', '_')
}
val formatted = str.replaceSpaces()Стандартная библиотека расширяет функциональность оригинальных типов Java, что особенно требовалось для String:
str.removeSuffix(".txt")
str.capitalize()
str.substringAfterLast("/")
str.replaceAfter(":", "classified")Java - это то, что мы должны назвать почти статически типизированным языком. В нем переменная типа String не гарантированно ссылается на String - она может ссылаться на null. Несмотря на то, что мы привыкли к этому, это сводит на нет безопасность статической проверки типов, и в результате разработчикам Java приходится жить в постоянном страхе перед ошибкой NPE (NullPointerException).
Kotlin решает эту проблему, проводя различие между ненулевыми (non-null) и обнуляемыми (nullable) типами. Типы по умолчанию являются non-null, и их можно сделать nullable, добавив ? как, например:
var a: String = "abc"
a = null // compile error
var b: String? = "xyz"
b = null // no problemKotlin заставляет вас защищаться от NPE всякий раз, когда вы обращаетесь к nullable-типу:
val x = b.length // compile error: b might be nullИ хотя это может показаться громоздким, на самом деле все просто благодаря нескольким особенностям Kotlin. У нас все еще есть умное приведение, которое преобразует nullable типы в non-null везде, где это возможно:
if (b == null) return
val x = b.length // no problemМы также можем использовать безопасный вызов ?., который производит проверку на нулевое значение вместо того, чтобы выбрасывать NPE:
val x = b?.length // type of x is nullable IntБезопасные вызовы можно объединять в цепочки, чтобы избежать вложенных проверок if-not-null (если-не-ноль), которые мы иногда пишем в других языках, и если нам нужно значение по умолчанию, отличное от null, то используем elvis-оператор ?::
val name = ship?.captain?.name ?: "unknown"Если ничего из этого вам не подходит, и необходимость в NPE крайне велика, то скажите об этом явно:
val x = b?.length ?: throw NullPointerException() // same as below
val x = b!!.length // same as aboveЭто хорошая система лямбд - она идеально сбалансирована между читабельностью и сложностью, благодаря продуманному дизайну, с простым синтаксисом:
val sum = { x: Int, y: Int -> x + y } // type: (Int, Int) -> Int
val res = sum(4,7) // res == 11А вот и толковые решения:
Скобки метода могут быть перемещены или опущены, если лямбда идет последней либо является единственным аргументом метода.
Если мы решили не объявлять аргумент одноаргументной лямбды, он будет неявно объявлен под именем
it.
Эти факты в совокупности делают следующие три строки эквивалентными:
numbers.filter({ x -> x.isPrime() })
numbers.filter { x -> x.isPrime() }
numbers.filter { it.isPrime() }И это позволяет нам писать лаконичный функциональный код - только посмотрите на эту красоту:
persons
.filter { it.age >= 18 }
.sortedBy { it.name }
.map { it.email }
.forEach { print(it) }Система лямбд Kotlin в сочетании с функциями расширения делает его идеальным для создания DSL. Взгляните на Anko в качестве примера DSL, который призван улучшить разработку Android:
verticalLayout {
padding = dip(30)
editText {
hint = “Name”
textSize = 24f
}
editText {
hint = “Password”
textSize = 24f
}
button(“Login”) {
textSize = 26f
}
}17# Поддержка IDE
У вас есть несколько вариантов, если вы собираетесь начать работу с Kotlin, но я настоятельно рекомендую использовать IntelliJ, который поставляется в комплекте с Kotlin - его возможности продемонстрируют все преимущество того, что и язык, и IDE разрабатываются одними и теми же людьми.
В качестве небольшого, но показательного примера, вот что всплыло, когда я впервые попытался скопипастить Java-код со Stack Overflow:
IntelliJ заметит, если вы вставите Java-код в файл Kotlin
Завтра состоится открытое занятие «Основы классов и объектов», на котором мы посмотрим на принципы проектирования классов и их реализации в Kotlin. Поймем, как объектно-ориентированное программирование работает изнутри, создадим свои структуры и посмотрим на возможности языка Kotlin. Спроектируем объектную модель данных. Регистрируйтесь по ссылке.
