Kotlin — podstawy języka

Kotlin jest dość nowym językiem, ale zgromadził już sporą rzeszę fanów. Pod koniec ubiegłego roku został dodany do Android Studio 3.0. Od tamtego momentu jest oficjalnie wspieranym językiem do tworzenia aplikacji mobilnych w tym środowisku. Wcześniej jedynym wspieranym językiem była Java. Kotlin od Javy różni się znacząco, a szczególnie wygodą użytkowania i objętością kodu. Artykuł przedstawia część możliwości języka Kotlin jak i porównanie podstawowej składni obu języków.

Deklaracje zmiennych

W Kotlinie zmienne są podzielone na val i var. Te przypisywane jednorazowo, tylko do odczytu oznacza się jako val, a te z możliwością zmiany wartości jako var. Podawanie typów tych własności jest opcjonalne jeśli wynika on z kontekstu. Wartości null można przypisać tylko w przypadku, gdy oznaczymy pole jako Nullable co w Kotlinie wykonuje się poprzez dodanie ? na końcu typu. Poniżej przykład deklaracji pól.

// Kotlin
var a: Int = 15
val b = 15 // Int
val c = "" // String
val d: String // wartość do odczytu, przypisana później
var e: Int = null // błąd - Int nie jest Nullable
var f: Int? = null
var g // błąd - brak typu lub wartości
a = 10
b = 10 // błąd - val jest tylko do odczytu
d = ""
d = "" // błąd - d zostało juz przypisane
// Java
Integer a = 15;
final Integer b = 15;
final String c = "";
final String d;
Integer e = null;
Integer f = null;

Podstawowe typy

Typów podstawowych w języku Kotlin jest 8 i składają się one z Double, Float, Long, Int, Short, Byte, Char i Boolean. W przeciwieństwie do Javy poza wartością zmiennej przy porównywaniu jest brany pod uwagę również jej typ. W Javie typy prymitywne są rzutowane podczas operacji co dodatkowo pozwala na porównywanie różnych typów prymitywnych operatorem (==). Tego w Kotlinie nie ma, ale typy liczbowe można konwertować między sobą co pozwala na ich porównanie metodą equals.

var a: Double = 2.15
val b: Float = 15f
val c: Long = 20L
val d: Int = 20
var e: Short = 15
var f: Byte = 10
var g: Char = 'a'
var h: Boolean = true
h = c.equals(d) // false, 20 Long nie jest równe 20 Int
h = c.equals(d.toLong()) // true
h = b.equals(e) // false

Deklaracje funkcji

W Kotlinie funkcje, podobnie do zmiennych, również nie muszą mieć zadeklarowanego typu jeśli wynika on z kontekstu. Wystarczy skorzystać ze skróconego zapisu funkcji. Alternatywą dla typu void z języka Java jest Unit.

// Kotlin
fun getString(): String {
    return "abc"
}
// skrócona wersja
fun getString() = "abc"
fun multiply(a: Int, b: Int): Int {
    return a * b
}
// skrócona wersja
fun multiply(a: Int, b: Int) = a * b
// Java
String getString() {
    return "abc";
}
Integer multiply(Integer a, Integer b) {
    return a * b;
}

Funkcje rozszerzeń

Kolejnym dodatkiem w Kotlinie są funkcje rozszerzeń. Można je wykorzystać zamiast nadpisywania klas lub dodawania statycznych metod z obiektem danej klasy przekazywanym w parametrze. W praktyce wygląda to mniej więcej tak:

// Kotlin
fun Int.duplicate() = this * 2 // skrócony zapis jest opcjonalny
...
var a = 15.duplicate() // 30
a = 100.duplicate() // 200
// Java - alternatywa
static Integer duplicate(Integer arg) {
    return arg * 2;
}
...
int a = duplicate(15); // 30

Domyślne wartości parametrów

Funkcje w Kotlinie mogą mieć domyślne wartości. Podobne rozwiązanie można spotkać w języku C#.

