Lekce 2 - První objektová aplikace v Kotlin - Hello object world

Minulá lekce, Úvod do objektově orientovaného programování v Kotlin, nás uvedla do objektově orientovaného programování. Již víme, že objekty mají atributy a metody. Také víme, že k vytvoření objektu vytvoříme nejprve třídu. Ta je vzorem, podle kterého následně tvoříme její instance.

Na začátku kurzu se základními strukturami jazyka Kotlin jsme si vytvořili program Hello world. Udělejme si nyní podobný program jako úvod do objektově orientovaného programování. Naprogramujme si Hello object world!

Založme si v IntelliJ novou Kotlin aplikaci tak, jak jsme to dělali doposud. Jelikož třídy se v objektových aplikacích organizují do balíčků, přidáme si do aplikace nejprve nový package (balíček). Klikneme pravým tlačítkem myši na složku src v našem projektu a vybereme New -> Package. Balíček si můžete pojmenovat jakkoliv, ale je zvykem, že se obvykle jmenuje podle nějaké domény, kterou vlastníte (např. já jej pojmenuji jako cz.itnetwork, protože je to balíček od itnetwork.cz). O balíčkách se toho dozvíme více v dalších lekcích

Dále si založme soubor v našem nově vytvořeném balíčku, který bude obsahovat naší main() metodu (Postup je téměř stejný jako v první lekci. Místo složky src, ale klikneme pravým tlačítkem myši na náš balíček).

V našem nově vytvořeném souboru Main.kt si definujeme main() metodu, jak jsme již zvyklí z předchozích lekcí.

package cz.itnetwork

fun main(args: Array<String>) {

}

Konečně si můžeme založit naši novou třídu. Klikneme pravým tlačítkem myši v složce src na náš balíček a vybereme New -> Kotlin File/Class

Class pojmenujeme Zdravic a potvrdíme. Pod názvem v dropdown vybereme "Class". Název třídy píšeme vždy velbloudí notací bez mezer a na rozdíl od proměnných má každé slovo velké první písmeno, tedy i první. Název je samozřejmě také bez diakritiky, tu v programu používáme maximálně uvnitř textových řetězců, nikoli v identifikátorech.

Podle této třídy později vytvoříme objekt zdravič, který nás bude umět pozdravit. Vidíme, že se na program již díváme úplně jinak, za každou akci je zodpovědný nějaký objekt, nestačí pouze něco "nabušit" do main(). V našem případě vám to může přijít zbytečné, u složitějších aplikací si to budete pochvalovat

V našem package přibude další soubor .kt a IntelliJ nám ho otevře. K původnímu Main.kt s metodou main() se můžeme vrátit pomocí záložky nebo přes levou záložku Project. Pokud chceme, aby byla naše nová třída Zdravic viditelná i ve výchozím souboru, kde máme metodu main(), musíme ji mít ve stejném balíčku. To naše aplikace nyní splňuje.

Podívejme se, co nám IntelliJ vygeneroval a kód si popišme. Následně si do třídy přidáme vlastní metodu pro pozdravení.

package cz.itnetwork

class Zdravic {
}

V package je tedy umístěná samotná třída, která se deklaruje klíčovým slovem class. Třída se jmenuje Zdravic a je prázdná.

Nyní si do třídy Zdravic přidáme metodu pozdrav(), bude veřejně viditelná a nebude mít žádnou návratovou hodnotu ani atributy.

Deklarace metody v Kotlin je následující:

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

Před metodou může být tzv. modifikátor přístupu, v našem případě public (veřejná). Metoda nebude vracet žádnou hodnotu, toho docílíme tím, že návratový typ nenapíšeme. Dále bude následovat samotný název metody. Metody pojmenováváme stejně jako proměnné velbloudí notací s malým počátečním písmenem. Závorka s parametry je povinná, my ji necháme prázdnou, protože metoda žádné parametry mít nebude. Do těla metody zapíšeme kód pro výpis na konzoli.

Naše třída bude nyní vypadat takto:

package cz.itnetwork

class Zdravic {

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

}

Pokud nenapíšeme modifikátor před metodu, Kotlin pochopí, že metoda má být public, tedy veřejně viditelná. Většinou se tento modifikátor v Kotlin vynechává.

Zde jsme prozatím skončili, přejdeme do Main.kt.

Nyní si v těle metody main() vytvoříme instanci třídy Zdravic. Bude to tedy ten objekt zdravič, se kterým budeme pracovat. Objekty se ukládají do proměnných, název třídy slouží jako datový typ. Instance má zpravidla název třídy, jen má první písmeno malé. Deklarujme si proměnnou a následně v ní založme novou instanci třídy Zdravic:

val zdravic = Zdravic()

Všimněme si, že jazyk Kotlin nemá klíčové slovo new, jak je tomu například v Javě.

