Lekce 2 - První objektová aplikace v C# - Hello object world

Minulá lekce, Úvod do objektově orientovaného programování v C#, nás uvedla do objektově orientovaného programování.

V dnešním tutoriálu se budeme věnovat tomu, jak OOP funguje a vytvoříme si svou první objektovou aplikaci v C#.

Jak OOP funguje

Snažíme se nasimulovat realitu tak, jak ji jsme zvyklí vnímat. Můžeme tedy říci, že se odpoutáváme od toho, jak program vidí počítač (stroj) a píšeme program spíše z pohledu programátora (člověka). Jako jsme tehdy nahradili assembler lidsky čitelnými matematickými zápisy, nyní jdeme ještě dál a nahradíme i ty. Jde tedy o určitou úroveň abstrakce nad programem. To má značné výhody už jen v tom, že je to pro nás přirozenější a přehlednější.

Základní jednotkou je objekt, který odpovídá nějakému objektu z reálného světa (např. objekt člověk nebo databáze).

Objekt má své atributy a metody.

Atributy

Atributy objektu jsou vlastnosti neboli data, která uchovává (např. u člověka jméno a věk, u databáze heslo). Jedná se o prosté proměnné, se kterými jsme již stokrát pracovali. Někdy o nich hovoříme jako o vnitřním stavu objektu.

Slovo vlastnost si v Microsoftu vyhradili pro specifické využití a totéž platí o atributu. Proměnným objektů říkají field, což se zase kryje s českým slovem pole. Budeme tedy používat slovo atribut, přestože to nebude úplně korektní.

Metody

Metody jsou schopnosti, které umí objekt vykonávat. U člověka by to mohly být metody: JdiDoPrace(), Pozdrav() nebo Mrkni(). U databáze PridejZaznam() nebo Vyhledej(). Metody mohou mít parametry a mohou také vracet nějakou hodnotu. Velmi dobře je známe, používali jsme např. metodu Split() na objektu string. I string je vlastně objekt, který reprezentuje v realitě nějaký text. Vidíte, že si můžeme jednoduše představit, že jednáme s řetězcem textu, něco mu přikazovat nebo na něm něco nastavovat. Obsahuje metody, které řetězec umí vykonávat (kopírování, mazání, splitování,...). Pole má také nějaké metody, např. Sort() seřadí jeho položky podle velikosti.

V této lekci si vysvětlíme jen úplné základy, tedy jak objekty vytvářet. Dalším tématům OOP budou věnovány další lekce, aby toho nebylo najednou moc 🙂

Třída

S pojmem třída jsme se již také setkali, chápali jsme ji jako soubor příkazů. Třída však umožňuje mnohem více. Třída je vzor, podle kterého se objekty vytvářejí. Definuje jejich vlastnosti a schopnosti.

Objekt, který se vytvoří podle třídy, se nazývá instance. Instance mají stejné rozhraní jako třída, podle které se vytvářejí, ale navzájem se liší svými daty (atributy). Mějme například třídu Clovek a od ní si vytvořme instance karel a josef. Obě instance mají jistě ty samé metody a atributy, jako třída (např. jmeno a vek) a metody (JdiDoPrace() a Pozdrav()). Ale hodnoty v nich se liší (první instance má v atributu jmeno hodnotu "Karel" a v atributu vek hodnotu 22, druhá "Josef" a 45).

Komunikace mezi objekty probíhá pomocí volání metod, díky čemuž je syntaxe přehledná. Volání obvykle vypadá takto: prijemce.JmenoMetody(parametry). Např. volání karel.Pozdrav(sousedka) by mohlo způsobit, že instance karel pozdraví instanci sousedka.

První objektová aplikace

Již víme, že objekty mají atributy a metody. Také víme, že k vytvoření objektu vytvoříme nejprve třídu. Ta je vzorem, podle kterého následně tvoříme její instance.

Na začátku kurzu se základními strukturami jazyka C# jsme si vytvořili program Hello world. Udělejme si nyní podobný program jako úvod do objektově orientovaného programování. Naprogramujme si aplikaci Hello object world!

Vytvoření třídy

Založme si novou konzolovou C# aplikaci tak, jak jsme to dělali doposud. Po vytvoření projektu v hlavičce třídy Program odstraníme modifikátor přístupu internal a v těle metody Main() příkaz Console.WriteLine("Hello, World!");.

V Solution Exploreru napravo klikneme pravým tlačítkem myši na náš projekt a vybereme Add -> Class…:

Vytvoříme třídu Zdravic a potvrdíme. Název třídy píšeme vždy notací PascalCase, tedy bez mezer a na rozdíl od proměnných (ty používají camelCase) má každé slovo velké první písmeno, tedy i první. Název je samozřejmě také bez diakritiky, tu v programu používáme maximálně uvnitř textových řetězců, nikoli v identifikátorech:

Podle této třídy později vytvoříme objekt zdravic, který nás bude umět pozdravit. Vidíme, že se na program již díváme úplně jinak, za každou akci je zodpovědný nějaký objekt, nestačí pouze něco "nabušit" do Main(). V tomto případě vám to může připadat zbytečné, u složitějších aplikací si to však budete pochvalovat

