3. diel - Hracia kocka v C# - Zapuzdrenie, konštruktor a Random
V predchádzajúcom cvičení, Riešené úlohy k 1.-2. lekciu OOP v C# .NET, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.
Už vieme tvoriť nové triedy a vkladať do nich atribúty a metódy s parametrami a návratovou hodnotou. V dnešnom C# .NET tutoriále začneme pracovať na sľúbenej aréne, v ktorej budú proti sebe bojovať dvaja bojovníci. Boj bude ťahový (na preskáčku) a bojovník vždy druhému uberie život na základe sily jeho útoku a obrany druhého bojovníka. Simulujeme v podstate stolnú hru, budeme teda simulovať aj hraciu kocku, ktorá dodá hre prvok náhodnosti. Začnime zvoľna a vytvorme si dnes práve túto hraciu kocku. Zároveň sa naučíme ako definovať vlastný konštruktor.
Vytvorenie projektu
Vytvorme si novú konzolovú aplikáciu a pomenujme ju Arena
. K
projektu si pridajme novú class
s názvom Kostka
.
Zamyslime sa nad atribútmi, ktoré kocke dáme. Iste by sa hodilo, keby sme si
mohli zvoliť počet stien kocky (klasicky 6 alebo 10 stien, ako je zvykom pri
tomto type hier). Ďalej bude kocka potrebovať tzv. generátor náhodných
čísel. Ten nám samozrejme poskytne .NET framework, ktorý na tieto účely
obsahuje triedu Random
. Naša trieda bude mať teraz 2
atribúty:
pocetSten
typuint
random
typuRandom
, kde bude náhodný generátor.
Minule sme kvôli jednoduchosti nastavovali všetky atribúty našej triedy
ako public
, teda ako verejne prístupné. Väčšinou sa však
skôr nechce, aby sa dali zvonku modifikovať a používa sa modifikátor
private
. Atribút je potom viditeľný len vo vnútri triedy a
zvonku sa C# tvári, že vôbec neexistuje. Pri návrhu triedy teda nastavíme
všetko na private
av prípade, že niečo bude naozaj potrebné
vystaviť, použijeme public
. Naša trieda teraz vyzerá asi
takto:
/// <summary> /// Trieda reprezentuje hraciu kocku /// </summary> class Kostka { /// <summary> /// Generátor náhodných čísel /// </summary> private Random random; /// <summary> /// Počet stien kocky /// </summary> private int pocetSten; }
Konštruktory
Až doposiaľ sme nevedeli zvonku nastaviť iné atribúty ako
public
, pretože napr. private
nie sú zvonku
viditeľné. Už sme si hovorili niečo málo o konštruktore objektu. Je to
metóda, ktorá sa zavolá vo chvíli vytvorenia inštancie
objektu. Slúži samozrejme na nastavenie vnútorného stavu objektu a
na vykonanie prípadnej inicializácie. Kocku by sme teraz v
Program.cs
vytvorili takto:
Kostka kostka = new Kostka();
Práve Kostka()
je konštruktor. Pretože v našej triede
žiadny nie je, C# si dogeneruje prázdnu metódu. My si však teraz
konštruktor do triedy pridáme. Deklaruje sa ako metóda, ale nemá
návratový typ a musí mať rovnaké meno ako je meno
triedy, v našom prípade teda Kostka
. V konštruktore
nastavíme počet stien na pevnú hodnotu a vytvoríme inštanciu triedy
Random
. Konštruktor bude vyzerať nasledovne:
public Kostka() { pocetSten = 6; random = new Random(); }
Ak kocku teraz vytvoríme, bude mať v atribúte pocetSten
6
av random
bude vytvorená inštancia generátora
náhodných čísel. Vypíšme si počet stien do konzoly, nech vidíme, že tam
hodnota naozaj je. Nie je dobré atribút nastaviť na public
,
pretože nebudeme chcieť, aby nám niekto mohol už pri vytvorenej kocke meniť
počet stien. Pridáme do triedy teda metódu VratPocetSten()
,
ktorá nám vráti hodnotu atribútu pocetSten
. Docielili sme tým
v podstate to, že je atribút read-only (atribút nie je viditeľný a možno
ho iba čítať metódou, zmeniť ho nemožno). C# má na tento účel ešte
ďalšie konštrukcie, ale tým sa zatiaľ nebudeme zaoberať. Nová metóda
bude vyzerať asi takto:
/// <summary> /// Vráti počet stien hracej kocky /// </summary> /// <returns>počet stien hracej kocky</returns> public int VratPocetSten() { return pocetSten; }
Presuňme sa do Program.cs
a vyskúšajme si vytvoriť kocku a
vypísať počet stien:
{CSHARP_CONSOLE} Kostka kostka = new Kostka(); // v tejto chvíli sa zavolá konštruktor Console.WriteLine(kostka.VratPocetSten()); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Kostka { private Random random; private int pocetSten; public Kostka() { pocetSten = 6; random = new Random(); } public int VratPocetSten() { return pocetSten; } } {/CSHARP_OOP}
Výstup:
Konzolová aplikácia
6
Vidíme, že sa konštruktor naozaj zavolal. My by sme ale chceli, aby sme mohli pri každej kocke pri vytvorení špecifikovať, koľko stien budeme potrebovať. Dáme teda kostruktoru parameter:
public Kostka(int aPocetSten) { pocetSten = aPocetSten; random = new Random(); }
Všimnite si, že sme pred názov parametra metódy pridali znak "a",
pretože inak by mal rovnaký názov ako atribút a C# by to zmiatlo. Vráťme
sa k Program.cs
a zadajte tento parameter do konštruktora:
{CSHARP_CONSOLE} Kostka kostka = new Kostka(10); // v tejto chvíli sa zavolá konštruktor s pár. 10 Console.WriteLine(kostka.VratPocetSten()); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Kostka { private Random random; private int pocetSten; public Kostka(int aPocetSten) { pocetSten = aPocetSten; random = new Random(); } public int VratPocetSten() { return pocetSten; } } {/CSHARP_OOP}
Výstup:
Konzolová aplikácia
10
Všetko funguje, ako sme očakávali. C# nám už v tejto chvíli
nevygeneruje prázdny (tzv. bezparametrický konštruktor), takže kocku bez
parametra vytvoriť nemožno. My to však môžeme umožniť, vytvorme si
ďalší konštruktor a tentoraz bez parametra. V ňom nastavíme počet stien
na 6
, pretože takú hodnotu asi užívateľ našej triedy pri
kocke očakáva ako východiskový:
public Kostka() { pocetSten = 6; random = new Random(); }
Skúsme si teraz vytvoriť 2 inštancie kocky, každú iným konštruktorom
(v Program.cs
):
{CSHARP_CONSOLE} Kostka sestistenna = new Kostka(); Kostka desetistenna = new Kostka(10); Console.WriteLine(sestistenna.VratPocetSten()); Console.WriteLine(desetistenna.VratPocetSten()); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Kostka { private Random random; private int pocetSten; public Kostka() { pocetSten = 6; random = new Random(); } public Kostka(int aPocetSten) { pocetSten = aPocetSten; random = new Random(); } public int VratPocetSten() { return pocetSten; } } {/CSHARP_OOP}
Výstup:
Konzolová aplikácia
6
10
C# nevadí, že máme 2 metódy s rovnakým názvom, pretože ich parametre
sú rôzne. Hovoríme o tom, že metóda Kostka()
(teda tu
konštruktor) má preťaženie (overload). To môžeme
využívať aj pri všetkých ďalších metódach, nielen pri konštruktoroch.
Visual Studio nám preťaženie pri metódach
prehľadne ponúka (vo chvíli, keď za názov metódy napíšeme ľavú
zátvorku), variantmi metódy si môžeme listovať pomocou šípok. Tohto
pomocníka nazval MS IntelliSense. V ponuke vidíme naše 2 konštruktory:
Veľa metód v .NETe má hneď niekoľko preťažení, skúste sa pozrieť
napr. na metódu Remove()
na string
u. Je dobré si u
metód prejsť ich preťaženie, aby ste neprogramovali niečo, čo už niekto
urobil pred vami. Napríklad metóda WriteLine()
, ktorú poznáte
na vypisovanie do konzoly, má hneď 18 variantov
Ukážeme si ešte, ako ide obísť nepraktický názov atribútu u
parametrického konštruktora (v našom prípade aPocetSten
) a
potom konštruktory na chvíľu opustíme. Problém je samozrejme v tom, že
keď napíšeme:
public Kostka(int pocetSten) { pocetSten = pocetSten; random = new Random(); }
C# nevie, ktorú z premenných myslíme, či parameter alebo atribút. V
tomto prípade priraďujeme do parametra znovu ten istý parameter. VS nás na
túto skutočnosť dokonca upozorní. Vnútri triedy sa máme možnosť
odkazovať na jej inštanciu, je uložená v premennej
this
. Využitie si môžeme predstaviť napr. keby
kocka mala metódu DejHraci(Hrac hrac)
a tam by volala
hrac.SeberKostku(this)
. Tu by sme hráči pomocou
this
odovzdali seba samého, teda tú konkrétnu
kocku, s ktorou pracujeme. My sa tým tu nebudeme zaťažovať, ale využijeme
odkaz na inštanciu pri nastavovaní atribútu:
public Kostka(int pocetSten) { this.pocetSten = pocetSten; random = new Random(); }
Pomocou this
sme špecifikovali, že ľavá premenná
pocetSten
patrí inštancii, pravú C# chápe ako z parametra.
Máme teda 2 konštruktory, ktoré nám umožňujú tvoriť rôzne hracie kocky.
Prejdime ďalej.
Náhodné čísla
Definujeme na kocke metódu Hod()
, ktorá nám vráti náhodné
číslo od 1
do počtu stien. Je to veľmi jednoduché, metóda
bude public
(pôjde volať zvonku) a nebude mať žiadny parameter.
Návratová hodnota bude typu int
. Náhodné číslo získame tak,
že na generátore zavoláme metódu Next()
. Tá má niekoľko
preťažení:
Next()
: Variant bez parametra vracia náhodné číslo v celom rozsahu dátového typuint
;Next(do)
: Vracajú nezáporné čísla menšie ako medzado
. Napr.random.Next(100)
teda vráti číslo od0
do99
.Next(od, do)
: Vráti náhodné číslo v zadanej medzi, pričomod
do intervalu patrí ado
už nie. Teda náhodné číslo od1
do100
by vrátilorandom.Next(1, 101)
;
/// <summary> /// Vykoná hod kockou /// </summary> /// <returns>Číslo od 1 do počtu stien</returns> public int Hod() { return random.Next(1, pocetSten + 1); }
Dajte si pozor, aby ste netvorili generátor náhodných čísel v metóde,
ktorá má náhodné číslo vracať, teda že by sa pre každé náhodné
číslo vytvoril nový generátor. Výsledné čísla potom nie sú takmer
náhodné alebo dokonca vôbec. Vždy si vytvorte jednu zdieľanú inštanciu
generátora (napr. do privátneho atribútu pomocou konštruktora) a na tej
potom metódu Next()
volajte.
Prekrývanie metódy ToString()
Kocka je takmer hotová, ukážme si ešte jednu užitočnú metódu, ktorú
ju pridáme a ktorú budeme hojne používať aj vo väčšine našich
ďalších objektov. Reč je o metóde ToString()
, o ktorej sme sa
už zmienili a ktorú obsahuje každý objekt, teda aj teraz
naša kocka. Metóda je určená na to, aby vrátila tzv. textovú
reprezentáciu inštancie. Hodí sa vo všetkých prípadoch, keď si
inštanciu potrebujeme vypísať alebo s ňou pracovať ako s textom. Túto
metódu majú napr. aj čísla. Už vieme, že v C# funguje implicitná
konverzia, akonáhle teda budeme chcieť do konzoly vypísať číslo alebo
ktorýkoľvek iný objekt, C# na ňom zavolá metódu ToString()
a
vypíše jej výstup. Ak si robíme vlastnú triedu, mali by sme zvážiť, či
sa nám takáto metóda nehodí. Nikdy by sme si nemali robiť vlastnú metódu,
napr. niečo ako Vypis()
, keď máme v C# pripravenú cestu, ako
toto riešiť. U kocky nemá ToString()
vyšší zmysel, ale u
bojovníka bude určite vracať jeho meno. My si ju ku kocke aj tak pridáme,
bude vypisovať, že sa jedná o kocku a vráti aj počet stien. Najprv si
skúsme vypísať do konzoly našu inštanciu kocky:
{CSHARP_CONSOLE} Kostka sestistenna = new Kostka(); Kostka desetistenna = new Kostka(10); Console.WriteLine(sestistenna); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Kostka { private Random random; private int pocetSten; public Kostka() { pocetSten = 6; random = new Random(); } public Kostka(int pocetSten) { this.pocetSten = pocetSten; random = new Random(); } public int VratPocetSten() { return pocetSten; } public int Hod() { return random.Next(1, pocetSten + 1); } } {/CSHARP_OOP}
Do konzoly sa vypíše iba cesta k našej triede, teda
Arena.Kostka
. Metódu nemôžeme len tak definovať, pretože je
už definovaná (v ďalších lekciách zistíme prečo). Musíme ju teda
prepísať, resp. prekryť. Tým sa opäť nebudeme teraz
podrobne zaoberať, ale chcem, aby sme už teraz vedeli ToString()
používať. Na prekrytie použijeme kľúčové slovo
override
:
{CSHARP_OOP} class Kostka { private Random random; private int pocetSten; public Kostka() { pocetSten = 6; random = new Random(); } public Kostka(int pocetSten) { this.pocetSten = pocetSten; random = new Random(); } public int VratPocetSten() { return pocetSten; } public int Hod() { return random.Next(1, pocetSten + 1); } /// <summary> /// Vracia textovú reprezentáciu kocky /// </summary> /// <returns>Textová reprezentácia kocky</returns> public override string ToString() { return String.Format("Kocka s {0} stenami", pocetSten); } } {/CSHARP_OOP}
{CSHARP_CONSOLE} Kostka sestistenna = new Kostka(); Kostka desetistenna = new Kostka(10); Console.WriteLine(sestistenna); Console.ReadKey(); {/CSHARP_CONSOLE}
Teraz opäť skúsime do konzoly vypísať priamo inštanciu kocky.
Výstup:
Konzolová aplikácia
Kocka s 6 stenami
Ešte si naše kocky vyskúšame. Skúsime si v programe s našimi dvoma kockami v cykloch hádzať a pozrieme sa, či fungujú tak, ako sa očakáva:
{CSHARP_CONSOLE} // vytvorenie Kostka sestistenna = new Kostka(); Kostka desetistenna = new Kostka(10); // hod šesťstennú Console.WriteLine(sestistenna); for (int i = 0; i < 10; i++) Console.Write(sestistenna.Hod() + " "); // hod desaťstennú Console.WriteLine("\n\n" + desetistenna); for (int i = 0; i < 10; i++) Console.Write(desetistenna.Hod() + " "); Console.ReadKey(); // Ak budete spúšťať kód cez náš online kompiler, výsledok // je udržiavaný v medzipamäti a budú padať stále tie isté čísla. // S akoukoľvek zmenou v kóde (napr. aj pridanie komentára) vyvoláte // novú kompiláciu a teda aj vygenerovanie nových čísel. {/CSHARP_CONSOLE}
{CSHARP_OOP} class Kostka { private Random random; private int pocetSten; public Kostka() { pocetSten = 6; random = new Random(); } public Kostka(int pocetSten) { this.pocetSten = pocetSten; random = new Random(); } public int VratPocetSten() { return pocetSten; } public int Hod() { return random.Next(1, pocetSten + 1); } public override string ToString() { return String.Format("Kocka s {0} stenami", pocetSten); } } {/CSHARP_OOP}
Konzolová aplikácia
Kocka s 6 stenami
3 6 6 1 6 3 6 2 6 3
Kocka s 10 stenami
5 9 9 2 10 4 9 3 10 5
Máme hotovú pomerne peknú a nastaviteľnú triedu, ktorá reprezentuje hraciu kocku. Bude sa nám hodiť v našej aréne, ale môžete ju použiť aj kdekoľvek inde. Vidíme, ako OOP umožňuje znovupoužívať komponenty.
V nasledujúcom cvičení, Riešené úlohy k 3. lekcii OOP v C# .NET, 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š.
Stiahnuť
Stiahnutím nasledujúceho súboru súhlasíš s licenčnými podmienkami
Stiahnuté 3112x (2.54 MB)
Aplikácia je vrátane zdrojových kódov v jazyku C#