Řádek říká: "Chci proměnnou zdravic, ve které bude instance třídy Zdravic" a tuto instanci vytvoříme a následně přiřadíme do naší proměnné. S proměnnými jsme vlastně již takto pracovali.

Při vytvoření nové instance se zavolá tzv. konstruktor. To je speciální metoda na třídě, proto při vytvoření instance píšeme ty prázdné závorky, jelikož voláme tuto "vytvářecí" metodu. Konstruktor zpravidla obsahuje nějakou inicializaci vnitřního stavu instance (např. dosadí výchozí hodnoty do proměnných). My jsme v kódu žádný konstruktor nedeklarovali, Kotlin si proto vytvořil tzv. implicitní bezparametrický konstruktor. Vytvoření instance objektu je tedy podobné volání metody.

Jelikož v proměnné nyní máme opravdu instanci třídy Zdravic, můžeme instanci nechat pozdravit. Zavoláme na ni metodu pozdrav() a to jako zdravic.pozdrav(). Kód metody main() bude tedy nyní vypadat následovně:

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

{KOTLIN_OOP}

class Zdravic {

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

}

{/KOTLIN_OOP}

Program spustíme. Výstup bude následující:

Hello object world!

Máme tedy svou první objektovou aplikaci v Kotlin!

Dejme nyní naší metodě pozdrav() parametr jmeno, aby dokázala pozdravit konkrétního uživatele:

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

Vidíme, že syntaxe parametru metody je stejná, jako syntaxe proměnné. Kdybychom chtěli parametrů více, oddělujeme je čárkou. Upravíme nyní naši metodu main():

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

{KOTLIN_OOP}

class Zdravic {

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

}

{/KOTLIN_OOP}

Náš kód je nyní v metodě a my ho můžeme jednoduše pomocí parametrů volat znovu s různými parametry. Nemusíme 2x opisovat "Ahoj uživateli...". Kód budeme odteď dělit logicky do metod.

Výstup:

Ahoj uživateli Karel
Ahoj uživateli Petr

Třídě přidáme nějaký atribut, nabízí se text, kde bude uložen text pozdravu. Atributy se definují stejně, jako proměnné. Stejně jako u metod platí, že před atributy můžeme psát modifikátor přístupu, bez něj je Kotlin bere jako public. Upravme naši třídu:

package cz.itnetwork

class Zdravic {
    var text: String = ""

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

}

Text nyní musíme pochopitelně nastavit vytvořené instanci v Main.kt:

{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}

class Zdravic {
    var text: String = ""

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

}

{/KOTLIN_OOP}

Výsledek:

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

Vzhledem k objektovému návrhu není nejvhodnější, aby si každý objekt ovlivňoval vstup a výstup, jak se mu zachce. Pochopitelně narážím na naše vypisování do konzole. Každý objekt by měl mít určitou kompetenci a tu by neměl překračovat. Pověřme náš objekt pouze sestavením pozdravu a jeho výpis si zpracujeme již mimo, v našem případě v metodě main(). Výhodou takto navrženého objektu je vysoká univerzálnost a znovupoužitelnost. Objekt doposud umí jen psát do konzole, my ho však přizpůsobíme tak, aby daná metoda text pouze vracela a bylo na jeho příjemci, jak s ním naloží. Takto můžeme pozdravy ukládat do souborů, psát na webové stránky nebo dále zpracovávat.

Jelikož chceme, aby metoda vracela hodnotu a to String, přidáme jí datový typ String. K návratu hodnoty použijeme příkaz return. Ten metodu ukončí a navrátí hodnotu, jakýkoli kód v těle metody po return se již neprovede! Upravme obě třídy:

Metoda pozdrav() v Zdravic.kt:

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

Tělo metody main() v Main.kt:

{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}

class Zdravic {
    var text: String = ""

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

}

{/KOTLIN_OOP}

Nyní je náš kód dle dobrých praktik. Ještě naši třídu okomentujme, jak se sluší a patří. Komentáře budeme psát nad název třídy a nad název každého atributu a metody. K jejich zápisu použijeme /** Popisek */. Vyplatí se nám to ve chvíli, když na třídě používáme nějakou metodu, její popis se nám zobrazí v našeptávači. Zdokumentovaná třída může vypadat např. takto:

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 víceřádkový komentář, syntaxe popisků se nazývá Javadoc. Pokud budete své třídy dobře popisovat, programátorskou dokumentaci k aplikaci vytvoříte poté jediným kliknutím.

Podíváme se, že nám IntelliJ opravdu popisky zobrazí:

A jsme u konce. Námi napsaný program má již nějakou úroveň, i když vlastně nic nedělá. Za úkol máte předělat si naši konzolovou kalkulačku do objektů.

V následujícím cvičení, Řešené úlohy k 1.-2. lekci OOP v Kotlin, si procvičíme nabyté zkušenosti z předchozích lekcí.