Учебник Kotlin для разработчиков Java

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

Фактически, Google объявила в 2017 году, что будет официально поддерживать Kotlin , а не Java, в качестве основного языка для разработки Android.

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

Вот что мы рассмотрим сегодня:

Котлин против Java
Привет, мир с Котлином
Переменные и типы данных Kotlin
Условные обозначения и циклы Котлина
Коллекции Kotlin
Функции Котлина
Функциональное программирование с помощью Kotlin
Чему учиться дальше с Kotlin

Переход на Kotlin в два раза быстрее

Переходите прямо к тому, что вам нужно, не тратя время на основы программирования, которые вы уже знаете.

Ускоренный курс Kotlin для программистов

Котлин против Java

Kotlin – это статически типизированный язык программирования с открытым исходным кодом, разработанный компанией Jetbrains, которая известна созданием IDE IntelliJ IDEA. Цель Kotlin – быть более простым в использовании и лаконичным языком для любого типа проектов.

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

Kotlin уникален тем, что он полностью совместим с кодом Java, что означает, что вы можете использовать существующие библиотеки или фреймворки Java. Код Kotlin может быть преобразован в байт-код JavaScript или Java для использования на виртуальной машине Java (JVM) или разработке Android .

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

По мере того как гибкая разработка становится все более распространенной, такие компании, как Google , Amazon , Netflix, Uber начал нанимать разработчиков Kotlin. Фактически, он занял 4-е место по быстрорастущему языку в 2020 году в годовом отчете Github, а также во многих других отчетных реализациях разработчиков Kotlin.

Статическая типизация :

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

var m : Int = 12

m = 10          // ok

m = "twelve" // error!

m = 10.0        // error!

Нелокальные прыжки :

Kotlin позволяет вам выйти из функции в любом месте.

fun main() {

    intArrayOf(4, 5, 6).forEach lambda@ {
        if (it == 5) return@lambda
        println(it)
    }

    println()

    loop@ for (i in 0 .. 3) {

        for (j in 0 .. 3) {

            if (i + j == 4) continue@loop

            if (i + j == 5) break@loop

            println(i + j)
        }
    }
}

Фильтрация коллекций :

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

val languageArray = arrayOf("Serbian", "Swahili", "Japanese", "German", "Spanish")

val selectedLang = languageArray

.filter { name -> name.startsWith("s", ignoreCase = true) }

//or: .filter { it.startsWith("s", ignoreCase = true) }

.sortedBy { name -> name.length }

.first()

Функции расширения :

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

class Person {
  var firstName = ...
  var lastName = ...
}

// Maybe the author of the Person class forgot to include this

fun Person.setName(firstName: String, lastName: String) {
  this.firstName = firstName
  this.lastName = lastName
}

Функции более высокого порядка :

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

people.filter { person -> person.headCount == 1 }

Отложенная загрузка :

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

Ключевые различия между Kotlin и Java

Котлин

Позволяет осуществлять кросс-платформенный перенос с Kotlin на Android, JVM и многое другое.
Создан с нуля как для функционального программирования, так и для объектно-ориентированного программирования.
Рассчитан на лаконичность.
Встроенное интеллектуальное приведение и неявное приведение.
Невозможно присвоить нулевые значения для обеспечения нулевой безопасности
Готовая поддержка современных функций, таких как сопрограммы, функции расширения и классы данных.

Java :

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

Продолжайте учиться дальше.

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

Ускоренный курс Kotlin для программистов

Привет, мир с Котлином

Давайте взглянем на a Привет, мир программа как на Java, так и на Kotlin, чтобы увидеть различия.

Вы можете написать Kotlin в любой среде разработки Java с помощью плагина Kotlin или даже непосредственно в командной строке.

//java
class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

//kotlin
fun main() {

    println("Hello, World!")

}

Очевидно, что Kotlin более лаконичен, используя только две строки кода. Это связано с тем, что Kotlin позволяет функциям существовать вне классов, а это означает, что нам не нужно объявлять класс HelloWorld .

В строке 1 кода Kotlin мы определяем метод main . Как и в Java, каждой программе нужна функция main . Версия Kotlin 1.3+ удалила входы и выходы из main , чтобы сделать синтаксис более простым и менее визуально загроможденным.
В строке 2 мы печатаем строку Привет, Мир! с помощью встроенной функции println() . Это работает так же, как функция печати Java, но ее не нужно извлекать из внешнего Системного класса.
В конце строки 2 обратите внимание, что в конце строки нет точки с запятой. Kotlin определяет окончание операторов по строкам и не требует точек с запятой.

