27. OOP – öröklés, sokalakúság (polimorfizmus).

Osztályok
hierarchiája, Object osztály C#-ban. Láthatósági módosítók
használata (private, public, protected).

Objektumorientált programozás - Az objektumorientált vagy objektumelvű programozás

(angolul object-oriented programming, röviden OOP) az objektumok fogalmán alapuló
programozási paradigma. Az objektumok egységbe foglalják az adatokat és a hozzájuk
tartozó műveleteket. Az objektum által tartalmazott adatokon általában az objektum
metódusai végeznek műveletet. A program egymással kommunikáló objektumok
összességéből áll.
Az objektumorientált programozás 4 alapelve
Az objektumorientált programozás 4 alapelvre épül:
 Egységbezárás (angolul encapsulation)
 Absztrakció
 Öröklés
 Polimorfizmus
Egységbezárás - Az
objektum minden
tulajdonsága és
metódusa biztonságosan,
egységként, az
objektumon belül
tárolódik. Más
objektumok metódusai
csak akkor tudják
befolyásolni őket, ha ezt
megengedjük. Minden
objektumban lehetnek
publikusként és privátként beállított változók és metódusok.
A publikus változókat elérhetik és használhatják más objektumok, a privátokat nem. Az
egységbezárás segít biztonságosabbá tenni a kódot.
 Az autós példánál maradva: a szín, év és a modell neve privát változók, más
objektumok nem tudják megváltoztatni őket.
Absztrakció - Az absztrakció lényege, hogy csak a szükséges információkat szolgáltatja a
külvilágnak, és elrejti a végrehajtás belső részleteit.
A programok gyakran sok ezer-tízezer sorból álló, hatalmas egységek, amiket nehéz
karbantartani. Az absztrakció abban is segít, hogy könnyebben karbantartható legyen a kód és
könnyebben átlátható legyen a program a felhasználó számára.
Az absztrakció révén az objektumok csak a felszíni működésben, interakcióban fontos
elemeket láttatják a többi objektummal, a belső struktúrát, ami mindezhez szükséges, elrejtik.
Az autós példával élve: az “indítás” metódus tartalmazza azt a kódot, ami leírja, mi
történik, “indítás”-kor, vagyis amikor meghívják ezt a függvényt. Annak az
objektumnak, amelyik meghívta, (tehát pl. a “személy” objektum, aki elindítja az
autót), nem kell pontosan tudnia, milyen kód fut le a háttérben. Csak az a lényeg,
hogy működik az “autó”, és az “indítás”-t követően elindul.
Öröklés - A hosszú, bonyolult kódokkal több nehézség is adódik: nem csak nehéz őket
karbantartani és átlátni, de sok a hasonló kódrészlet, hasonló objektum. Megegyezhet a
logikájuk, gyakran nagyobb kódrészletek ismétlődnek, a teljes objektum mégsem ugyanaz.
Azért, hogy ne kelljen mindenhez teljesen új objektumot létrehozni, alkalmazhatjuk az
öröklést. Programozásban is használjuk a “szülő” (parent) és “gyerek” (child) kifejezéseket, a
gyerek örököl a szülőtől.
Öröklés során a parent objektum logikáját, felépítését örökli a child. A child osztályok
automatikusan hozzáférnek a parentben tárolt függvényekhez.
Az öröklés támogatja az egyszerű újrahasznosíthatóságot.
Nézzük meg az autós példát: az “autó” objektum bizonyos változóit (pl. szín, modell
neve, gyártási év) megörökölheti egy új objektum, létrehozhatunk ennek mintájára
részben hasonló, bizonyos tulajdonságokban viszont különböző objektumokat is, pl.
“teherautó”, “kisbusz”,
“traktor”.
Polimorfizmus - A polimorfizmus
megengedi, hogy a child objektum
örökölje a parent tulajdonságait, de
saját metódusai legyenek, eltérően használja őket. Tehát képes legyen másképp
implementálni a parent függvényeit.
Ha az “autó”, “teherautó”, “traktor” objektumok mind egy közös “jármű” osztály
leszármazottjai, akkor örökölhetik annak tulajdonságait. Viszont a polimorfizmus
révén lehetővé válik, hogy az “indítás” metódus mindegyik child objektumnál
különbözőképp zajlódon le.
Osztályok hierarchiája
Az objektum-orientált programozásban az osztály egy sablon, amely meghatározza egy
bizonyos típusú objektumok állapotát és viselkedését. Egy osztály definiálható más
osztályokkal. Például egy teherautó és egy versenyautó is egy autó példája. Egy másik példa,
hogy a betű és a szám egyetlen karakter, amely a képernyőre rajzolható. Az utóbbi példában a
következő terminológiát használjuk:
 A betűosztály a karakterosztály alosztálya; (alternatív nevek: gyermekosztály és
származtatott osztály)
 A karakterosztály a betűosztály közvetlen szuperosztálya (vagy szülőosztálya);
 A betűosztály kiterjeszti a karakterosztályt.
