2. diel - Prvý objektová aplikácie v C # - Hello object world
Minulá lekcie, Úvod do objektovo orientovaného programovania v C # , 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 C # 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 vo Visual Studiu novú konzolovú aplikáciu tak, ako sme to robili doteraz. V Solution Exploreri napravo klikneme pravým tlačidlom myši na náš projekt a vyberieme Add -> Class. Ide to aj klávesouvou skratkou Shift + Alt + C.
Class pomenujeme Zdravic.cs
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.
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 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 Solution Exploreri pribudne ďalší súbor .cs a VS nám ho
otvorí. K pôvodnému Program.cs
s metódou Main()
sa
môžeme vrátiť pomocou záložky alebo cez Solution Explorer.
Pozrime sa, čo nám VS vygenerovalo a kód si popíšme. Následne si do triedy pridáme vlastnú metódu pre pozdravenie.
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace HelloObjects { class Zdravic { } }
Kľúčové slovo namespace
nám označuje tzv.
Menný priestor. Rovnako ako sa metódy združujú do tried, tak sa triedy
združujú do menných priestorov. Ak chceme, aby bola naša trieda viditeľná
aj v Program.cs
, kde máme metódu Main()
, musíme
ju mať v rovnakom mennom priestore. To tu platí, VS samo novú triedu obalí
tým istým menným priestorom, vy miesto HelloObjects
budete mať
názov svojej aplikácie, ak ste ju nepomenovali, bude tam
ConsoleApplication1
.
Príkaz using
nám umožňuje zviditeľniť
triedy iných menných priestorov, aby sme s nimi mohli pracovať. V základe
nám VS pripraví System
, potom generické kolekcie,
Linq
a Text
. Pre nás bude najdôležitejšie
namespace
System
, pretože práve ten obsahuje triedu
Console
. Ďalšie využijeme až neskôr a potom budeme dokonca
potrebovať nejaké dodať, najmä pre prácu s textovými súbormi.
V namespace
je teda umiestnená samotná trieda, ktorá sa
deklaruje kľúčovým slovom class
. Trieda sa volá
Zdravic
a je prázdna.
Všimnite si, že kód je takmer rovnaký, ako ten v Program.cs
, už teda rozumieme tomu, čo sme predtým ignorovali. Náš konzolový program
bola vlastne trieda umiestnená v mennom priestore, ktorá obsahovala jednu
metódu Main()
. Vidíme, že v C # sa v podstate neobjektové
programovať ani nedá, čo je len dobre
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 v C # je teda nasledovné:
[modifikátor prístupu] [návratový typ] [JmenoMetody]([parametre])
Pred metódou bude tzv. Modifikátor prístupu, v našom prípade
public
(verejná). Keby sme modifikátor
vynechali, C # by ju chápal ako private
(neverejné). Metóda
nebude vracať žiadnu hodnotu, toho docielime kľúčovým slovom
void
. Ďalej bude nasledovať samotný názov
metódy, metódy píšeme rovnako ako triedy ťavej notáciou s veľkým poč.
Písmenom. Prvé písmeno názvu je však na rozdiel od premenných veľké!
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 { public void Pozdrav() { Console.WriteLine("Hello object world!"); } }
Tu sme zatiaľ skončili, prejdeme do Program.cs
.
Teraz si v tele metódy 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
:
Zdravic zdravic;
zdravic = new Zdravic();
Prvý riadok hovorí: "Chcem premennú zdravic
, v ktorej bude
inštancie triedy Zdravic
". S premennými sme vlastne už takto
pracovali.
Na druhom riadku je kľúčové slovo new
,
ktoré nám založia novú inštanciu triedy Zdravic
. 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, C # 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:
Zdravic zdravic = new 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 aplikácii
pridáme ešte Console.ReadKey()
. Kód metódy Main()
bude teda teraz vyzerať nasledovne:
{CSHARP_CONSOLE} Zdravic zdravic = new Zdravic(); zdravic.Pozdrav(); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Zdravic { public void Pozdrav() { Console.WriteLine("Hello object world!"); } } {/CSHARP_OOP}
Program spustíme.
Vaše prvé objektová aplikácie
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:
public void Pozdrav(string jmeno) { Console.WriteLine("Ahoj užívateľovi {0}", 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()
:
{CSHARP_CONSOLE} Zdravic zdravic = new Zdravic(); zdravic.Pozdrav("Karel"); zdravic.Pozdrav("Petr"); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Zdravic { public void Pozdrav(string jmeno) { Console.WriteLine("Ahoj užívateľovi {0}", jmeno); } } {/CSHARP_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.
Konzolová aplikácia
Ahoj užívateľovi Karel
Ahoj užívateľovi Petr
Triede pridáme nejaký atribút, ponúka sa text
, kde bude
uložený text pozdravu. Atribúty sa definujú rovnako, ako premenné. Ako u
metód platí, že pred nich píšeme modifikátor prístupu, bez neho je C #
berie ako private
. Upravme našu triedu:
class Zdravic { public string text; public void Pozdrav(string jmeno) { Console.WriteLine("{0} {1}", text, jmeno); } }
Text teraz musíme pochopiteľne nastaviť vytvorené inštanciu v
Program.cs
:
{CSHARP_CONSOLE} Zdravic zdravic = new Zdravic(); zdravic.text = "Ahoj užívateľovi"; zdravic.Pozdrav("Karel"); zdravic.Pozdrav("Petr"); zdravic.text = "Vítam ťa tu PROGRAMÁTOR"; zdravic.Pozdrav("Richard"); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Zdravic { public string text; public void Pozdrav(string jmeno) { Console.WriteLine("{0} {1}", text, jmeno); } } {/CSHARP_OOP}
Konzolová aplikácia
Ahoj užívateľovi Karel
Ahoj užívateľovi Petr
Vítam ťa tu PROGRAMÁTOR 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
,
zmeníme jej doterajší typ void
na 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.cs
:
public string Pozdrav(string jmeno) { return String.Format("{0} {1}", text, jmeno); }
Telo metódy Main()
v Program.cs
:
{CSHARP_CONSOLE} Zdravic zdravic = new Zdravic(); zdravic.text = "Ahoj užívateľovi"; Console.WriteLine(zdravic.Pozdrav("Karel")); Console.WriteLine(zdravic.Pozdrav("Petr")); zdravic.text = "Vítam ťa tu PROGRAMÁTOR"; Console.WriteLine(zdravic.Pozdrav("Richard")); Console.ReadKey(); {/CSHARP_CONSOLE}
{CSHARP_OOP} class Zdravic { public string text; public string Pozdrav(string jmeno) { return String.Format("{0} {1}", text, jmeno); } } {/CSHARP_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ápise použijeme trojlomítko
///
, VS nám potom vygeneruje XML, do ktorého všetko popíšeme.
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č. Ak by nám komentáre v kóde vadili
(zaberajú predsa len niekoľko riadkov), môžeme ich sklapnúť pomocou
malých tlačidiel "-". Zdokumentovaná trieda môže vyzerať napr.
Nasledovne:
/// <summary> /// Trieda reprezentuje Zdravice, ktorý slúži na zdravenie užívateľov /// </summary> class Zdravic { /// <summary> /// Text pozdravu /// </summary> public string text; /// <summary> /// Pozdravia užívateľa textom pozdravu a jeho mene /// </summary> /// <param name="jmeno">Meno používateľa</param> /// <returns>Text s pozdravom</returns> public string Pozdrav(string jmeno) { return String.Format("{0} {1}", text, jmeno); } }
Pozrieme sa, že nám VS 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 C # .NET , 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 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é 2128x (24.81 kB)
Aplikácia je vrátane zdrojových kódov v jazyku C#