V našem Solution Exploreru přibude další soubor .cs a IDE nám ho otevře. K původnímu Program.cs s metodou Main() se můžeme vrátit pomocí záložky nebo přes Solution Explorer.

Podívejme se, co nám IDE vygenerovalo, a kód si popišme. Následně si do třídy přidáme vlastní metodu pro pozdravení:

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

namespace HelloObjects
{
    class Zdravic
    {

    }
}

Klíčové slovo namespace nám označuje tzv. jmenný prostor. Stejně jako se metody sdružují do tříd, tak se také třídy sdružují do jmenných prostorů. Pokud chceme, aby byla naše třída viditelná i v Program.cs, kde máme metodu Main(), musíme mít třídu ve stejném jmenném prostoru. To zde platí, IDE samo novou třídu obalí týmž jmenným prostorem, vy místo HelloObjects budete mít název své aplikace, pokud jste ji nepojmenovali, bude tam ConsoleApplication1.

Příkaz using nám umožňuje zviditelnit třídy jiných jmenných prostorů, abychom s nimi mohli pracovat. V základu nám IDE připraví System, poté generické kolekce, Linq a Text. Pro nás bude nejdůležitější jmenný prostor namespace System, protože právě ten obsahuje třídu Console. Další jmenné prostory využijeme až později. Poté budeme dokonce potřebovat nějaké jmenné prostory dodat, zejména pro práci s textovými soubory.

V namespace je tedy umístěná samotná třída, která se deklaruje klíčovým slovem class. Třída se jmenuje Zdravic a je prázdná.

Všimněte si, že kód je téměř stejný jako ten v Program.cs, již tedy rozumíme tomu, co jsme předtím ignorovali. Náš konzolový program byla vlastně třída umístěná ve jmenném prostoru, která obsahovala jednu metodu Main().

Metody

Nyní si do třídy Zdravic přidáme metodu Pozdrav(). Ta bude veřejně viditelná a nebude mít žádnou návratovou hodnotu ani parametry.

Deklarace metody v C# je tedy následující:

[modifikátor přístupu] [návratový typ] [JmenoMetody]([parametry])

Před metodou bude tzv. modifikátor přístupu, v našem případě public (veřejná). Metoda nebude vracet žádnou hodnotu, čehož docílíme klíčovým slovem void. Dále bude následovat samotný název metody. Metody píšeme stejně jako třídy PascalCase. Závorka s parametry je povinná, my ji necháme prázdnou, protože metoda žádné parametry mít nebude. Do těla metody zapíšeme kód pro výpis na konzoli.

Naše třída bude nyní vypadat takto:

class Zdravic
{

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

}

Zde jsme prozatím skončili, přejdeme do Program.cs.

Nyní si v těle metody Main() vytvoříme instanci třídy Zdravic. Bude to tedy ten objekt zdravic, se kterým budeme pracovat. Objekty se ukládají do proměnných, název třídy slouží jako datový typ. Instance má zpravidla název třídy, jenom má první písmeno malé. Deklarujme si proměnnou a následně v ní založme novou instanci třídy Zdravic:

Zdravic zdravic;
zdravic = new Zdravic();

Tyto řádky říkají: "Chci proměnnou zdravic, ve které bude instance třídy Zdravic." S proměnnými jsme vlastně již takto pracovali.

Na druhém řádku je klíčové slovo new, které nám vytvoří novou instanci třídy Zdravic. Tuto instanci přiřadíme k naší proměnné.

Při vytvoření nové instance se zavolá tzv. konstruktor. To je speciální metoda na třídě, proto při vytvoření instance píšeme ty prázdné závorky, jelikož voláme tuto "vytvářecí" metodu. Konstruktor zpravidla obsahuje nějakou inicializaci vnitřního stavu instance (např. dosadí výchozí hodnoty do proměnných). My jsme v kódu žádný konstruktor nedeklarovali, C# si proto vytvořil tzv. implicitní bezparametrický konstruktor. Vytvoření instance objektu se tedy podobá volání metody. Celý zápis můžeme samozřejmě zkrátit na:

Zdravic zdravic = new Zdravic();

Od .NET 5 již nemusíme typ podruhé vypisovat, ale zapíšeme jen:

Zdravic zdravic = new();

Tento zápis používáme pouze v případě, kdy je jasně poznat, jakého typu proměnná je.

Jelikož v proměnné nyní máme opravdu instanci třídy Zdravic, můžeme instanci nechat pozdravit. Zavoláme na ni metodu Pozdrav(), a to jako zdravic.Pozdrav(). K aplikaci přidáme ještě Console.ReadKey(). Kód metody Main() bude tedy nyní vypadat následovně:

{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 a v konzoli se nám zobrazí:

Naše první objektová aplikace
Hello object world!

Máme tedy svou první objektovou aplikaci!

V příští lekci, Atributy a metody v C#, si vysvětlíme jak přidávat objektům atributy a metodám parametry. Dokončíme svou první objektovou aplikaci.

 

Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.