9. diel - Companion objects v Kotlin

V predchádzajúcom cvičení, Riešené úlohy k 5.-8. lekciu OOP v Kotlin, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.

V minulej lekcii, Riešené úlohy k 5.-8. lekciu OOP v Kotlin , sme si v praxi vyskúšali dedičnosť a polymorfizmus. Dnes sa v tutoriálu budeme venovať pojmu statika. Až doteraz sme boli zvyknutí, že dáta (stav) nesie inštancie. Atribúty, ktoré sme definovali, teda patrili inštanciu a boli pre každú inštanciu jedinečné. OOP však umožňuje definovať atribúty a metódy na samotnej triede. Týmto prvkom hovoríme statické (niekedy triednej) a sú nezávislé na inštanciu.

POZOR! Dnešné lekcie vám ukáže statiku, teda postupy, ktoré v podstate narušujú objektový model. OOP je obsahuje len pre špeciálne prípady a všeobecne platí, že všetko ide napísať bez statiky. Vždy musíme starostlivo zvážiť, či statiku naozaj nutne potrebujeme. Všeobecne by som odporúčal statiku vôbec nepoužívať, ak si nie ste úplne istí, čo robíte. Podobne, ako globálne premenné je statika v objektovom programovaní niečo, čo umožňuje písať zlý kód a porušovať dobré praktiky. Dnes si ju teda skôr vysvetlíme, aby ste pochopili určité metódy a triedy v Kotlinu, ktoré ju používajú. Znalosti použite s rozvahou, na svete bude menej zla.

Statické (triedny) atribúty

Ako statické môžeme označiť rôzne prvky. Začnime u atribútov. Ako som sa už v úvode spomenul, statické prvky patrí triede, nie inštanciu. Dáta v nich uložené teda môžeme čítať bez ohľadu na to, či nejaká inštancia existuje. V podstate môžeme povedať, že statické atribúty sú spoločné pre všetky inštancie triedy, ale nie je to presné, pretože s inštanciami naozaj vôbec nesúvisí.

Založme si nový projekt (názov napr. Statika) a urobme si jednoduchú triedu Uzivatel:

class Uzivatel(private val jmeno: String, private val heslo: String) {

    private var prihlaseny = false

    fun prihlasSe(zadaneHeslo: String) {
        if (zadaneHeslo == heslo)
            prihlaseny = true
        else
            prihlaseny = false
    }

}

Trieda je pomerne jednoduchá, reprezentuje používateľa nejakého systému. Každá inštancia používateľa má svoje meno, heslo a tiež sa o ňu vie, či je prihlásená alebo nie. Aby sa používateľ prihlásil, zavolá sa na ňom metóda prihlasSe() a v jej parametra sa odovzdá heslo, ktoré človek za klávesnicou zadal. Metóda overí, či ide naozaj o tohto používateľa a pokúsi sa ho prihlásiť. Vráti true / false podľa toho, či prihlásenie prebehlo úspešne. V reáli by sa Vaše heslo ešte tzv. Hashovalo, ale to tu vynecháme.

Keď sa používateľ registruje, systém mu napíše, akú minimálnu dĺžku musí jeho heslo mať. Toto číslo by sme mali mať niekde uložené. Vo chvíli, keď používateľa registrujeme, tak ešte nemáme k dispozícii jeho inštanciu. Objekt nie je vytvorený a vytvoria sa až po vyplnení formulára. Nemôžeme teda v triede Uzivatel na tento účel použiť verejný atribút minimalniDelkaHesla. Samozrejme by bolo veľmi prínosné, keby sme mali údaj o minimálnej dĺžke hesla uložený v triede Uzivatel, pretože k nemu logicky patrí. Údaj uložíme do statického atribútu pomocou bloku companion object:

class Uzivatel(private val jmeno: String, private val heslo: String) {

    private var prihlaseny: Boolean

    init {
        prihlaseny = false
    }

    // Zbytek implementace...

    companion object {
        val minimalniDelkaHesla = 6
    }
}

Teraz sa presuňme do Main.kt a skúsme si atribút vypísať. K atribútu teraz pristúpime priamo cez triedu:

