2. diel - Prvý objektová aplikácie v Kotlin - Hello object world

Minulá lekcie, Úvod do objektovo orientovaného programovania v Kotlin , nás uviedla do objektovo orientovaného programovania. Už vieme, že objekty majú atribúty a metódy. Tiež vieme, že na vytvorenie objektu vytvoríme najprv triedu. Tá je vzorom, podľa ktorého následne tvoríme jej inštancie.

Na začiatku kurzu so základnými štruktúrami jazyka Javy sme si vytvorili program Hello world. Urobme si teraz podobný program ako úvod do objektovo orientovaného programovania. Naprogramujte si Hello object world!

Založme si v IntelliJ novú Kotlin aplikáciu tak, ako sme to robili doteraz. Keďže triedy sa v objektových aplikáciách organizujú do balíčkov, pridáme si do aplikácie najprv nový package (balík). Klikneme pravým tlačidlom myši na priečinok src v našom projekte a vyberieme New -> Package. Balíček si môžete pomenovať akokoľvek, ale je zvykom, že sa zvyčajne volá podľa nejaké domény, ktorú vlastníte (napr. Ja ho pomenujem ako cz.itnetwork, pretože je to balíček od itnetwork.cz). O balíčkoch sa toho dozvieme viac v ďalších lekciách

Ďalej si založme súbor v našom novovytvorenom balíka, ktorý bude obsahovať našej main() metódu (Postup je takmer rovnaký ako v prvej lekcii. Miesto zložky src, ale klikneme pravým tlačidlom myši na náš balíček).

V našom novo vytvorenom súbore Main.kt si definujeme main() metódu, ako sme už zvyknutí z predchádzajúcich lekcií.

package cz.itnetwork

fun main(args: Array<String>) {

}

Konečne si môžeme založiť našu novú triedu. Klikneme pravým tlačidlom myši v priečinku src na náš balíček a vyberieme New -> Kotlin File/Class

Class pomenujeme Zdravic a potvrdíme. Pod názvom v dropdown vyberieme "Class". Názov triedy píšeme vždy ťavie notáciou bez medzier a na rozdiel od premenných má každé slovo veľké prvé písmeno, teda aj prvé. Názov je samozrejme tiež bez diakritiky, tú v programe používame maximálne vnútri textových reťazcov, nie v identifikátoroch.

Podľa tejto triedy neskôr vytvoríme objekt Zdravice, ktorý nás bude vedieť pozdraviť. Vidíme, že sa na program už pozeráme úplne inak, za každú akciu je zodpovedný nejaký objekt, nestačí iba niečo "nabušit" do main(). V našom prípade vám to môže prísť zbytočné, pri zložitejších aplikácií si to budete pochvaľovať

V našom package pribudne ďalší súbor .kt a IntelliJ nám ho otvorí. K pôvodnému Main.kt s metódou main() sa môžeme vrátiť pomocou záložky alebo cez ľavú záložku Project. Ak chceme, aby bola naša nová trieda Zdravic viditeľná aj v predvolenom súbore, kde máme metódu main(), musíme ju mať v rovnakom balíčku. To naše aplikácie teraz spĺňa.

Pozrime sa, čo nám IntelliJ vygeneroval a kód si popíšme. Následne si do triedy pridáme vlastnú metódu pre pozdravenie.

package cz.itnetwork

class Zdravic {
}

V package je teda umiestnená samotná trieda, ktorá sa deklaruje kľúčovým slovom class. Trieda sa volá Zdravic a je prázdna.

Teraz si do triedy Zdravic pridáme metódu pozdrav(), bude verejne viditeľná a nebude mať žiadnu návratovú hodnotu ani atribúty.

Deklarácia metódy v Kotlin je nasledovné:

[modifikátor přístupu] [jmenoMetody]([parametry]) : [návratový typ]

Pred metódou môže byť tzv. Modifikátor prístupu, v našom prípade public (verejná). Metóda nebude vracať žiadnu hodnotu, toho docielime tým, že návratový typ nenapíšeme. Ďalej bude nasledovať samotný názov metódy. Metódy pomenovávame rovnako ako premenné ťavej notáciou s malým začiatočným písmenom. Zátvorka s parametrami je povinná, my ju necháme prázdnu, pretože metóda žiadne parametre mať nebude. Do tela metódy zapíšeme kód pre výpis na konzolu.

