OOP Alapok

OOP alapok

By nja

Egységbezárás

• Egy programozási nyelv Objektum Orientált Programozási nyelv, ha megvalósítható benne három alapelv:

• egységbezárás, • öröklődés • sokalakúság • Az egység ezárás azt jelöli, hogy a progra szövegé e is egyértel űe

jelölve legyen, hogy egy objektumosztályt milyen adatok és milyen űveletek jelle zik.

Az adatok az egyedek él eltérőek lehet ek i de autó ak ás-más a re dszá a , de a űveletek egegyez ek. A űveletek a fe ti adatokra hivatkoznak, azokat használják fel a megvalósításukban, illetve azokat módosítják (pl. TeleTankol űvelet autók eseté a benzinMennyiseg adatot módosítja). Az adatokat e e az eset e ’ ezők’-nek vagy ’adattagok’-nak szokták

evez i. A űveletek pedig eljárások és függvé yek for ájá a va egvalósítva, de e e a kör yezet e közös éve ’ etódus’-nak hívjuk

őket.

Öröklődés


• egységbezárás, • öröklődés • sokalakúság • Az öröklődés alapelv azt o dja ki, hogy ha késze vagyu k egy

osztállyal egadtuk a ak adatait és űveleteit , akkor képesek legyünk egy új osztályt létrehozni oly módon, hogy ezen, már kész osztályból kiinduljon. Ekkor a ásodik szi tű osztály i duláskor e üres, ha e áris re delkezik a fe t defi iált adatokkal és űveletekkel. Ekkor ár sak a ővítést és ódosítást kell leprogra oz i.

A kii duló osztályt ’ős osztály’-nak, a továbbfejleszett osztályt ’gyermek osztály’-nak, vagy ’származtatott osztály’-nak nevezzük.

Sokalakúság (polimorfizmus)


• egységbezárás, • öröklődés • sokalakúság • Az öröklődés alapelve szeri t a szár aztatott osztály a

lehetőség va a ár eglévő, örökölt űveletek újraírására ódosítására . A sokalakúság szeri t azok a űveleteket,

elyek eze javított űveletekre épül ek – ne igényeljenek újraírást, hanem képesek legyenek újraírás nélkül is ezt az új verziót használni. Ezt az alapelvet a legtöbb programozási nyelv a virtuális metódusokkal valósítja meg.

OOP-t támogató nyelvek

• Egy progra ozási yelv ’OOP tá ogató’, ha harmadik generációs, de lehet benne hagyományos (nem OOP) stílusban is programozni, de alkalmazhatók az OOP alapelvei is.

• Az ilyen programozási nyelvek utólag lettek ővítve, kiegészítve az OOP jelle zőkkel.

• Ilyen programozási nyelvek pl: C++, Delphi.

Tisztán OOP nyelvek

• Egy progra ozási yelv ’tisztán OOP jellegű’, ha harmadik generációs, de csak OOP személettel lehet benne programozni.

• Az ilyen programozási nyelvekben nem lehet egyszerű eljárásokat és függvé yeket készíte i, minden ilyet el kell helyezni valamilyen osztályban (metódussá válik). Nem lehet változókat megosztani függvények között, azokat is osztályok elsejé e kell helyez i ezővé válik .

• Ilyen programozási nyelvek pl: C#, Java.

Osztály adattagjai

• Az osztály két fő rész ől áll: adatok ól és űveletek ől. Az adatokat ezők e adattagok tároljuk. class TKor { public int x; public int y; public int sugar; } A fenti osztály három adattagot tartalmaz. Minden adattag ak va eve, és típusa. Az külö öző példá yok eseté az adattagok értéke külö öző lehet, hisze jele példa esetén minden kör más-más koordinátára kerülhet akár, és a sugara is külö öző lehet.

Osztály adatai

• Az osztály két fő rész ől áll: adatok ól és űveletek ől. Az adatokat ezők e adattagok) tároljuk. class TKor { public int x; public int y; public int sugar; } Az osztály i de eset e felelős, hogy a példá yai gara tálta helyese

űködje ek. E ek egfelelőe e ege gedhető az, hogy az adattagok e tartalmazzanak értéket, vagy hibás értékeket tartalmazzanak. Hogy a példány már kezdetben értékekkel rendelkezzen, az adattagoknak kezdőértékadás során be lehet állítani az alapértelmezett értékeket: class TKor { public int x =0; public int y = 0; public int sugar =0; }

Védelmi szintek

