Kotlin — podstawy składni

Język, w którym piszemy aplikacje na Androida.

Dlaczego Kotlin

Cztery powody, dla których uczymy się właśnie tego języka.

Zmienne: val i var

Dwa słowa zamiast typów. Bez średników na końcu linii.

fun main() {                        // program zaczyna się tutaj
  val imie = "Ola"                  // val = stała — NIE zmienisz
  var punkty = 0                    // var = zmienna — można zmieniać
  punkty = punkty + 10              // ok, bo var
  // imie = "Jan"                   // BŁĄD kompilacji, bo val
  println(imie)                     // wypisz na ekran
}

Typy i wstawianie do tekstu

Typ można podać po dwukropku — ale zwykle Kotlin domyśli się sam.

val a: Int = 7                        // liczba całkowita
val cena: Double = 4.5                // liczba z częścią dziesiętną
val gra: Boolean = true               // prawda / fałsz
val tekst: String = "kości"           // napis

println("Cena: $cena zł")             // $zmienna wstawia wartość
println("Suma: ${a + 2}")             // ${...} — dowolne wyrażenie

Funkcje

Słowo fun, typ wyniku po dwukropku. Na egzaminie logika musi być w funkcjach.

fun dodaj(a: Int, b: Int): Int {        // parametry i typ wyniku
  return a + b                          // zwróć wynik
}

fun kwadrat(x: Int) = x * x             // wersja jednolinijkowa
fun powitaj(imie: String) {             // bez wyniku — nic nie zwraca
  println("Cześć, $imie!")
}

val w = dodaj(2, 3)                     // wywołanie: w == 5

Warunki: if oraz when

if zwraca wartość. when to switch, tylko potężniejszy.

val max = if (a > b) a else b             // if jako wyrażenie!

val opis = when (kostka) {                // when po wartości
  1, 2    -> "mało"                       // kilka wartości naraz
  in 3..5 -> "średnio"                    // zakres
  else    -> "szóstka!"                   // wszystko inne
}

when {                                    // when bez argumentu = łańcuch if-ów
  punkty >= 90 -> println("super")
  else         -> println("grasz dalej")
}

Pętle i zakresy

for chodzi po zakresach i kolekcjach. while — klasycznie.

for (i in 0..4) print(i)                  // 0 1 2 3 4 — koniec WLICZONY
for (i in 0 until 5) print(i)             // 0..4 — jak klasyczny for
for (i in 5 downTo 1) print(i)            // w dół: 5 4 3 2 1
for (i in 0..10 step 2) print(i)          // co 2

val rzuty = intArrayOf(3, 6, 6)           // tablica z gotowymi wartościami
for (r in rzuty) println(r)               // po elementach tablicy

while (punkty < 100) { ... }              // while — bez zmian

Null safety i wczytywanie danych

Zwykły typ nie może być pusty. Chcesz null — dopisz znak zapytania.

var t: String? = null                     // ? = może być null
println(t?.length)                        // ?. = policz, jeśli nie null

val n = readLine()?.toIntOrNull()         // wczytaj tekst i zamień na Int
if (n == null || n !in 3..10) {           // walidacja jak w arkuszu
  println("Błędna liczba!")
}

Tablice, listy i małe magiczne funkcje

Zamiast ręcznych pętli — gotowe operacje na kolekcjach.

val kosci = IntArray(5)                 // tablica 5 zer
kosci[0] = 6                            // dostęp po indeksie, od zera

val lista = mutableListOf(1, 5)         // lista — rośnie w trakcie
lista.add(3)                            // dodaj element

println(kosci.sum())                    // suma elementów
println(kosci.count { it == 6 })        // ile szóstek? it = element
println(lista.filter { it > 2 })        // tylko elementy > 2

Losowanie — serce gry w kości

Jedna linijka, na której stoi całe zadanie z kośćmi.

val rzut = (1..6).random()                  // losowa liczba od 1 do 6

val kosci = IntArray(5)                     // 5 kości
for (i in kosci.indices) {                  // indices = wszystkie indeksy
  kosci[i] = (1..6).random()                // rzut każdą kostką
}

Zadania — play.kotlinlang.org

Otwórz play.kotlinlang.org i pisz.

Zapamiętaj