OOP v C#

Jak již bylo zmíněno, následující text navazuje na článek Objektově orientované programování. Není podmínkou mít ho přečtený, ale tento článek již předpokládá nějakou teoretickou znalost OOP a bude se zaměřovat na konkrétní aspekty OOP v C#.

Jak a kam definovat třídu

Třída se definuje pomocí klíčového slova class. Za ním je třeba zadat název třídy (unikátní označení) a do složených závorek samotný obsah třídy.

class NazevTridy
{
}

Nejčastěji se třída definuje uvnitř namespace (jmenný prostor). V analogii k tomu ji lze definovat samozřejmě i mimo jmenný prostor, přičemž třída se potom stejně přiřadí do namespace, která je definována jako Default namespace v Project Properties. Trochu exotičtější situací je, kdy se třída definuje uvnitř jiné třídy. V takovém případě se před samotnou definici vnořené třídy musí umístit modifikátor přístupu. Také se musí dávat pozor na to, že vytvořením vnořené třídy jsme přidali další úroveň v aplikaci a třída na nižší úrovni bude podle pravidla o zapouzdření poskytovat svoje elementy třídě vnořené. Naopak ale třída vnořená svoje elementy, pokud jsou nastavené jako soukromé, poskytovat nemusí.

class MojeUzasnaTrida
{
public class VnorenaTrida
{
public static void UdelejNeco() { ... }
private static void SoukromaMetoda() { ... }
}
public static void UdelejNecoDva() { ... }
private static void SoukromaMetodaDva() { ... }
}

V tomto příkladu na úrovni třídy VnorenaTrida můžeme bez problémů používat všechny metody (i metodu SoukromaMetodaDva, protože je na nižší úrovni). Na úrovni třídy MojeUzasnaTrida už nemůžeme používat metodu SoukromaMetoda, protože je soukromá pro třídu VnorenaTrida. Na úrovni společné namespace bychom už nemohli používat metody SoukromaMetoda a SoukromaMetodaDva.

Základní modifikátory přístupu

Pro potřeby toho článku si vystačíme se třemi modifikátory (další dva uvedené využijeme u dědičnosti). První dva už známe, soukromé – private a veřejné – public. Dalším modifikátorem je internal. Když nějakému prvku nastavíme modifikátor internal, bude přístupný v rámci assembly. Dalším modifikátorem bude protected, který, jak již bylo zmíněno, využijeme při dědičnosti. Prvek definován s tímto modifikátorem bude přístupný z vlastní třídy a z třídy odvozené. Podobný bude protected internal, který bude mít stejnou vlastnost jako předešlý a navíc ještě vlastnost modifikátoru internal.

Instanční nebo statické

Pokud jste si lépe prohlédli příklad, určitě jste si všimli parametru static u každé definice metody. Tímto klíčovým slovem jsem určil metodu jako statickou. To znamená, že není závislá na instanci třídy a lze tedy volat bez vytvoření nové instance. Takto vytvořené metody (vlastnosti, proměnné,...) ovšem nelze dědit a statické metody nesmí využívat údajů získaných při vytvoření instance. To, že lze použít bez vytvoření instance, je pro nás skvělý nástroj na jednoduché rozčlenění metod do tříd. Statická metoda se volá přes datový typ.

MojeUzasnaTrida.VnorenaTrida.UdelejNeco();

Co je to instanční prvek už je snad jasné. Je to prvek ve třídě, který pro svou existenci potřebuje novou instanci a je ho tedy třeba volat přes proměnnou – instanci. Kdybychom u metody UdelejNecoDva smazali parametr static a chtěli bychom nyní tuto metodu použít, museli bychom vytvořit novou instanci a potom až metodu volat.

MojeUzasnaTrida _instance = new MojeUzasnaTrida();
_instance.UdelejNecoDva();

Konstruktor

V souvislosti s instančními prvky je ústředním pojmem také konstruktor. Konstruktor se definuje jako metoda bez návratového typu s označením stejným, jako je název třídy. V příkladu níže jsem ho navíc definoval jako public. To je vcelku logické, protože jinak by de facto nešlo vytvořit novou instanci třídy. Právě tohoto se využívá u některých návrhových vzorů, kdy konstruktor definujeme jako private a novou instanci bude vytvářet nějaká statická metoda. Tím můžeme zajistit, aby v aplikaci existovala pouze jedna instance třídy.