• Az osztály i de eset e felelős, hogy a példá yai gara tálta helyese űködje ek. Ne ege gedhető az, hogy az adattagok hibás értékeket tartalmazzanak. A e yi e a progra vala ely külső része direkt ódo hozzá tud férni az adattagokhoz, akkor azokba hibás értékeket helyezhet el. Ezek egzavarhatják az osztály űveletek űködését. Pl., ha egy repülő eseté e a agasságot egatív értékre is e lehet állíta i, akkor a leszállás űvelet esélyese hi át fog okoz i. Az osztály a szá ára kritikus adattagokat védheti a külvilág elől a védelmi szintek használatával. A védel i szi tek a ezők hatáskörét ódosítják. Segítségükkel olya hatáskör állítható e, elye elül a ezők olvashatók és írhatók, de azo kívül a ezők e hozzáférhetőek. Ha e hozzáférhetőek, akkor hi ás értéket se tud ak elhelyez i e ük.

PUBLIC

• Az osztály a szá ára kritikus adattagokat védheti a külvilág elől a védel i szintek használatával. Háro fajta alapvető védel i szi t va :

• private • protected • public • A public a leg ege gedő védel i szi t. Egy public adattag hatásköre

kiterjed a teljes program szövegére. Más osztályokból is meghivatkozható, értéke bármikor kiolvasható és megváltoztatható. Pl.: class TTelefon { public string TulajdonosNeve; private int PIN_Kod; // private, mert kiírtuk int PUK_Kod; // private, mert nem írtunk semmit }

PROTECTED

• Az osztály a szá ára kritikus adattagokat védheti a külvilág elől a védel i szi tek hasz álatával. Háro fajta alapvető védel i szi t va :

• private • protected • public • A protected eggyel gyengített védelmi szint. Egy protected adattag hatásköre kiterjed az őt tartal azó osztályra, és a ak i de szár aztatott

osztályára. Pl.: class TTelefon { public string TulajdonosNeve; protected int PIN_Kod; protected int PUK_Kod;0 public bool PIN_Kod_Csere(int regiKod, int ujKod) { if (regiKod==PIN_Kod) { PIN_Kod = ujKod; return true; } return false; } } class TJoTelefon:TTelefon // származtatás { public int PIN_Lekerdez( int pukKod ) { if (pukKod == PUK_Kod ) return PIN_Kod; return -1; } } n -1; } }

PRIVATE

• Az osztály a szá ára kritikus adattagokat védheti a külvilág elől a védel i szi tek hasz álatával. Háro fajta alapvető védel i szi t va :

• private • protected • public • A private a legszorosabb védelmi szint. Egy private adattag hatásköre e terjed túl az őt tartal azó osztályo .

Ezért sak az osztály a defi iált etódusok törzsé e lehet rájuk hivatkoz i, és lehet őket felhasz ál i. Ez egy e az alapértel ezett védel i szi t is. Vagyis a e yi e e adu k eg védel i szi tet egy ező él, úgy automatikusan a private lesz az: class TTelefon { public string TulajdonosNeve; private int PIN_Kod; // private, mert kiírtuk int PUK_Kod; // private, mert nem írtunk semmit public bool PIN_Kod_Csere(int regiKod, int ujKod) { if (regiKod==PIN_Kod) { PIN_Kod = ujKod; return true; } return false; } }

METóDUS

• Az osztály tartal azza a rajta végezhető űveletek kódját is. A űveletek eljárások és függvények formájában vannak megvalósítva, és közös összefoglaló nevük metódus. A metódusoknak van nevük, paraméterlistájuk, utasítástörzsük. A törzsükben felhasználhatják a paramétereiket, de hivatkozhatnak az osztály adattagjaira is. Pl.: class TTelefon { protected string sajatTelefonSzam = String.Empty; protected int osszEgyseg = 0; public void EgyenlegFeltoltes( int egyseg ) { osszEgyseg = osszEgyseg + egyseg; SmsKuld(sajatTelefonSzam, ”Jele legi egye leged {0} egyseg”,osszEgyseg ); } }

METÓDUS ÉS ME)Ő

• A etódusok elsejé e az osztály saját ezőit direkt ódo el lehet ér i, és hasz ál i. Mivel a metódus szintén az osztály befoglaló blokkjának belsejében kerül deklarálásra, így a legszigorúbb védel i szi tű private ezőkhöz is direkt hozzáférhet, azokat írhatja és olvashatja. Ezért az osztály etódusai ak a leg agyo a felelőssége. Egy hi ása egírt etóduso keresztül hi ás viselkedésre vehető rá az osztály példá yai: Pl.: class TTelefon { protected string sajatTelefonSzam = String.Empty; protected int osszEgyseg = 0; public void EgyenlegFeltoltes( int egyseg ) { osszEgyseg = osszEgyseg + egyseg; } } Az EgyenlegFeltoltes() metódus például negatív számmal is meghívható, mivel int típusú adatot fogad el. Negatív szám esetén pedig a feltöltés csökkenti az egységek számát, nem növeli. public void EgyenlegFeltoltes( int egyseg ) { if (egyseg<0) throw new Exception ”Hi ás egye legfeltöltés” ; else osszEgyseg = osszEgyseg + egyseg; }

METÓDUS HÍVÁSA METÓDUSBÓL

• Egy osztály több metódust is tartalmazhat. Egyik metódusból természetesen van lehetőség ásik etódust eghív i a szokásos ódo : class TTelefon { protected string sajatTelefonSzam = String.Empty; protected int osszEgyseg = 0; public void EgyenlegFeltoltes( int egyseg ) { osszEgyseg = osszEgyseg + egyseg; string smsSzoveg = String.Format ”Jele legi egye leged {0} egyseg”,osszEgyseg ) SmsKuld(sajatTelefonSzam, smsSzoveg ); } public void SmsKuld( string telefonszam, string szoveg ) { ... } }