A harmadik megfogalmazás azt fejezi ki, hogy egy alosztály örökli az állapotot
(példányváltozók) és a viselkedést (módszereket) a szuperosztályaitól. A betűk és
számjegyek megosztják az egyes karakterek állapotát (név, betűtípus, méret, pozíció) és
viselkedését (rajzolás, átméretezés stb.).
Az alosztály célja a meglévő állapot és viselkedés kiterjesztése: a betűnek van egy kis- és
nagybetűje (nagy- és kisbetű, mondjuk a letterCase példányváltozóban tárolva) és metódusai
a kis- és nagybetűk megváltoztatására (toUpperCase, to LowerCase) azon az állapoton kívül,
amit már birtokol, mint karakter.
A számjegynek azonban nincs kis- és nagybetűje, így a toUpperCase, toLowerCase
metódusok nem tartoznak a Character osztály közös szintjére. Vannak olyan metódusok,
amelyek speciálisak a számjegyosztály számára. Például egy számjegy összeállítható egy 0 és
9 közötti egész értékből (integerekből), és fordítva, egy számjegy egész értéke (integere)
lehet mondjuk az intValue metódus eredménye.
Az alosztályok felülírhatják az öröklött viselkedést is: ha a karakterosztály alosztályaként
színes karakter szerepel, akkor felülírná a karakterosztály rajzolási metódusának definícióját,
így a színt a rendszer figyelembe veszi a karakter képernyőre való rajzolásakor. Ez az OOP
szakzsargonban polimorfizmusnak nevezett jelenséghez vezet: ugyanaz az üzenet, amelyet
különböző objektumokhoz küldenek, olyan viselkedést eredményez, amely az üzenetet
fogadó objektum természetétől függ.
Egy grafikonon a fenti karakterpélda a következőképpen nézhet ki:

Láthatósági módosítók használata (private, public, protected)

Egy osztály, metódus, változó vagy tulajdonság láthatósága írja le, hogy hogyan lehet
hozzájuk férni. A leggyakrabban használt láthatósági szintek a private és a public, de ennél
több láthatósági típus is létezik a C#-ban.
public - ezt a tagot bárhonnan el lehet érni. Ez a legkevésbé korlátozott láthatósági szint. Az
enumerációk és az interfészek alapértelmezetten ilyenek. A public láthatósági módosítóval
ellátott adatmezők és metódusok bárhol elérhetők.
private - csak a saját osztályán belül elérhető. Ez a legszigorúbb láthatósági szint. Az
osztályok és struktúrák alapértelmezetten ezen a szinten vannak. A private láthatósági
módosítóval ellátott adatmezők és metódusok kizárólag az adott osztályban érhetők el.
protected - ezeket csak ugyanazon az osztályon belülről vagy egy leszármazott osztályban
lehet elérni. a protected láthatósági módosítóval ellátott adatmezők és metódusok az adott
osztályban és az abból leszármaztatott osztályokban érhetők el
Ha van két osztályod, Class1 és Class2, akkor a Class1 private tagjai csak Class1-en belül
használhatóak. Nem várhatod el például azt, hogy a Class2-ben egy Class1 példányt hozol
létre, hogy a Class1 private tagjaihoz hozzáférhess - ez nem fog működni.
Az alábbi példa két osztályt fog megmutatni, és azt, hogy a benne levő értékek láthatósága
miként fog változni egyes láthatósági esetekben.
A osztály
using System.Windows.Forms;

namespace _013_OOP_Lathatosagi_modositok
{
public class A
{
public int x = 1;
private int y = 2;
protected int z = 3;

public void KiirasA(TextBox tbox)

{
tbox.AppendText("x = " + x + ", ");
tbox.AppendText("y = " + y + ", ");
tbox.AppendText("z = " + z + "\n");
}

}
}
A fenti példában láthatjuk az a osztályt amely 3 integer értékkel rendelkezik, de mindigyknek
másfajta láthatósági módosítóval rendelkezik
public int x = 1; - ez az érték bárhol látható lesz
private int y = 2; - ez az érték csak az osztályon belül less látható
protected int z = 3; - ez az érték csak az A osztályból leszármaztatott osztályban less
látható.