Переменные и типы данных Kotlin

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

var  =  //mutable

val  =  //read-only

val :  =  // explicit type casting

Переменные в Kotlin очень похожи на переменные в Java, за исключением:

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

Давайте посмотрим, как эти различия выглядят на практике.

Доступные только для чтения и изменяемые переменные:

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

Изменяемые переменные похожи на большинство переменных в Java и могут быть изменены после их инициализации.

Инициализация только для чтения:

val number = 17

println("number = $number")

number = 42  // Not allowed, throws an exception

Изменяемая инициализация:

var number = 17

println("number = $number")

number = 42  // var can be reassigned

println("number = $number")

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

Типы данных Kotlin

В отличие от Java, в Kotlin нет примитивных типов данных. Все следующие типы являются объектами во время выполнения, но переносятся в соответствующие примитивные типы Java в байт-коде Java.

Целочисленные типы

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

val byte: Byte = 127

val short: Short = 32767

val int: Int = 2147483647

val long: Long = 9223372036854775807

Числа с плавающей запятой

Kotlin поддерживает стандартные десятичные и экспоненциальные обозначения. Поплавок и Двойной ведет себя так же, но Double может содержать больше чисел , чем Float . Kotlin smart преобразует любое число с плавающей запятой в Двойной , что означает , что вы должны включить f в конце аргумента , чтобы установить переменную как Float .

val float: Float = 3.4028235e38f

val double: Double = 1.7976931348623157e308

Типы текста

Kotlin поддерживает Java-подобный Типы символов и Строка для представления текста. Вы обозначаете отдельные символы одинарными кавычками, 'c' , а строки – двойными кавычками "эта строка" .

val character: Char = '#'

val text: String = "Learning about Kotlin's data types"

В отличие от Java, Kotlin позволяет легко создавать многострочные строки, используя три набора двойных кавычек, """<Множественные строки>""" . Java предлагает только конкат и разделитель строк для многострочных строк, которые менее лаконичны и требуют специальных реализаций.

Логический тип

Логический тип Kotlin идентичен типу Java в функции.

val yes: Boolean = true

val no: Boolean = false

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

Вывод типа

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

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

Чтобы неявно объявлять типы, отличные от стандартных, вы можете добавить ключ типа в конце значения, например L для типа Длинный ниже:

val string = "Educative"

val int = 27

val long = 42L

val double = 2.71828

val float = 1.23f

val bool = true

Система вывода типов Kotlin очень надежна и позволяет неявно вводить литералы, объекты и сложные структуры, такие как лямбда-выражения .

Условные обозначения и циклы Котлина

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

Все условия определяются с помощью:

 () 

 () { 

}

Если утверждение

Оператор Kotlin if аналогичен оператору Java в том смысле, что он содержит блок кода, который выполняется, если указанное условие становится истинным. Вы также можете добавить оператор else , который выполняется, если оператор if пропущен.

var max = a

if (a < b) max = b

// With else

var max: Int

if (a > b) {

    max = a

} else {

    max = b

}

// As expression

val max = if (a > b) a else b

Когда Заявление

В Kotlin также есть оператор when , который работает аналогично оператору C switch . Оператор when создает несколько ветвей проверок, каждая из которых оценивается для определенного условия.

when (x) {

    1 -> print("x == 1") //branch 1

    2 -> print("x == 2") //branch 2

    else -> { // Note the block

        print("x is neither 1 nor 2")

    }

}

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

Вы можете думать о когда как о нескольких if-else утверждениях, переведенных в более сжатый формат.

Для цикла

Цикл Kotlin for работает как цикл C для каждого цикла , а не как цикл Java для . Он принимает коллекцию, например массив, и выполняет одно и то же действие над каждым элементом коллекции.

Синтаксис для цикла 1 для таков:

for (item in collection) print(item)

for (i in 1..3) {

    println(i)

}

Цикл While

Цикл while выполняет основной код повторно до тех пор, пока не будут выполнены перечисленные условия. Как и в Java, существует два типа цикла while . Стандартный цикл while проверяет условие до выполнения кода, а цикл do-while проверяет после выполнения кода.