Metódusok túlterhelése

• Egy osztály több metódust is tartalmazhat. Ugyanazon metódusnévvel több metódus is szerepelhet, amennyiben azok para éterezése külö öző. Ez az ’overloading’ tulajdo sága a nyelvnek. Egy túlterhelést ege gedő yelv e a etódushívás, az aktuális paraméterlista illesztése dönt a metódus kiválasztásáról. Ha ez nem egyértel ű ered é yt ad, akkor fordítási hi át kapu k. Ha i s illeszkedő etódus, akkor is hi át kapu k. class TTelefon { public bool tarcsaz( int telefonszam { …} public bool tarcsaz( int korzet, int telefonszam { … } public bool tarcsaz( string telefonTulajdonos { … } }

KONSTRUKTOR MEGADÁSA

• A konstruktor neve kötött, meg kell egyezzen az osztály nevével. Egy konstruktornak nem lehet visszatérési érték típusa (még void sem). Lehetnek paraméterei. Mivel a C# overloading -ot támogató nyelv, így bár minden konstruktornak ugyanaz a neve, de mivel más-más a para éterezése, ezért akár tö ko struktor is készíthető. Pl: class TTelefon { public TTelefon { … } public TTelefon(string tulajNev { … } public TTelefon(string tulajNev, bool elofizeteses { … } public TTelefon(int induloEgyenleg { … } }

KONSTRUKTOR FELADATAI

• A konstruktor egy speciális feladatú metódus. Feladata elkészíteni egy példányt az adott osztályból, azt alaphelyzetbe állítani, hogy azonnal használható lehessen. A konstruktor feladatai:

• az új példá y ezői ek alaphelyzet e állítása. • Ezt valójá a agyo gyakra a ezők ellé írt kezdőértékadásával végezzük el. • Ugya akkor a ko struktor ak para éterei lehet ek, így elképzelhető, hogy a

kezdőértékeket a para éterek alapjá állítja e a ko struktor. • Valamint a kezdőértékadás sorá hasz ált kifejezések sak korlátozott képességűek

(nem használhatóak benne pl. függvényhívások). A konstruktor törzsében azonban ezek ár hasz álhatóak, így szá ított kezdőértékek is eállíthatóak

• amennyiben a paraméterekben meghatározott értékek ellentmondásosak, a ko struktor ak lehetősége va egtagad i egakadályoz i a példá y létrehozását (kivétel dobása).

• a konstruktor a virtuális metódus táblát hozzárendeli a példányhoz, mindig a saját osztályának VMT tábláját köti a példányhoz.

KONSTRUKTOR túlterhelése

• A ko struktorok eseté e a túlterhelés hasz álata agyo jelle ző. Ugyanis a konstruktor neve kötött (meg kell egyezzen az osztály nevével), így egy osztályhoz csak úgy lehet több konstruktort rendelni, ha kihasználjuk a túlterhelés szabályait. Legfontosabb szabály: minden konstruktor paraméterezése más-más kell legyen! Csakis ekkor tudja a fordító az aktuális paraméterlista alapján eldönteni, melyik konstruktort szeretnénk meghívni. Pl.: class TTelefon { public TTelefon { … } public TTelefon(string tulajNev { … } public TTelefon(string tulajNev, bool elofizeteses { … } public TTelefon(int induloEgyenleg { … } }

Alapértelmezett konstruktor

• A ko struktor futtatása kötelező a példá y készítése sorá , hogy az új példány azonnal alaphelyzetben legyen. Amennyiben egy osztályhoz nem készítünk konstruktort, úgy a fordító elkészít egyet helyettünk. Ezen konstruktornak nem lesz paramétere (üres paraméterlista), és a törzse is üres lesz. Az üres para éterezésű konstruktort alapértelmezett konstruktornak nevezzük. Ilyen konstruktort mi is készíthetünk az osztályunkhoz. Nyilván ezen konstruktor használata a legkényelmesebb, hiszen hívásakor nem kell értékeket átadnunk neki. Ugyanakkor egy ilyen konstruktor által alaphelyzet e állított példá yal lesz a leg eheze késő dolgoz i, hiszen ezen példány tényleg nagyon kezdetleges állapotban lehet csak. Amennyiben mi írunk konstruktort (legalább 1-et) az osztályunkhoz, úgy a fordító már nem generálja az alapértelmezett konstruktort. Ha a mi általunk megírt konstruktoroknak van paraméterük, akkor a példányosításnál már csak valamelyik paraméteres konstruktor közül választhatunk.

Öröklődés

• Az öröklődés alapelv azt o dja ki, hogy ha késze vagyu k egy osztállyal egadtuk a ak adatait és űveleteit , akkor képesek legyünk egy új osztályt létrehozni oly módon, hogy ezen már kész osztályból kiinduljon. Az öröklődés sorá haso ló ered é yt érü k el, i tha az ős osztály kódját egyszerűe lokk ásolással leduplikáltuk vol a, és átneveztük volna az új osztály nevére, majd e ponttól kezdve folytattuk volna a fejlesztést. Ugya akkor, eze te h ika fejlette , hisze a e yi e az ős osztály a ár i e ű ódosítást végrehajta á k utólag, a

lokk ásolást eg kelle e is étel i. Az öröklődés sorá azo a a frissítés automatikus. A gyerekosztály kii duláskor tartal azza az ős osztály i de

ezőjét és etódusát, sak a tová fejlesztésekkel kap solatos módosításokra kell koncentrálni.

Öröklődés utá új ező hozzáadása

• A gyer ekosztály a lehetőség va új ezők hozzáadásával kiegészíte i az osztályt. Ez nyilvánvalóan szükséges, hiszen a továbbfejlesztett osztály több adatot lehet képes kezelni. Pl.: class TKor { public int x; public int y; public int sugar; } class TAbrazolhatoKor : TKor { public int vonalSzine; public int vonalVastagsag; } A klasszikus (matematikai) kör leírásához annak koordinátái és sugara elégséges. Ha azo a ezt a kört ki is szeret é k rajzol i a képer yőre, úgy a vo al szí e és vastagsága is érdekes.

Öröklődés utá új etódus adása

• A gyer ekosztály a lehetőség va új etódusok hozzáadásával kiegészíte i az osztályt. Ez yilvá valóa szükséges, hisze a tová fejlesztett osztály tö űvelet elvégzésére is képes lehet.

Pl.: class TKor { public int x; public int y; public int sugar; public double Terulet() { return sugar * sugar * Math.PI; } public double Kerulet() { return 2 * sugar * Math.PI; } } class TAbrazolhatoKor : TKor { public int vonalSzine; public int vonalVastagsag; public void Kirajzolas { … } public void Letorles { … } } A klasszikus ate atikai kör űveletei közé tartoz ak a kerület és terület lekérdezése. A képer yő egjele ő kör képes saját agát kirajzol i

Öröklődés és túlterhelés

• A e yi e az ős osztály a ár kidolgozásra kerül vala ely etódus, azt a gyer ekosztály az öröklődés kap sá átveszi. A gyer ekosztály a lehetőség va új etódusok evezetésére. Eze új

etódusok jelle zőe ás- ás évvel re delkez ek, de lehetőség va ugya olya evű etódus készítésére is. A e yi e a gyer ekosztály a készített ugya olya evű etódus para éterezése eltér az őstől örököl etódustól, úgy az overloading iatt i dkettő hasz álható arad. Az aktuális paraméterlista alapján a fordító képes meghatározni, melyik metódust kívánjuk meghívni. Pl.: class TAuto { public double Feltankol() // legyen a tank teljesen tele { ... } } class TAuto2 : TAuto { public double Feltankol(double liter // e yi ’liter’ e zi etöltése { ... } }

Öröklődés és etóduselfedés

• A e yi e az ős osztály a ár kidolgozásra kerül vala ely etódus, azt a gyer ekosztály az öröklődés kap sá átveszi. A gyer ekosztály a lehetőség va új etódusok evezetésére. Eze új etódusok jelle zőe más- ás évvel re delkez ek, de lehetőség va ugya olya evű etódus készítésére is. A e yi e a gyer ekosztály a készített ugya olya evű etódus para éterezése is ugya az, úgy az overloading nem kihasználható. E pillanattól kezdve a gyermekosztályból készített példányok esetén az új változat kerül meghívásra (elfedi a régi verziót). Pl.: class TVektor { public void Rendezes // egyfajta re dező ódszer { ... } } class TVektor2 : TVektor { public void Rendezes() // hatékonyabb rendezés { ... } } Meghívása: TVektor v = new TVektor(); v.Rendezes(); // ez az kevésbé hatékony rendezés használata TVektor2 m = new TVektor2(); m.Rendezes(); // a hatékonyabb használata

SEALED

• Egy osztály továbbfejlesztését meggátolhatjuk, ha a sealed (lepecsételt) kulcsszóval ellátjuk. Ezzel gyakorlatilag azt akadályozhatjuk meg, hogy eze osztályt ős ek választhassuk. Nyilvá erre sak re dkívül ritká , erőse i dokolt eset e

kerülhet sor. sealed class TBefejezettOsztaly: TAkarmilyenOs { … … }

Típuskényszerítés

• Az OOP példányok és típusok esetén is használható a hagyományos formájú típuskényszerítés, bár használata nem olyan elegáns, mint az as operátoros forma. A hagyo á yos alak a típus év példá y for ájú. Ekkor azo a ügyel i kell a zárójelek egfelelő használatára! Példa: public static void MindenSzalljonFel(Object x) { if (x is TVadaszgep) { ((TVadaszGep)x).MotorokInditasa(); ((TVadaszGep)x).Gurulas(); ((TVadaszGep)x).Felszallas(); } if (x is TKacsa) { ((TKacsa)x).Nekifutas(); ((TKacsa)x).SzarnyCsapdosas(); ((TKacsa)x).Elrugaszkodas(); } }

IMPLICIT típuskompatibilitás

• Egy o jektu osztály ko pati ilis az ősosztályával, és a ak ősosztályaival. Ezt a fordító is felis eri, ezért i pli it ódo e gedi a típuskonverziót. Az öröklődési fa sú sá az Object osztály áll, minden más osztály ezen Object leszármazottja lehet csak. Ezért minden osztály kompatibilis az Object osztállyal. class TOsOsztaly { … } class TGyerekOsztaly:TOsOsztaly { … } TOsOsztaly a = new TOsOsztaly(); TGyerekOsztaly b = a; A b=a értékadás csak akkor jó, ha a jobb oldal típusa megegyezik, vagy legalábbis kompatibilis a bal oldal típusával. Jelen értékadásban a fent ismertetett implicit típuskompatibilitás miatt ez teljesül. Is és As operátorok ár progra függők

Jelle ző egadása

• A jelle ző deklarálása haso lít egy ező deklarálásához. Meg kell ad i típusát, és evét. De eze felül meg kell adni a get és set részét is. class TKor { // elrejtett, e pu likus ező private int _sugar; // pu likus, égis védett jelle ző public int sugar { get { return _sugar; } set { if (value>0) _sugar=value; else throw new Exception ”A sugár értéke e lehet egatív” ; } } }

Jelle ző hasz álata

• A ’jelle ző’ property az osztály egy virtuális ezője. Eze egy ező ek látszó dolog, de a hátteré e vala ilye kód áll. Ezzel valósíthatjuk eg elegá sa a ezők védel ét. Meggátolhatjuk, hogy olyan érték kerülhessen valamely

ező e, a ely értel etle . A jelle ző e eíra dó érték a set szakasz futását idézi elő. A set szakasz megvizsgálja a beírandó értéket (value), ha

egfelelő ek találja, akkor eltárolja a ező e , elle kező esetben megtagadja azt. A ’jelle ző’ értéké ek kiolvasása a get szakasz futását idézi elő. A get szakasz, mint függvény viselkedik. A kalkulált értéket egy return segítségével adja vissza a hívás helyére. Lehet olvasható és írható is, progra függő.

Jó tanulást!

Documents

OOP Alapok