Az alábbi kódrészlet már magából a Formból jön, láthatjuk, hogy a Button1 click eseménye
kiirja a textboxba az A értékeit.
private void button1_Click(object sender, EventArgs e)
{
textBox1.Clear();
a.KiirasA(textBox1);
}
A péládt folytatva vizsgáljuk meg a B osztályt is:
using System.Windows.Forms;

namespace _013_OOP_Lathatosagi_modositok
{
public class B : A
{
public void KiirasB(TextBox tbox)
{
tbox.AppendText("x = " + x + ", ");
tbox.AppendText("y nem látható, ");
tbox.AppendText("z = " + z + "\n");
}
}
}
Láthatjuk, hogy a B osztály az előbb megbeszélt A osztályból van leszármaztatva, ebből
adódóan az A osztályban tárolt értékek a következő módon fognak megjelenni:
tbox.AppendText("x = " + x + ", ");
Az A osztály első értéke látható lessz a B osztály számára, mivel annak láthatósági
módosítója public volt
tbox.AppendText("y nem látható, ");
Az A osztály második értéke nem látható a B osztály számára, mivel annak
láthatósági módosítója private volt, tehát ez az érték csak az A osztály számára
elérhető
tbox.AppendText("z = " + z + "\n");
Az A osztály harmadik értéke szintén látható a B osztály számára, mivel annak
láthatósági módosítója protected volt. Ez azt jelenti, hogy az érték csak az A
osztályból leszármaztatott alosztályoknak látható.
Ez a B-re érvényes: public class B : A
Megvizsgálva a Formban levő kódrészletet, láthatjuk, hogy az A osztály második értéke
biztos nem lesz látható.
private void button2_Click(object sender, EventArgs e)
{
 textBox1.Clear();
b.KiirasB(textBox1);
}
Futás közben:

Miután megvizsgáltuk az A és B osztályok, nézzük meg mi történik, amikor egy A-tól

teljesen független osztályból (ez a Form1 osztálya) próbáljuk lehívni az A osztály értékeit:
a.x – látható Form1 számára, mivel láthatósági
módosítója public (bárkinek elérhető).
a.y – ez az érték nem látható Form1 számára,
mivel láthatósági módosítója private (csak és
kizárólag A osztálynak érhető el)
a.z – szintén nem érhető el Form1 számára,
mivel láthatósági módosítója protected, azaz
csak az A-ból leszármaztatott osztályoknak
látható. Mivel a B osztály a Form1 osztállyal
ellentétben az A osztályból van
leszármaztatva, ezért volt lehetséges a B osztálynak látni az a.z-t.
b.x - látható Form1 számára, mivel a B osztály az A osztályból származik, valamint
láthatósági módosítója public (bárkinek elérhető).
b.y - ez az érték nem látható Form1 számára, mivel láthatósági módosítója private (csak és
kizárólag A osztálynak érhető el), ezért nem számít, hogy a B az A osztályból van
leszármaztatva.
b.z – szintén nem érhető el Form1 számára, mivel láthatósági módosítója protected, azaz csak
az A-ból leszármaztatott osztályoknak látható. Megfigyelhetjük, hogy annak ellenére, hogy a
B osztályon keresztül kérdez rá az A osztály z értékére. A B osztály nem mutathatja meg neki
ezt az értéket, mivel protected, tehát csak olyan osztályok láthatják, amelyek az A osztályból
származnak, ez nem igaz a Form1 osztályra.
A Form1 osztály teljes kódja (ebből származnak az előbb említett „Form kódrészletek”)
using System;
using System.Windows.Forms;

namespace _013_OOP_Lathatosagi_modositok
{
public partial class Form1 : Form
{
private A a = new A();
private B b = new B();

public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)

{
textBox1.Clear();
a.KiirasA(textBox1);
}

private void button2_Click(object sender, EventArgs e)

{
textBox1.Clear();
b.KiirasB(textBox1);
}

private void KiirasForm1(TextBox tbox)

{
textBox1.Clear();
tbox.AppendText("a.x = " + a.x + ", ");
tbox.AppendText("a.y nem látható, ");
tbox.AppendText("a.z nem látható\n");
tbox.AppendText("b.x = " + b.x + ", ");
tbox.AppendText("b.y nem látható, ");
tbox.AppendText("b.z nem látható\n");
}

private void button3_Click(object sender, EventArgs e)

{
textBox1.Clear();
KiirasForm1(textBox1);
}
}
}