{KOTLIN_OOP}
fun main(args: Array<String>) {
    println(Uzivatel.minimalniDelkaHesla)
}
{/KOTLIN_OOP}
{KOTLIN_OOP}
class Uzivatel(private val jmeno: String, private val heslo: String) {

    private var prihlaseny = false

    fun prihlasSe(zadaneHeslo: String) {
        if (zadaneHeslo == heslo)
            prihlaseny = true
        else
            prihlaseny = false
    }

    companion object {
        val minimalniDelkaHesla = 6
    }
}
{/KOTLIN_OOP}

Ako už bolo povedané, Java môže používať kotlinovské triedy. Ak by sme chceli z Javy používať statické premenné deklarované v Kotlin, museli by sme v Kotlin najprv každú z nich označiť anotácií @JvmStatic, teda napísať nad ňou tento text. Pretože ale píšeme kód iba pre Kotlin, tento fakt tu vynecháme.

Vidíme, že atribút naozaj patrí triede. Môžeme sa na neho pýtať v rôznych miestach programu bez toho, aby sme mali používateľa vytvoreného. Naopak na inštanciu užívateľa tento atribút nenájdeme:

// tento kód vyvolá chybu
val u = Uzivatel("Tomáš Marný", "heslojeveslo")
println(u.minimalniDelkaHesla)

IntelliJ zahlási chybu a kód sa nezkompiluje.

Číslovanie inštancií

Ako ďalšie praktické využitie statických atribútov sa ponúka číslovanie používateľov. Budeme chcieť, aby mal každý užívateľ pridelené unikátne identifikačné číslo. Bez znalosti statiky by sme si museli strážiť zvonku každej vytvorenie užívateľa a počítať je. My si však môžeme vytvoriť priamo na triede Uzivatel privátne statický atribút dalsiId, kde bude vždy pripravené číslo pre ďalšieho užívateľa. Prvý užívateľ bude mať id 1, druhý 2 a tak ďalej. Používateľovi teda pribudne nový atribút id, ktorý sa v konstruktoru nastaví podľa hodnoty dalsiId. Poďme si to vyskúšať:

class Uzivatel(private val jmeno: String, private val heslo: String) {

    private var prihlaseny: Boolean
    val id: Int

    init {
        prihlaseny = false
        id = dalsiId
        dalsiId++
    }

    // Zbytek implementace...

    companion object {
        private var dalsiId = 1
        val minimalniDelkaHesla = 6
    }
}

Trieda si sama ukladá, aké bude id ďalší jej inštancie. Toto id priradíme nové inštanciu v konstruktoru a zvýšime ho o 1, aby bolo pripravené pre ďalšiu inštanciu. Statické však nemusí byť len atribúty, možnosti sú oveľa väčšie.

Statickej metódy

Statické metódy sa volajú na triede. Ide najmä o pomocné metódy, ktoré potrebujeme často používať a neoplatí sa nám tvoriť inštanciu. Kotlín síce umožňuje vytvoriť aj len tzv. Funkciu, ktorú nevoláme ani na inštanciu, ani na triede (takto používame napr. Funkciu println()), ale je oveľa výhodnejšie zoskupovať funkcie na triedy, s ktorými súvisia. Tak nám ich bude IntelliJ aj oveľa lepšie napovedať a budeme si môcť pomocou Ctrl + Space vyvolať zoznam toho, čo všetko môžeme na danej triede volať.

Ukážme si opäť reálny príklad. Pri registrácii používateľa potrebujeme poznať minimálnu dĺžku hesla ešte pred jeho vytvorením. Bolo by tiež dobré, keby sme mohli pred jeho vytvorením aj heslo skontrolovať, či má správnu dĺžku, neobsahuje diakritiku, je v ňom aspoň jedno číslo a podobne. Na tento účel si vytvoríme pomocnú statickú metódu zvalidujHeslo():

companion object {
    private var dalsiId = 1
    val minimalniDelkaHesla = 6

    fun zvalidujHeslo(heslo: String): Boolean {
        if (heslo.length >= minimalniDelkaHesla)
            return true
        else
            return false
    }
}

Opäť si skúsime, že metódu môžeme na triede Uzivatel zavolať:

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
println(Uzivatel.zvalidujHeslo("heslojeveslo"))
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}
class Uzivatel(private val jmeno: String, private val heslo: String) {

    private var prihlaseny: Boolean
    val id: Int

