Programski jezik Kotlin

Kotlin
	Logo
Paradigma	Multi
Začetna izdaja	2011
Oblikoval	JetBrains
Razvijalec	JetBrains
Stabilna izdaja	1.3.61
Tipizacija	Inferred, static, strong
Vplivi	C#; Gosu; Groovy; Java; ML; Python; Scala;
Platforma	JVM, JavaScript, LLVM
OS	Cross-platform
Licenca	Apache License 2.0
Običajna končnica datoteke	.kt; .kts;
Spletna stran	kotlinlang.org

Kotlin je večplatformski, statično pisan programski jezik za splošne namene. Kotlin je bil razvit s popolno notranjo povezanostjo s programskim jezikom Java, zato je njegova standardna knjižnica odvisna od razvoja standardne knjižnice programskega jezika Java. Razvoj programskega jezika Kotlin financirajo podjetja JetBrains in Google preko Kotlin fundacije. Od 17. 5. 2017 naprej je Kotlin na voljo v integriranem razvojnem okolju za razvoj android aplikacij Android Studio kot alternativa javi. Za smiselno delovanje kotlina je potrebno imeti Java Development Kit (JDK).

Vsak program v kotlinu mora imeti vhodno točko tako kot programski jeziki C, C++ in to je funkcija main().

Program pozdravljen svet

fun main() {
    println("Pozdravljen, svet!") // Izpiše 'Pozdravljen, svet!'.
}

Izvajanje programa se torej začne v vhodni točki (funkciji) main(), ki je v našem primeru zgoraj podana brez vhodnih parametrov. Če podamo vhodne parametre funkciji potem navedemo attribute, k izvršitvi .exe prevedenega programa npr. (pozdravljensvet.exe -attributi). Vhodna točka z vhodnimi parametri ima obliko:

fun main(args: Array<String>) {    // args predstavlja attribute kot množico nizov.
    println("Pozdravljen, svet!"); // Izpiše 'Pozdravljen, svet!'.
}

Vsako izjavo (izraz) lahko končamo s podpičjem vendar to ni priporočljivo, saj s tem ustvarjamo redundanco, podpičja uporabljamo eksplicitno takrat kadar tlačimo izraze v isto vrstico, zato da prevajalnik ve kdaj se zaključi izvršitev izraza.

Osnovni podatkovni tipi

Osnovni podatkovni tipi so:

Cela števila:

Byte (velikost 8b = 1B)
Short (velikost 16b = 2B)
Int (velikost 32b = 4B)
Long (velikost 64b = 8B)

Racionalna števila:

Float (velikost 32b = 4B)
Double (velikost 64b = 8B)

Boolova števila:

Boolean (velikost 1b (true ali false)

Znak:

Char (velikost 8b ali 16b = 1B ali 2B)

Niz:

String

Urejena množica:

Array

Komentarji

Komentarji so del programa, ki se ne upošteva med izvajanjem in pred izvajanjem programa, namenjeni so predvsem avtorju za dokumentiranje izvorne kode. V kotlinu tako kot v večini programskih jezikov // predstavlja enovrstični komentar, /* */ pa večvrstični komentar.

// To je enovrstični komentar, saj je napisan samo v eni vrstici.

/*
To je večvrstični komentar,
saj je napisan
v več vrsticah.
*/

Spremenljivke

V kotlinu imamo dva tipa spremenljivk val in var oba tipa se avtomatično specializirata v podatkovni tip vrednosti, ki jo držita. val pred imenom spremenljivke pomeni, da se vrednost te spremenljivke ne spreminja (je konstantna, statična) obratno, če je pred imenom spremenljivke var pomeni, da se spremenljivka res spreminja oziroma, da je uporaba besede spremenljivka v tem primeru upravičena. Primer inicializacije spremenljivk:

fun main() {
    val PI = 3.14    // PI se sama specializira v podatkovni tip Double saj ima vrednost 3.14
    var polmer = 5   // polmer se specializira v podatkovni tip Int saj ima vrednost 5
    var obseg = 2 * PI * polmer
    println("PI ima vrednost: $PI")   // $PI predstavlja vrednost konstante PI, ki jo izpišemo v obliki String.
    println("Polmer je: $polmer")     // $ povsod pomeni, da v dobesedni String vstavljamo spremenljivo oz. konstantno vrednost.
    println("Obseg kroga je: $obseg")
    println("3 * Polmer je: ${polmer + polmer + polmer}") // ${ izraz } pomeni, da v dobesedni String vstavljamo izraz, ki se mora ovrednotiti pred izvršitvjo funkcije println().
}

Če želimo eksplicitno povedati podatkovni tip, torej, da se izognemo implicitni prevedbi katero diktira prevajalnik in jo razbere iz dobesedne vrednosti (3.14 -> Double) spremenljivke potem se zgornji primer prepiše v:

fun main() {
    val PI: Double = 3.14 // Ni implicitne prevedbe (spremenljivka je že specializirana v podatkovni tip Double)
    var polmer: Int = 5   // Ni implicitne prevedbe (spremenljivka je že specializitana v podatkovni tip Int)
    var obseg = 2 * PI * polmer
    .
    .
    .
}

Artimetika, Logika & Operatorji

Kotlin ima 5 osnovnih aritmetičnih operatorjev:

x + y (seštevanje),
x - y (odštevanje),
x * y (množenje),
x / y (deljenje) in
x % y (ostanek pri deljenju).

Kotlin ima prireditveni operator x = y, katerega smo uporabili v zgornjih (2) primerih.

Hitri operatorji v kotlinu so:

x += y (dodelitev seštevka (ekvivalentno x = x + y))
x -= y (dodelitev odštevka (ekvivalentno x = x - y))
x *= y (dodelitev zmnožka/produkta (ekvivalentno x = x * y))
x /= y (dodelitev količnika/kvaficienta (ekvivalentno x = x / y))
x %= y (dodelitev ostanka pri deljenju/modula (ekvivalentno x = x % y))

Inkrement in dekrement operatorji:

x++ (dodelitev seštevka vrednosti in 1 (ekvivalentno x = x + 1))
x-- (dodelitev odštevka vrednosti in 1 (ekvivalentno x = x - 1))

Osnovni logični operatorji:

x && y (logični "in")
x || y (logični "ali")
!x (logični "ne")

Operatorji za preverjanje enakosti po vrednosti:

x == y (enakost, vrne true, če je $\mathrm {vrednost} (x)$ enaka $\mathrm {vrednost} (y)$ , drugače false)
x != y (neenakost, vrne true, če $\mathrm {vrednost} (x)$ ni enaka $\mathrm {vrednost} (y)$ , drugače false)

Operatorji za preverjanje enakosti po referenci:

x === y (referenčna enakost, vrne true, če je $\mathrm {refvrednost} (x)$ enaka $\mathrm {refvrednost} (y)$ , drugače false)
x !== y (referenčna neenakost, vrne true, če $\mathrm {refvrednost} (x)$ ni enaka $\mathrm {refvrednost} (y)$ , drugače false)

Primerjalni operatorji:

x < y (strogo manjše)
x > y (strogo večje)
x <= y (manjše ali enako)
x >= y (večje ali enako)

Operator za dostopanje do elementa [] v množici po indeksu M[indeks], kjer je M urejena množica.

Operator za preverjanje null vrednosti x!!, če je x null potem se sproži AssertError.

// Primer, kjer so uporabljeni operatorji.
fun main()
{
    val PI = 3.14
    var polmer = readLine()!!;
    if (!(polmer <= 0) && polmer < 10000) {
        var premer = 2 * polmer
        var obseg = 2 * PI * polmer
        var ploscina = PI * polmer * polmer
        println("Podatki kroga")
        println("Polmer: $polmer")
        println("Premer: $premer")
        println("Obseg: $obseg")
        println("Ploscina: $ploscina")  
    }
    else 
    {
        println("Ta krog je 'čuden'")
    } 
}
// V zgornjem primeru se ne zmeniti preveč za if-stavke uporabljeni so izključno za demonstracijo uporabnosti operatorjev.

Funkcije

Kotlin kot mnogi drugi programski jeziki pozna dva tipa funkcij in sicer, funkcije, ki vrnejo vrednost in tiste ki ne vrnejo vrednosti.

Funkcije, ki vrnejo neko vrednost

V Kotlin-u so funkcije predstavljene s ključno besedo fun kateri sledi ime funkcije in navadni oklepaji v katerih so lahko ali pa ne parametri, ter podatkovni tip, ki ga funkcija vrne. Vsaka funkcija, ki vrne neko vrednost mora vsebovati return besedo s katero povemo, da se je izvajanje funkcije končalo in da naj se vrne sledeča spremenljivka oz. izraz.

fun Seštej(a: Int, b: Int): Int {
    return a + b // Vrnemo vsoto a in b
}
fun main()
{
    println("${Seštej(4, 3)}") // Klic funkcije vrne vrednost v dobesedni String, izpiše 7
}

V zgornjem zgledu smo napisali funkcijo z imenom Seštej, ki vzame dva parametra a, b oba podatkovnega tipa Int in vrne njun seštevek, ki je enako podatkovnega tipa Int. Zgornja funkcija je precej enostavna, zato jo lahko v kotlinu zapisemo v sledeči obliki:

fun Seštej(a: Int, b: Int) = a + b
fun main() {
    println("${Seštej(5, 6)}") // Izpiše 11
}

V tej obliki zapisujemo samo miniaturne funkcije, funkcija se v tem primeru obnaša kot spremenljivka, ki vzame dva parametra in seštevek parametrov dodeli vrednosti spremenljivke.

Funkcije, ki ne vrnejo

Funkcija, ki ne vrne je malo zavajujoče imenovanje, funkcija, ki "ne vrne" namreč vrne podatkovni tip Unit, ki je ekvivalent bolj poznanemu void v programskih jezikih C, C++, Java, ...

fun napišiSporočilo(): Unit {
    println("Sporočam vam...")
}
fun main() {
    napišiSporočilo() // Izpiše 'Sporočam vam...'
}

Vendar je Unit že sam po sebi impliciten, zato v tem primeru redundanten. Spodnja funkcija je enaka.

fun napišiSporočilo() {
    println("Sporočam vam...")
}
fun main() {
    napišiSporočilo() // Izpiše 'Sporočam vam...'
}

Funkcije je mogoče tudi gnezditi kot v sledečem zgledu

fun main() {
    fun pozdraviSvet() : String {
        return "Pozdravljen, svet"
    }
    val steviloSveta = 5 + 7;
    println("${pozdraviSvet()} $steviloSveta !")
}

A PHP Error was encountered