fun getMultipliedInt(a: Int = 10) =  a * 2
fun getMutlipliedInts(a: Int = 10, b: Int = 12) = a * b
...
var b = getMultipliedInt(2) // 4
b = getMultipliedInt() // 20
b = getMultipliedInts(5, 10) // 50
b = getMultipliedInts(1) // 12
b = getMultipliedInts() // 120

Pętle

Podstawowe zastosowanie pętli w języku Kotlin nie różni się znacząco od tego z Javy. Poniżej przykład, który wyświetla zawartość listy. Rezultat jest taki sam dla każdej z pętli.

var items = listOf("a", "b", "c", "d")

for (item in items) { // Java: for (String item : items) {
    println(item)
}
for (i in "abcd") {
    println(i)
}

var index = 0
while (index < items.size) {
    println(items[index])
    index++
}
index = 0
do {
    println(items[index])
    index++
} while (index < items.size)

Zakresy

Kotlin dodatkowo wprowadza zakresy, których w Javie nie ma. Rosnący przedział obustronnie domknięty oznacza się poprzez dwie kropki (..) między liczbami granicznymi, a malejący poprzez downTo. Przedział lewostronnie domknięty oznacza się przez until. Ponadto wykorzystać można step do ustawienia skoku.

val x = 5

val b = x in 1..10 // true
b = x !in 1..10 // false
b = x in 10 downTo 1 // true
b = x in 0..5 // true
b = x in 0 until 5 // false, until nie obejmuje końcowej wartości
b = x in 0..10 step 3 // false, 5 nie ma w {0, 3, 6, 9}
b = x in 0..10 step 5 // true

Zakresy w pętlach

Przedziały liczbowe można w prosty sposób wykorzystać w pętlach. Poniżej kilka przykładów.

for (k in 1..5) { 
    println(k) // [1, 2, 3, 4, 5]
}
val items = listOf("a", "b", "c")
for (index in items.indices) { // równoznaczne z 0..items.size - 1
    println(items[index]) // [a, b, c]
}

for (k in 1..10 step 2) {
    println(k) // [1, 3, 5, 7, 9]
}

for (k in 1 until 6 step 1) {
    println(k) // [1, 2, 3, 4, 5]
}

for (k in 9 downTo 0 step 3) {
    println(k) // [9, 6, 3, 0]
}

Interpolacja typu String

Wartości pól można zamieszczać wewnątrz zmiennej łańcuchowej, podobnie jak w Gradle. W Javie podobny efekt można uzyskać poprzez String.format.

var a = 10
var b = 15
var c = "${a+b}" // "25", Java: String.format("%d", a + b);
c = "$a+$b" // "10+15", Java: String.format("%d+%d", a, b);

Skrócony warunek NotNull

W Kotlinie skorzystać można dodatkowo ze skróconego zapisu sprawdzającego czy wartość zmiennej nie jest nullem. Zapis ten da się zagnieździć dowolną ilość razy. Gdy którykolwiek z obiektów jest nullem to wykona się kod alternatywny (oznaczany ?:).

var values: List<Any>? = null
var count = values?.size ?: 0 // 0
values = listOf(1, 2, 3);
count = values?.size ?: 0 // 3

Wyrażenia if i try

Kotlin obsługuje przypisywanie zmiennych poprzez wyrażenia if i try. W bloku instrukcji można wykonać wiele różnych działań. Wystarczy tylko pamiętać o podaniu wartości na jego końcu.

var a = if (1 > 0) 1 else 0 // a = 1
a = try {
    println("instrukcja")
    5/0
} catch (e: ArithmeticException) {
    7
}
// a = 7

Podsumowanie

Powyższe przykłady ukazują tylko część możliwości jakie daje Kotlin. Wiele z tych możliwości ułatwia pracę na tyle, że warto rozważyć wykorzystanie tego języka w przyszłych projektach. Więcej szczegółów i ciekawostek z Kotlina być może zostanie zaprezentowanych w następnym artykule.