    init {
        prihlaseny = false
        id = dalsiId
        dalsiId++
    }

    fun prihlasSe(zadaneHeslo: String) {
        if (zadaneHeslo == heslo)
            prihlaseny = true
        else
            prihlaseny = false
    }

    companion object {
        private var dalsiId = 1
        val minimalniDelkaHesla = 6

        fun zvalidujHeslo(heslo: String): Boolean {
            if (heslo.length >= minimalniDelkaHesla)
                return true
        else
            return false
        }
    }
}
{/KOTLIN_OOP}

Pozor! Vďaka tomu, že metóda zvalidujHeslo() náleží triede, nemôžeme v nej pristupovať k žiadnym inštančným atribútom. Tieto atribúty totiž neexistujú v kontexte triedy, ale inštancie. Pýtať sa na jmeno by v našej metóde nemalo zmysel! Môžete si skúsiť, že to naozaj nejde.

Rovnaké funkčnosti pri validácii heslá samozrejme môžeme dosiahnuť aj bez znalosti statiky. Vytvorili by sme si nejakú triedu, napr. ValidatorUzivatelu a do nej napísali tieto metódy. Museli by sme potom vytvoriť jej inštanciu, aby sme metódy mohli volať. Bolo by to trochu mätúce, pretože logika užívateľa by bola zbytočne rozdelená do dvoch tried, keď môže byť za pomoci statiky pohromade.

U príklade sa statickým atribútom minimalniDelkaHesla sme neporušili zapuzdrenie, pretože sme nastavili atribút ako val.

A vyskúšame si ešte nakoniec naše statické vlastnosti. Metóda main() bude vyzerať takto:

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
val u = Uzivatel("Tomáš Marný", "heslojeveslo")
println("ID prvního uživatele: ${u.id}")
val v = Uzivatel("Josef Nový", "csfd1fg")
println("ID druhého uživatele: ${v.id}")
println("Minimální délka hesla uživatele je: ${Uzivatel.minimalniDelkaHesla}")
println("""Validnost hesla "heslo" je: ${Uzivatel.zvalidujHeslo("heslo")}""")
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}
class Uzivatel(private val jmeno: String, private val heslo: String) {

    private var prihlaseny: Boolean
    val id: Int

    init {
        prihlaseny = false
        id = dalsiId
        dalsiId++
    }

    fun prihlasSe(zadaneHeslo: String) {
        if (zadaneHeslo == heslo)
            prihlaseny = true
        else
            prihlaseny = false
    }

    companion object {
        private var dalsiId = 1
        val minimalniDelkaHesla = 6

        fun zvalidujHeslo(heslo: String): Boolean {
            if (heslo.length >= minimalniDelkaHesla)
                return true
        else
            return false
        }
    }
}
{/KOTLIN_OOP}

A výstup bude:

ID prvního uživatele: 1
ID druhého uživatele: 2
Minimální délka hesla uživatele je: 6
Validnost hesla "heslo" je: false

Privátne konštruktor

Ak sa nám vyskytne trieda, ktorá obsahuje len pomocné metódy alebo nemá zmysel od ňu tvoriť inštancie (napr. Nikdy nebudeme mať 2 konzoly), hovoríme o ňu niekedy ako o statické triede / objektu. Kotlín umožňuje priamo označiť triedu ako statickú kľúčovým slovíčkom object. Tento objekt potom nemožno instanciovat (nemožno teda vytvoriť inštanciu také triedy).

Poďme si vytvoriť testovací objekt A, ktorý nepôjde instanciovat. Kľúčovým slovom object nahradíme slovo class:

object A {
    // Zde bychom mohli psát naše metody a atributy
}

Poďme si skúsiť objekt A inicializovať:

val a = A()

Dostaneme vyhubováno, keďže má instanciaci zakázanú. Objekt má všetky prvky statické a teda nedáva zmysel od neho tvoriť inštanciu, tá by nič neobsahovala.

Kotlín podporuje aj statický konštruktor, ktorý sa zavolá vo chvíli, keď je trieda zaregistrovaná. Vytvára sa rovnako ako konštruktor v triede, len bude v objekte.

object A {
    init {
        // Zde bychom měli náš statický konstruktor
    }
    // Zde bychom mohli psát naše metody a atributy
}

