2. diel - Prvý objektová aplikácie vo Swift

Minulá lekcie, Úvod do objektovo orientovaného programovania vo Swift , 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 sa základnými konštrukciami jazyka Swift 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 Xcode novú konzolovú aplikáciu (Command Line Tool) tak, ako sme to robili doteraz. V Project navigator naľavo (výpis súboru projektu) klikneme pravým tlačidlom myši na priečinok nášho projektu a vyberieme "New File ...".

V zobrazenom dialógu vyberieme možnosť "Swift File" a pokračujeme kliknutím na "Next". Nový súbor pomenujeme Zdravic.swift a potvrdíme. 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 max. Vnútri textových reťazcov, nie v identifikátoroch.

Máme pred sebou nový zdrojový súbor. V zakomentované časti môžete vidieť napr. Informácie o dátume vytvorenie a nechýba import Foundation pre import základnej časti jazyka Swift. Triedu si musíme deklarovať sami, nie je to ale nič ťažké:

class Zdravic {

}

Podľa tejto triedy neskôr vytvoríme objekt zdravic, 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 súboru main.swift. 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ť

Vo Swift nie sú triedy zaradené do balíčkov alebo menných priestorov, ako je tomu v niektorých ostatných programovacích jazykoch. Namiesto toho je základnou jednotkou Swift súbor, pričom nie je nutné mať všetok kód vnútri nejaké triedy. Prakticky sa tak často vytvára napr. Súbor Constants.swift, kde sú iba String konštanty deklarované pomocou let, aby boli na jednom mieste a nemohli ste si omylom spôsobiť problémy preklepom.

Druhou "jednotka" v jazyku Swift sú moduly. Apple je definuje ako "single unit of distribution". Modul je skrátka niečo, čo v sebe obsahuje zamýšľanú funkcionalitu a dá sa použiť v rôznych programoch. Náš nový projekt je vlastne tiež modul sám o sebe, ale nedáva zmysel ho využiť v iných aplikáciách. Rovnako tak Foundation je modul, alebo neskôr UIKit, ktorý sa importuje ako základ v iOS aplikáciách miesto Foundation (pretože Foundation obsahuje).

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

Deklarácia metódy vo Swift je teda nasledovné:

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

Pred metódou nemusí byť tzv. Modifikátor prístupu, ako predvolený používa Swift modifikátor internal, ktorý znamená prístup v rámci modulu (takže v našom prípade celá konzolová aplikácie). Ďalej bude nasledovať samotný názov metódy, metódy píšeme rovnako ako triedy ťavej notáciou s malým poč. 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:

class Zdravic {

    func pozdrav() {
        print("Hello object world!")
    }

}

Tu sme zatiaľ skončili, prejdeme do main.swift.

Teraz si v súbore main vytvoríme inštanciu triedy Zdravic. Bude to teda ten objekt zdravic, 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:

let zdravic : Zdravic
zdravic = Zdravic()

Prvý riadok hovorí: "Chcem premennú zdravic, v ktorej bude inštancie triedy Zdravic ". S premennými sme vlastne už takto pracovali. Na prvom riadku vykonávame iba deklaráciu, takže možno využiť let. Po prvom priradení už nebude možné do premennej zdravic priradiť novú inštanciu.

Na druhom riadku založíme novú inštanciu triedy Zdravic pomocou okrúhlych zátvoriek. Túto inštanciu priradíme do našej premennej.

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, Swift si preto vytvoril tzv. Implicitné bezparametrický konštruktor. Vytvorenie inštancie objektu je teda podobné volanie metódy. Celý zápis môžeme samozrejme skrátiť na:

let zdravic = Zdravic()

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 súbor main.swift bude teda teraz vyzerať nasledovne:

{SWIFT}

let zdravic : Zdravic
zdravic = Zdravic()

zdravic.pozdrav()
{/SWIFT}
{SWIFT}
class Zdravic {

    func pozdrav() {
        print("Hello object world!")
    }
}
{/SWIFT}

Program spustíme.

Hello object world!

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

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

func pozdrav(jmeno: String) {
        print("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 náš súbor main.swift:

{SWIFT}
let zdravic : Zdravic
zdravic = Zdravic()

zdravic.pozdrav(jmeno: "Karel")
zdravic.pozdrav(jmeno: "Petr")
{/SWIFT}
{SWIFT}
class Zdravic {

    func pozdrav(jmeno: String) {
        print("Ahoj uživateli \(jmeno)!")
    }
}
{/SWIFT}

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. Odlišnosťou od radu jazykov je vo Swift prítomnosť názvov parametrov pri volaní metódy. V našom prípade jmeno, bez neho nebude program fungovať. Ak by sme chceli dať názvy parametrov preč z volania, využijeme v deklarácii metódy _ pred názvom parametra. Pri volaní ho potom písať nebudeme.

func pozdrav(_ jmeno: String) {
     print("Ahoj uživateli \(jmeno)!")
}

Volanie metódy by vyzeralo takto:

zdravic.pozdrav("Karel")

výstup:

Ahoj uživateli Karel!
Ahoj uživateli Petr!

Triede pridáme nejakú vlastnosť, ponúka sa text, kde bude uložený text pozdravu. Vlastnosti sa definujú rovnako, ako premenné. Ako u metód platí, že pred nich píšeme modifikátor prístupu, bez neho je Swift opäť berie ako internal, čo nám vyhovuje. Upravme našu triedu:

class Zdravic {

    var text: String = ""

    func pozdrav(_ jmeno: String) {
        print("\(text) \(jmeno)!")
    }
}

Vlastnosť text sme si nastavili na prázdny String, pretože inak by sme museli riešiť Optional alebo vlastné konštruktor. Text teraz musíme pochopiteľne nastaviť vytvorené inštanciu v main.swift:

{SWIFT}
let 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")
{/SWIFT}
{SWIFT}
class Zdravic {

    var text: String = ""

    func pozdrav(_ jmeno: String) {
        print("\(text) \(jmeno)!")
    }
}
{/SWIFT}

výstup:

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 súbore main.swift. 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 návratový typ String. K návratu hodnoty použijeme príkaz return. Return 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.swift:

func pozdrav(_ jmeno: String) -> String {
        return "\(text) \(jmeno)!"
}

Upravený kód v main.swift:

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

    var text: String = ""

    func pozdrav(_ jmeno: String) -> String {
        return "\(text) \(jmeno)!"
    }
}
{/SWIFT}

Teraz je náš kód podľa dobrých praktík.

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 vo Swift , 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 vo Swift, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.