while (x > 0) {

    x--

}

do {

    val y = retrieveData()

} while (y != null) // y is visible here!

Коллекции Kotlin

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

Вы можете создавать все коллекции в Kotlin, используя их уникальную функцию конструктора. Все конструкторы используют одно и то же соглашение об именовании, <коллекция> Из(<значение1, значение2, ...>) . Например, вы можете составить список из 2 целых чисел с помощью списка(1, 2) .

Список

Списки представляют собой индексированную линейную структуру данных, аналогичную массивам Java. Индексы начинаются с 0 и перейдите в (список.размер - 1) . В отличие от массивов, списки являются динамическими и могут изменять размер в соответствии с добавленными или удаленными элементами. Списки могут содержать любое количество повторяющихся элементов.

val numbers = listOf("one", "two", "three", "four")

println("Number of elements: ${numbers.size}")

println("Third element: ${numbers.get(2)}")

println("Fourth element: ${numbers[3]}")

println("Index of element \"two\" ${numbers.indexOf("two")}")

Наборы

Набор – это неупорядоченная линейная структура данных, которая не может содержать повторяющихся элементов. Наборы не имеют индексов. Два набора считаются равными, если оба содержат одинаковые уникальные элементы.

val numbers = setOf(1, 2, 3, 4)

println("Number of elements: ${numbers.size}")

if (numbers.contains(1)) println("1 is in the set")

val numbersBackwards = setOf(4, 3, 2, 1)

println("The sets are equal: ${numbers == numbersBackwards}")

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

Массив

Массив не является родным типом данных в Kotlin. Он представлен классом Array. Эти массивы ведут себя так же, как массивы Java: оба содержат изменяемые значения, но имеют фиксированный размер.

Вы можете создать массив с помощью функции массив(<элемент1, элемент2, ...>) .

Например:

val priorities = arrayOf("HIGH", "MEDIUM", "LOW")

println(priorities[1])

priorities[1] = "NORMAL"

println(priorities[1])

println(priorities.size)

Функции Котлина

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

Вот пример синтаксиса функций Kotlin:

fun (: ): 

fun fibonacci(index: Int): Long

Чтобы имитировать поведение возвращаемых типов Java void , вы можете задать тип возвращаемого значения Ничего .

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

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

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

Функции расширения

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

Например, вы можете добавить дополнительное поведение во внешний API, которое помогло бы более тесно интегрировать его с вашим решением.

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

fun MutableList < Int > .swap(index1: Int, index2: Int) {

val tmp = this[index1]

this[index1] = this[index2]

this[index2] = tmp

}

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

Функциональное программирование с помощью Kotlin

Наиболее существенное различие между Kotlin и Java заключается в том, что Kotlin предназначен для функционального программирования, а не только для ООП. Функциональное программирование на Java ограничено. Хотя вы можете имитировать многие функциональные модели поведения в Java, большинство разработчиков согласны с тем, что это неприменимо в реальном мире.

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

// higher order functions

fun main( ) {

val numbers = arrayListOf(15, -5, 11, -39)

val nonNegativeNumbers = numbers.filter{
  it >= 0
 }

println(nonNegativeNumbers) //function as input parameter

}

// lambda expression

val sum: (Int, Int) -> Int = { 
 x, y -> x + y
}
fun main( ) {
    println(sum(5,10))
}

Чему учиться дальше с Kotlin

Поздравляем вас с первыми шагами в Kotlin! Этот развивающийся язык идеально подходит для современных разработчиков и прост в освоении для существующих разработчиков Java.

Теперь вы готовы перейти к промежуточным темам, таким как:

Обнуляемые типы
Условия как выражения
Коллекции карт
Обозначение сокращенной функции
Функции оператора

Чтобы помочь вам быстро перейти на Kotlin, компания Educative создала Ускоренный курс Kotlin для программистов . Этот курс ориентирован на существующих разработчиков Java, что означает, что все уроки являются практическими и подчеркивают особенности языка. К концу вы будете знать, как использовать все основные функции Kotlin, и будете готовы создать свое первое приложение для Android с помощью Android Studio или еще одна программа Kotlin

Счастливого обучения!

Продолжайте читать о Котлине

Оригинал: “https://dev.to/educative/kotlin-tutorial-for-java-developers-2g12”