Naša trieda bude teraz vyzerať takto:

package cz.itnetwork

class Zdravic {

    fun pozdrav() {
        println("Hello object world!")
    }

}

Ak nenapíšeme modifikátor pred metódu, Kotlin pochopí, že metóda má byť public, teda verejne viditeľná. Väčšinou sa tento modifikátor v Kotlin vynecháva.

Tu sme zatiaľ skončili, prejdeme do Main.kt.

Teraz si v tele metódy main() vytvoríme inštanciu triedy Zdravic. Bude to teda ten objekt Zdravice, s ktorým budeme pracovať. Objekty sa ukladajú do premenných, názov triedy slúži ako dátový typ. Inštancia má spravidla názov triedy, len má prvé písmeno malé. Vyhlásiť si premennú a následne v nej založme novú inštanciu triedy Zdravic:

val zdravic = Zdravic()

Všimnime si, že jazyk Kotlin nemá kľúčové slovo new, ako je tomu napríklad v Jave.

Riadok hovorí: "Chcem premennú zdravic, v ktorej bude inštancie triedy Zdravic " a túto inštanciu vytvoríme a následne priradíme do našej premennej. S premennými sme vlastne už takto pracovali.

Pri vytvorení novej inštancie sa zavolá tzv. Konštruktor. To je špeciálna metóda na triede, preto pri vytvorení inštancie píšeme tie prázdne zátvorky, keďže voláme túto "vytvárajúci" metódu. Konštruktor spravidla obsahuje nejakú inicializáciu vnútorného stavu inštancie (napr. Dosadí východiskové hodnoty do premenných). My sme v kóde žiadny konštruktor nedeklaroval, Kotlin si preto vytvoril tzv. Implicitné bezparametrický konštruktor. Vytvorenie inštancie objektu je teda podobné volanie metódy.

Keďže v premennej teraz máme naozaj inštanciu triedy Zdravic, môžeme inštanciu nechať pozdraviť. Zavoláme na ňu metódu pozdrav() a to ako zdravic.pozdrav(). Kód metódy main() bude teda teraz vyzerať nasledovne:

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
val zdravic = Zdravic()
zdravic.pozdrav()
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}

class Zdravic {

    fun pozdrav() {
        println("Hello object world!")
    }

}

{/KOTLIN_OOP}

Program spustíme. Výstup bude nasledujúci:

Hello object world!

Máme teda svoju prvú objektovú aplikáciu v Kotlin!

Dajme teraz našej metóde pozdrav() parameter jmeno, aby dokázala pozdraviť konkrétneho užívateľa:

fun pozdrav(jmeno: String) {
        println("Ahoj uživateli $jmeno")
}

Vidíme, že syntax parametra metódy je rovnaká, ako syntaxe premenné. Keby sme chceli parametrov viac, oddeľujeme ich čiarkou. Upravíme teraz našu metódu main():

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
val zdravic = Zdravic()
zdravic.pozdrav("Karel")
zdravic.pozdrav("Petr")
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}

class Zdravic {

    fun pozdrav(jmeno: String) {
        println("Ahoj uživateli $jmeno")
    }

}

{/KOTLIN_OOP}

Náš kód je teraz v metóde a my ho môžeme jednoducho pomocou parametrov volať znova s rôznymi parametrami. Nemusíme 2x opisovať "Ahoj užívateľovi ...". Kód budeme odteraz deliť logicky do metód.

výstup:

Ahoj uživateli Karel
Ahoj uživateli Petr

Triede pridáme nejaký atribút, ponúka sa text, kde bude uložený text pozdravu. Atribúty sa definujú rovnako, ako premenné. Rovnako ako u metód platí, že pred atribúty môžeme písať modifikátor prístupu, bez neho je Kotlin berie ako public. Upravme našu triedu:

package cz.itnetwork

class Zdravic {
    var text: String = ""

    fun pozdrav(jmeno: String) {
        println("$text $jmeno")
    }

}