Ak by sme takýto konštruktor chceli mať aj v štandardnej triede a pripraviť si v ňom statické premenné, je to taktiež možné:

class Trida {
    companion object {
        init {
            // Zde bychom měli náš statický konstruktor
        }
        // Zde bychom mohli psát naše metody a atributy
    }
}

Statický register

Poďme si takú jednoduchú statickú triedu vytvoriť. Mohlo by sa jednať o triedu, ktorá obsahuje len pomocné metódy a atribúty. Ja som sa však rozhodol vytvoriť tzv. Statický register. Ukážeme si, ako je možné odovzdávať dôležité dáta medzi triedami, bez toho aby sme museli mať inštanciu.

Majme aplikáciu, povedzme nejakú väčšiu a rozsiahlejšie, napr. Diár. Aplikácia bude obsahovať prepínanie jazyka jej rozhrania, zvolenie používaných záložiek, zložky na ukladanie súborov, farebnej schémy a ešte treba či ju chceme spúšťať pri spustení operačného systému. Bude mať teda nejaká nastavenia, ku ktorým sa bude pristupovať z rôznych miest programu. Bez znalosti statiky by sme museli všetkým objektom (kalendári, úlohám, poznámkam ...) odovzdať v konstruktoru v akom jazyku pracujú, prípadne im dodať týmto spôsobom ďalšie nastavenia, ako prvý deň v týždni (nedeľa / pondelok) a podobne.

Jednou z možností, ako toto riešiť, je použiť na uloženie týchto nastavení objekt. Bude teda prístupná vo všetkých miestach programu a to aj bez vytvorenia inštancie. Obsahovať bude všetky potrebné nastavenia, ktorá si z nej budú objekty ľubovoľne brať. Mohla by vyzerať napr. Nejako takto:

object Nastaveni {
    val jazyk = "CZ"
    val barevneSchema = "cervene"
    val spustitPoStartu = true
}

Skúsme si triedu teraz použiť, aj keď program diár nemáme. Vytvoríme si len na ukážku triedu Kalendar a skúsime si, že v nej máme naozaj bez problému prístup k nastaveniu. Vložíme do nej metódu, ktorá vráti všetky nastavenia:

class Kalendar {

    fun vratNastaveni(): String {
        return "Jazyk: ${Nastaveni.jazyk}\n" +
               "Barevné schéma: ${Nastaveni.barevneSchema}\n" +
               "Spustit po startu: ${Nastaveni.spustitPoStartu}"
    }

}

Následne všetko vypíšeme do konzoly:

{KOTLIN_OOP}
{KOTLIN_MAIN_BLOCK}
val kalendar = Kalendar()
println(kalendar.vratNastaveni())
{/KOTLIN_MAIN_BLOCK}
{/KOTLIN_OOP}
{KOTLIN_OOP}
object Nastaveni {
        val jazyk = "CZ"
        val barevneSchema = "cervene"
        val spustitPoStartu = true
}
{/KOTLIN_OOP}
{KOTLIN_OOP}
class Kalendar {

        fun vratNastaveni(): String {
                return "Jazyk: ${Nastaveni.jazyk}\n" +
                       "Barevné schéma: ${Nastaveni.barevneSchema}\n" +
                       "Spustit po startu: ${Nastaveni.spustitPoStartu}"
    }

}
{/KOTLIN_OOP}

výstup:

Jazyk: CZ
Barevné schéma: cervene
Spustit po startu: true

Vidíme, že inštancia kalendára má naozaj bez problému prístup ku všetkým nastavením programu.

Opäť pozor, tento kód možno nesprávne použiť na odovzdávanie nezapouzdřených dát a používa sa len v špecifických situáciách. Väčšina odovzdávanie dát do inštancie prebieha pomocou parametra v konstruktoru, nie cez statiku.

Statika sa veľmi často vyskytuje v návrhových vzoroch, o ktorých sme sa tu už bavili. Sú to postupy, ktoré dovádza objektovo orientované programovanie k dokonalosti ao ktorých sa tu určite ešte zmienime. Pre dnešok je toho však už dosť V budúcej lekcii, Riešené úlohy k 9. lekcii OOP v Kotlin , sa pozrieme na vlastnosti v Kotlinu.

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

 

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.