2. diel - Prvá objektová aplikácia v C# - Hello object world

Minulá lekcia, Úvod do objektovo orientovaného programovania v C#, nás uviedla do objektovo orientovaného programovania.

V dnešnom tutoriáli sa budeme venovať tomu, ako OOP funguje a vytvoríme si svoju prvú objektovú aplikáciu v C#.

Ako OOP funguje

Snažíme sa nasimulovať realitu tak, ako ju sme zvyknutí vnímať. Môžeme teda povedať, že sa odpútavame od toho, ako program vidí počítač (stroj) a píšeme program skôr z pohľadu programátora (človeka). Tak ako sme kedysi nahradili assembler človeku čitateľnými matematickými zápismi, teraz ideme ešte ďalej a nahradíme aj tie. Ide teda o určitú úroveň abstrakcie nad programom. To má značné výhody už len v tom, že je to pre nás prirodzenejšie a prehľadnejšie.

Základnou jednotkou je objekt, ktorý zodpovedá nejakému objektu z reálneho sveta (napr. objekt human alebo database).

Objekt má svoje atribúty a metódy.

Atribúty

Atribúty objektu sú vlastnosti čiže dáta, ktoré uchováva (napr. u človeka meno a vek, u databázy heslo). Ide o prosté premenné, s ktorými sme už stokrát pracovali. Niekedy o nich hovoríme ako o vnútornom stave objektu.

Slovo vlastnosť si v Microsofte vyhradili pre špecifické využitie a to isté platí o atribúte. Premenným objektov hovoria field, čo sa zase kryje s českým slovom poľa. Budeme teda používať slovo atribút, hoci to nebude úplne korektné.

Metódy

Metódy sú schopnosti, ktoré objekt dokáže vykonávať. U človeka by to mohli byť metódy: GoToWork(), Greet() alebo Blink(). U databázy AddEntry() alebo Search(). Metódy môžu mať parametre a môžu tiež vracať nejakú hodnotu. Veľmi dobre ich poznáme, používali sme napr. metódu Split() na objekte string. string je vlastne objekt, ktorý reprezentuje v realite nejaký text. Vidíte, že si môžeme jednoducho predstaviť, že jednáme s reťazcom textu, niečo mu prikazujeme alebo na ňom niečo nastavujeme. Obsahuje metódy, ktoré reťazec vie vykonávať (kopírovanie, mazanie, delenie na časti...). Pole má napríklad atribút Length, ktorý udáva jeho dĺžku.

V tejto lekcii si vysvetlíme len úplné základy, teda ako objekty vytvárať. Ďalším témam OOP sa budú venovať ďalšie lekcie, aby toho nebolo naraz priveľa 🙂

Trieda

S pojmom trieda sme sa už tiež stretli, chápali sme ju ako súbor príkazov. Trieda však umožňuje omnoho viac. Trieda je vzor, podľa ktorého sa objekty vytvárajú. Definuje ich vlastnosti a schopnosti.

Objekt, ktorý sa vytvorí podľa triedy, sa nazýva inštancia. Inštancie majú rovnaké rozhranie ako trieda, podľa ktorej sa vytvárajú, ale navzájom sa líšia svojimi dátami (atribútmi). Majme napríklad triedu Human a od nej si vytvorme inštancie carl a john. Obe inštancie majú iste tie isté metódy a atribúty ako trieda (napr. name a age) a metódy (GoToWork() a Greet()). Hodnoty v nich sa však líšia (prvá inštancia má v atribúte name hodnotu Carl a v atribúte age hodnotu 22, druhá John a 45).

Komunikácia medzi objektmi prebieha pomocou volania metód, vďaka čomu je syntax prehľadná. Volanie zvyčajne vyzerá takto: receiver.MethodName(parameters). Napr. carl.Greet(neighbor) by mohlo spôsobiť, že inštancia carl pozdraví inštanciu neighbor.

Prvá objektová aplikácia

Už vieme, že objekty majú atribúty a metódy. Tiež vieme, že na vytvorenie objektu najprv vytvoríme triedu. Tá je vzorom, podľa ktorého následne tvoríme jej inštancie.

Na začiatku kurzu so základnými štruktúrami jazyka C# sme si vytvorili program Hello world. Urobme si teraz podobný program ako úvod do objektovo orientovaného programovania. Naprogramujme si aplikáciu Hello object world!

Vytvorenie triedy

Založme si novú konzolovú C# aplikáciu tak, ako sme to robili doteraz. Po vytvorení projektu v hlavičke triedy Program odstránime modifikátor prístupu internal a v tele metódy Main() príkaz Console.WriteLine("Hello, World!");.