Text teraz musíme pochopiteľne nastaviť vytvorené inštanciu v Main.kt:

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
val zdravic = Zdravic()
zdravic.text = "Ahoj uživateli"
zdravic.pozdrav("Karel")
zdravic.pozdrav("Petr")
zdravic.text = "Vítám tě tu programátore"
zdravic.pozdrav("Richard")
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}

class Zdravic {
    var text: String = ""

    fun pozdrav(jmeno: String) {
        println("$text $jmeno")
    }

}

{/KOTLIN_OOP}

výsledok:

Ahoj uživateli Karel
Ahoj uživateli Petr
Vítám tě tu programátore Richard

Vzhľadom k objektovému návrhu nie je najvhodnejšie, aby si každý objekt ovplyvňoval vstup a výstup, ako sa mu zachce. Pochopiteľne narážam na naše vypisovanie do konzoly. Každý objekt by mal mať určitú kompetenciu a tú by nemal prekračovať. Povera náš objekt iba zostavením pozdravu a jeho výpis si spracujeme už mimo, v našom prípade v metóde main(). Výhodou takto navrhnutého objektu je vysoká univerzálnosť a znovupoužitelnost. Objekt doposiaľ vie len písať do konzoly, my ho však prispôsobíme tak, aby daná metóda text iba vracala a bolo na jeho príjemcovi, ako s ním naloží. Takto môžeme pozdravy ukladať do súborov, písať na webové stránky alebo ďalej spracovávať.

Keďže chceme, aby metóda vracala hodnotu a to String, pridáme jej dátový typ String. K návratu hodnoty použijeme príkaz return. Ten metódu ukončí a navráti hodnotu, akýkoľvek kód v tele metódy po return sa už nevykoná! Upravme obe triedy:

Metóda pozdrav() v Zdravic.kt:

fun pozdrav(jmeno: String): String {
    return "$text $jmeno"
}

Telo metódy main() v Main.kt:

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
val zdravic = Zdravic()
zdravic.text = "Ahoj uživateli"
println(zdravic.pozdrav("Karel"))
println(zdravic.pozdrav("Petr"))
zdravic.text = "Vítám tě tu programátore"
println(zdravic.pozdrav("Richard"))
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}

class Zdravic {
    var text: String = ""

    fun pozdrav(jmeno: String): String {
        return "$text $jmeno"
    }

}

{/KOTLIN_OOP}

Teraz je náš kód podľa dobrých praktík. Ešte našu triedu Okomentujte, ako sa sluší a patrí. Komentáre budeme písať nad názov triedy a nad názov každého atribútu a metódy. K ich zápisu použijeme /** Popisek */. Oplatí sa nám to vo chvíli, keď na triede používame nejakú metódu, jej popis sa nám zobrazí v našepkávač. Zdokumentovaná trieda môže vyzerať napr. Nasledovne:

package cz.itnetwork

/** Třída reprezentuje zdravič, který slouží ke zdravení uživatelů */
class Zdravic {
    /** Text pozdravu */
    var text: String = ""

    /**
     * Pozdraví uživatele textem pozdravu a jeho jménem
     * @param  jmeno  Jméno uživatele
     * @return      Text s pozdravem
     */
    fun pozdrav(jmeno: String): String {
        return "$text $jmeno"
    }

}

/** */ je viacriadkový komentár, syntaxe popiskov sa nazýva Javadoc. Ak budete svoje triedy dobre popisovať, programátorskú dokumentáciu k aplikácii vytvoríte potom jediným kliknutím.

Pozrieme sa, že nám IntelliJ naozaj popisky zobrazí:

A sme u konca. Nami napísaný program má už nejakú úroveň, aj keď vlastne nič nerobí. Za úlohu máte prerobiť si našu konzolovú kalkulačku do objektov. V budúcej lekcii, Riešené úlohy k 1.-2. lekciu OOP v Kotlin , si urobíme takú jednoduchú hračku, necháme dva objekty (bojovníkmi) súperiť v aréne (tiež objektu). Máte sa na čo tešiť

V nasledujúcom cvičení, Riešené úlohy k 1.-2. lekciu OOP v Kotlin, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.