Lekce 10: Základy OOP (Objektově orientované programování) v C#
Objektově orientované programování (OOP) je jedním z nejdůležitějších a nejpoužívanějších paradigmat v moderním softwarovém vývoji. C# je plně objektově orientovaný jazyk, který umožňuje vytvářet strukturované a modulární aplikace založené na objektech. V této lekci se zaměříme na základní principy OOP, jak je implementovat v C#, a jakým způsobem nám OOP pomáhá při organizaci a psaní kódu.
1. Co je OOP?
Objektově orientované programování je paradigma založené na objektech, které jsou instancemi tříd. Objekty mohou mít vlastnosti (atributy) a metody (funkce), které definují jejich chování. Základní principy OOP zahrnují:
- Zapouzdření (encapsulation): Skrytí interních dat objektu a jejich zpřístupnění pouze prostřednictvím veřejně dostupných metod.
- Dědičnost (inheritance): Schopnost vytvářet nové třídy, které dědí vlastnosti a metody z jiných tříd.
- Polymorfismus: Schopnost pracovat s objekty různých tříd, které sdílejí společné rozhraní, a volat na nich různé implementace metod.
- Abstrakce: Vytváření abstraktních tříd a metod, které definují společné chování, ale neobsahují konkrétní implementaci.
2. Třídy a objekty v C#
Základem objektově orientovaného programování v C# je třída. Třída je šablona, ze které můžeme vytvářet objekty. Objekt je konkrétní instancí třídy.
Definice třídy
Třída je definována pomocí klíčového slova class. Každá třída může mít atributy (vlastnosti) a metody (funkce).
public class Auto
{
public string znacka; // Atribut (vlastnost)
public int rychlost; // Atribut (vlastnost)
public void Zrychlit() // Metoda
{
rychlost += 10;
Console.WriteLine($"Auto zrychluje na {rychlost} km/h");
}
}
V tomto příkladu jsme vytvořili třídu Auto, která má dva atributy: znacka a rychlost, a jednu metodu Zrychlit, která zvyšuje rychlost automobilu.
Vytváření objektů
Objekty se vytvářejí z tříd pomocí klíčového slova new.
Auto mojeAuto = new Auto(); // Vytvoření objektu
mojeAuto.znacka = "Škoda"; // Přiřazení hodnoty atributu
mojeAuto.rychlost = 50; // Přiřazení hodnoty atributu
mojeAuto.Zrychlit(); // Volání metody
V tomto kódu jsme vytvořili instanci třídy Auto s názvem mojeAuto, nastavili jsme její značku a rychlost a zavolali jsme metodu Zrychlit, která zvýší rychlost.
3. Konstruktor
Konstruktor je speciální metoda, která se automaticky volá při vytváření nového objektu. Konstruktor slouží k inicializaci objektu.
public class Auto
{
public string znacka;
public int rychlost;
// Konstruktor
public Auto(string znacka, int rychlost)
{
this.znacka = znacka;
this.rychlost = rychlost;
}
public void Zrychlit()
{
rychlost += 10;
Console.WriteLine($"Auto {znacka} zrychluje na {rychlost} km/h");
}
}
Při vytváření nového objektu nyní můžeme předat argumenty přímo do konstruktoru:
Auto mojeAuto = new Auto("Škoda", 50);
mojeAuto.Zrychlit(); // Výstup: Auto Škoda zrychluje na 60 km/h
4. Zapouzdření (Encapsulation)
Zapouzdření je princip, který nám umožňuje skrýt interní detaily objektu a zpřístupnit pouze ty informace, které jsou nutné. Toho dosahujeme pomocí modifikátorů přístupu.
- public: Atribut nebo metoda je přístupná odkudkoli.
- private: Atribut nebo metoda je přístupná pouze uvnitř třídy.
- protected: Atribut nebo metoda je přístupná pouze v rámci třídy a jejích dědiců.
Příklad použití private a public:
public class Osoba
{
private string jmeno; // Skrytý atribut
// Veřejná metoda pro nastavení jména
public void NastavJmeno(string jmeno)
{
this.jmeno = jmeno;
}
// Veřejná metoda pro zobrazení jména
public void ZobrazJmeno()
{
Console.WriteLine($"Jméno osoby je {jmeno}");
}
}
Osoba osoba = new Osoba();
osoba.NastavJmeno("Petr");
osoba.ZobrazJmeno(); // Výstup: Jméno osoby je Petr
V tomto případě je atribut jmeno soukromý, takže k němu nemůžeme přistupovat přímo zvenčí třídy, ale můžeme použít veřejné metody pro jeho nastavení a získání.
5. Dědičnost (Inheritance)
Dědičnost umožňuje vytvářet nové třídy na základě již existujících tříd. Nová třída dědí atributy a metody ze své rodičovské třídy. To umožňuje opakované využití kódu a zjednodušení jeho správy.
public class Vozidlo
{
public string znacka;
public void Start()
{
Console.WriteLine($"{znacka} startuje.");
}
}
// Třída Auto dědí od třídy Vozidlo
public class Auto : Vozidlo
{
public int rychlost;
public void Zrychlit()
{
rychlost += 10;
Console.WriteLine($"{znacka} zrychluje na {rychlost} km/h.");
}
}
V tomto příkladu třída Auto dědí atribut a metodu od třídy Vozidlo. Nyní můžeme volat jak metodu Start, tak Zrychlit.
Auto mojeAuto = new Auto();
mojeAuto.znacka = "BMW";
mojeAuto.Start(); // Výstup: BMW startuje.
mojeAuto.Zrychlit(); // Výstup: BMW zrychluje na 10 km/h.
6. Polymorfismus
Polymorfismus umožňuje používat objekty různých tříd, které sdílejí společné rozhraní, jako by byly instance stejné třídy. Polymorfismus je obvykle implementován prostřednictvím metod s různými implementacemi ve třídách odvozených z jedné základní třídy.
Příklad polymorfismu:
public class Zvirata
{
public virtual void Zvuk()
{
Console.WriteLine("Zvíře vydává zvuk.");
}
}
public class Pes : Zvirata
{
public override void Zvuk()
{
Console.WriteLine("Pes štěká.");
}
}
public class Kocka : Zvirata
{
public override void Zvuk()
{
Console.WriteLine("Kočka mňouká.");
}
}
Zvirata mojeZvirata = new Pes();
mojeZvirata.Zvuk(); // Výstup: Pes štěká.
mojeZvirata = new Kocka();
mojeZvirata.Zvuk(); // Výstup: Kočka mňouká.
V tomto příkladu máme třídu Zvirata, která definuje obecnou metodu Zvuk. Třídy Pes a Kocka tuto metodu přepisují, aby měly vlastní specifické chování.
Závěr
Objektově orientované programování v C# je mocný nástroj, který nám umožňuje vytvářet flexibilní, modulární a udržovatelný kód. Klíčové principy OOP – zapouzdření, dědičnost, polymorfismus a abstrakce – umožňuje dělit části programu, které je možné opakovaně použít.