V Solution Exploreri napravo klikneme pravým tlačidlom myši na náš projekt a vyberieme Add -> Class…:

Vytvoríme triedu Greeter a potvrdíme. Názov triedy píšeme vždy notáciou PascalCase, teda bez medzier a na rozdiel od premenných (tie používajú camelCase) má každé slovo veľké prvé písmeno, teda aj prvé. Názov je samozrejme tiež bez diakritiky, tú v programe používame maximálne vo vnútri textových reťazcov, nie v identifikátoroch:

Podľa tejto triedy neskôr vytvoríme objekt greeter, 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šiť" do Main(). V našom prípade vám to môže prísť zbytočné, pri zložitejších aplikáciách si to budete pochvaľovať

V našom Solution Exploreru pribudne ďalší súbor .cs a IDE 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 IDE vygenerovalo, a kód si popíšme. Následne si do triedy pridáme vlastnú metódu na pozdravenie:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HelloObjects
{
    class Greeter
    {

    }
}

Kľúčové slovo namespace nám označuje tzv. menný priestor. Rovnako ako sa metódy združujú do tried, tak sa aj triedy združujú do menných priestorov. Pokiaľ chceme, aby bola naša trieda viditeľná aj v Program.cs, kde máme metódu Main(), musíme mať triedu v rovnakom mennom priestore. To tu platí, IDE samo novú triedu obalí tým istým menným priestorom, vy namiesto HelloObjects budete mať názov svojej aplikácie, pokiaľ 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 IDE pripraví System, potom generické kolekcie, teda Linq a Text. Pre nás bude najdôležitejšie menné priestory namespace System, pretože práve ten obsahuje triedu Console. Ďalšie menné priestory využijeme až neskôr. Potom budeme dokonca potrebovať nejaké menné priestory dodať, najmä na 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á Greeter 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 neobjektovo programovať ani nedá, čo je len dobre

Metódy

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

Deklarácia metódy v C# je teda nasledovná:

[access modifier] [return type] [MethodName]([parameters])

Pred metódou bude tzv. modifikátor prístupu, v našom prípade public (verejná). Metóda nebude vracať žiadnu hodnotu, to dosiahneme kľúčovým slovom void. Ďalej bude nasledovať samotný názov metódy. Metódy píšeme rovnako ako triedy PascalCase. 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 konzole.

Naša trieda bude teraz vyzerať takto:

public class Greeter {

    public void Greet()
    {
        Console.WriteLine("Hello object world!");
    }
}

Tu sme zatiaľ skončili, prejdeme do súboru Program.cs.

Teraz si v tele metódy Main() vytvoríme inštanciu triedy Greeter. Bude to teda ten objekt greeter, 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é. Deklarujme si premennú a následne v nej založme novú inštanciu triedy Greeter:

Greeter greeter;
greeter = new Greeter();

Tieto riadky hovoria: "Chcem premennú greeter, v ktorej bude inštancia triedy Greeter." S premennými sme vlastne už takto pracovali.

Na druhom riadku je kľúčové slovo new, ktoré nám vytvorí novú inštanciu triedy Greeter. 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áraciu" 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 žiaden konštruktor nedeklarovali, C# si preto vytvoril tzv. implicitný bezparametrický konštruktor. Vytvorenie inštancie objektu je teda podobné volaniu metódy. Deklaráciu môžeme samozrejme skrátiť na:

Greeter greeter = new Greeter();

Od .NET 5 už nemusíme typ druhýkrát vypisovať, ale zapíšeme len:

Greeter greeter = new();

Tento zápis používame iba v prípade, keď je jasne poznať, akého typu premenná je.

Keďže v premennej máme teraz naozaj inštanciu triedy Greeter, môžeme inštanciu nechať pozdraviť. Zavoláme na ňu metódu Greet() ako greeter.Greet(). K aplikácii pridáme ešte Console.ReadKey(). Kód metódy Main() bude teda teraz vyzerať nasledovne:

{CSHARP_CONSOLE}
            Greeter greeter = new Greeter();
            greeter.Greet();
            Console.ReadKey();
{/CSHARP_CONSOLE}
{CSHARP_OOP}
    class Greeter
    {

        public void Greet()
        {
            Console.WriteLine("Hello object world!");
        }

    }
{/CSHARP_OOP}

Program spustíme a v konzole sa nám zobrazí:

Our first object-oriented application
Hello object world!

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

V nasledujúcej lekcii, Atribúty a metódy v C#, si vysvetlíme, ako pridávať objektom atribúty a metódam parametre. Dokončíme svoju prvú objektovú aplikáciu.

 

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š.