class Osoba
{
private string jmeno, prijmeni, pohlavi;
public Osoba(string jmeno,string prijmeni)
{
this.jmeno = jmeno;
this.prijmeni = prijmeni;
}
public string VypisInformace()
{
return "Jméno: " + this.jmeno + ", příjmení: " + this.prijmeni;
}
}

U příkladu si navíc povšimněte klíčového slova this. To poukazuje na prvky z aktuální instance třídy (takže na statické metody to nefunguje). Tím jsme odlišili parametry konstruktoru a samotné proměnné ve třídě.

Přetěžování

V případě, kdy potřebujeme mít více různých konstruktorů (s různými vstupními parametry), použijeme tzv. přetěžování konstruktorů. To je situace, kdy ve třídě máme více totožných konstruktorů ale lišících v parametrech. Při volání konstruktoru se potom vybere podle toho, jaké argumenty jsme při instanciaci použili. Příklad dalšího konstruktoru je níže.

public Osoba(string jmeno, string prijmeni, string pohlavi)
{
this.jmeno = jmeno;
this.prijmeni = prijmeni;
this.pohlavi = pohlavi;
}

Pokud se stane, jako je tomu v příkladu, že konstruktor se liší od jiného konstruktoru ve třídě pouze o jeden parametr a provádí pouze nějakou dodatečnou funkci, lze použít i zápis níže.

public Osoba(string jmeno, string prijmeni, string pohlavi) : this(jmeno, prijmeni)
{
this.pohlavi = pohlavi;
}

Přetěžování lze obecně aplikovat nejen na konstruktor, ale i na obyčejné metody. Stačí jen vytvořit totožnou metodu lišící se o nějaké parametry. Při použití přetížené metody/konstruktoru nám dokonce Intellisense nabídne vybrat si z různých verzí metod/konstruktorů. Použití přetěžování lze docela pěkně vidět na obyčejné MessageBox a její metodě Show, která je přetížená dvacetkrát !

Vlastnosti

Vlastnosti (anglicky properties) jsou speciální prvky ve třídě, které dokáží velmi obratně pracovat s proměnnými. Když máme v proměnných nějaké informace, pracovat přímo s nimi ve třídě je v pořádku. Ale když se s nimi má pracovat navenek, je potřeba nějak zajistit aby v případě potřeby byly jen pro čtení, nebo naopak jen pro zápis, či aby se proměnná, kterou chceme poskytovat, hned nějak formátovala. Přesně pro tyto účely se užívají vlastnosti.

Vlastnosti mají svůj getter a setter. Díky getteru můžeme formátovat, či jinak pracovat s proměnnou a poskytovat ji. Settery slouží pro kontrolu při nastavování hodnoty proměnné. K hodnotě v setteru se dostaneme pomocí proměnné value. Myslím si, že zde jeden příklad řekne více než tisíc slov.

private string _promenna; //Proměnná, s kterou pracujeme
public string MojeVlastnost
{
get //getter
{
return _promenna;
}
set //setter
{
_promenna = value;
}
}

Takže rekapitulace vlastností. Navenek vůbec nepracujeme s proměnnou, ale pouze s vlastností, která reprezentuje danou proměnnou. V getteru hodnotu proměnné vracíme a v setteru ji nastavujeme. Kdybychom chtěli nastavit vlastnost pouze pro čtení, stačilo by odebrat setter. Kdybychom chtěli setter povolit pouze na úrovni třídy, lze mu nastavit private a navenek k němu taktéž nebude přístup. Pokud máme příklad jako výše, kdy pouze chceme mít vlastnost a nechceme vstup ani výstup nějak validovat, jde od verze C# 3.5 použít následující jednořádkový ekvivalent.

public string MojeVlastnost { get; set; }

Závěr

V tomto článku jsme si představili, jak se v C# definuje třída, konstruktor, přetěžování metod a konstruktorů a vlastnosti. V dalším článku se budu věnovat speciálním modifikátorům tříd, dědičnosti. Do budoucna se budete moci těšit také na rozhraní, události, nebo třeba delegáty.