Az mennyire gond, ha szeptemberbe kezdtem az egyetemet PTI (elte) és az alap programozással nincs is gondom? (! )

Szóval az OOP-ról érthetően és magyarul:

Ha szétnézel magad körül, látni fogsz jó néhány tárgyat. Pl. asztal, ablak, lámpa, szék, csak hogy párat említsek. Hogyan kezdődött ezeknek a tárgyaknak az élete? Leültek és megtervezték. Készítettek egy tervet arról, hogy milyen tulajdonságokkal kell rendelkeznie az adott tárgynak. Az asztal esetében ilyen tulajdonság lehet az, hogy hány lába van, milyen anyagból készült, milyen színű, mekkora a mérete. A tervben azt is leírják, hogy az adott tárgynak milyen cselekvései vannak, és hogyan végzi ezeket a cselekvéseket. Nyilván egy asztal nem tud túl sok mindent csinálni, viszont ha nézünk egy lámpát, az például tud világítani, és az is leírható, hogy hogyan végzi ezt a világítás tevékenységet. Ez mind szép és jó, de ugye egy tervben, papíron létező asztal vagy lámpa még nem létezik, le kell gyártani azt. A gyártás után kapjuk meg a kézzel fogható példányt. A gyártás során dől el az is, hogy az egyes kész termékek tulajdonságai milyen értékeket vesznek fel. Ugyanis lehet gyártani például üvegből készült, átlátszó színű asztalt, de lehet fából készült, barna színű asztalt is.

Eme rövidke példa után nézzük, hogy ennek mégis mi köze volt a programozáshoz.

Mikor egy programot az OOP paradigma szerint készítünk el, ugyanez történik, mint velünk a való életben. Magát a programot fel lehet fogni egy világként. Ahhoz, hogy ebben a világban legyen nekünk valami, terveket kell készíteni, hasonlóan, ahogy mi is megterveztük az asztalt. Egy-egy ilyen tervet hívunk OSZTÁLYnak. A tervben (vagyis osztályban) leírt tulajdonságokat hívjuk MEZŐnek, ami nagyjából ugyanaz, mint egy hagyományos változó. Továbbá, az osztályban leírt cselekvéseket hívjuk METÓDUSnak, ez kvázi a hagyományos értelemben vett függvény vagy eljárás. Ahhoz, hogy a programunk világában ezekből a tervekből, osztályokból "kézzel fogható" tárgy legyen, PÉLDÁNYOSÍTANI kell. Ez az a gyártási folyamat, amelynek során megkapjuk a már használható és létező OBJEKTUMot (más néven PÉLDÁNY). Így első körben azt gondolná az ember, hogy minden, amit az osztályban leírunk, a példányokra is érvényes lesz. Akkor jöjjön az érvágás: ez nem éppen így van. Ugyanis vannak PÉLDÁNYSZINTŰ tagok az osztályban (tag = bármi, ami az osztályban le van írva), amik a példányokra vonatkoznak, és vannak OSZTÁLYSZINTŰ tagok, amik magára az osztályra jellemzőek. Furcsa, de az OOP paradigmában egy "papíron létező" terv is végezhet cselekvéseket, és lehetnek tulajdonságai. Ennek általában akkor van szerepe, amikor nem egy-egy konkrét példányra, hanem általánosságban a példányokról tudunk információt szerezni, műveletet végezni. Erre egy egyszerű példa:

A világban léteznek székek. Egy konkrét székre vonatkozó tulajdonságok (példányszintű tulajdonságok) például a lábainak száma, háttámlás-e, milyen az anyaga, stb. De tudunk olyan tulajdonságot mondani, ami egyik konkrét székhez sem kapcsolódik, hanem általánosságban beszél a székekről. Ilyen tulajdonság például az, hogy hány szék van a világon. Ez azért lesz osztályszintű tag, mert bár egyik konkrét széknek sincs ilyen tulajdonsága, mégis a székekhez van köze.

Amit így tudni kellene az az, hogy osztályon belül a példányszintű tagokat a this példányok keresztül érhetjük el, míg a statikus tagokra viszont már nyelvtől függ, mivel kell hivatkozni. Java-ban, C#-pban az osztály nevével, PHP-ban a self ill. a static kulcsszavakkal.

Az ilyen osztályszintű tagokat szokás STATIKUS TAGnak is nevezni, és a legtöbb programnyelv a static kulcsszóval jelöli. Nézzük meg, hogyan is történik a példányosítás. A példányosítás során a gyártó elkészíti a kész terméket. Az OOP-ben ezt a gyártót nevezzük KONSTRUKTORnak. Így első hallásra elég durvának tűnhet, de csupán arról van szó, hogy a memóriában lefoglal annyi területet, amiben a példányszintű tagok elférnek, továbbá itt szokás kezdőértéket is adni az osztály mezőinek. Ez a konstruktor egy olyan speciális metódus, ami akkor hívódik meg, amikor mi példányosítjuk az osztályunkat. Néhány programozási nyelv, többek közt a Java és a C# is eljárásként kezeli ezeket, olyannyira, hogy a visszatérési érték típusát is tilos kitenni a konstruktormetódus neve elé. Általában a konstruktornak kitüntetett neve van. C#-pban, C++-ban és Java-ban az osztály nevével egyezik meg, PHP-ban __construct névre hallgat.

Az OOP azért jött létre tehát, hogy a mi világunkat modellezzük benne. Ez azért lesz jó, mert jól elkülöníthető részekre osztja fel a mi kódunkat, sokkal jobban áttekinthető az EGYSÉGBEZÁRÁS ELVE miatt. Ez nemes egyszerűséggel annyit takar, hogy a lámpára vonatkozó cselekvéseket nem keverjük össze még kódlogikailag sem az asztal metódusaival és adattagjaival. Ez az összevisszaság leginkább az eljárásközpontú nyelvekben vehető észre, például a C-ben. Bár külön-külön fájlokra oszthatjuk fel a kódunkat, mégsem különülnek el az egyes dolgokra vonatkozó alprogramok. Az egységbezárás elve miatt rögtön jön egy fontos tulajdonság, a LÁTHATÓSÁG. Ennek csupán annyi a feladata, hogy az osztály és a példány tagjait a külvilág elérheti-e. Elvégre elég hülye tervezés lenne, ha például az ember irányíthatná a szívét, vagy beleszólhatnék az autó belső működésébe.

Ember e = new Ember();

e.Szívritmus = 0; //Halott ember vagyok - ezt nem lenne szabad megtennem

Az ilyen esetek elkerülésére az osztály és a példány tagjait LÁTHATÓSÁGI MÓDOSÍTÓval láthatom el. Az OOP paradigma 3 láthatóságot szab meg:

- a külvilág számára elérhető tagok, azaz NYILVÁNOS, PUBLIC

- a külvilág számára nem, de az osztályon/példányon belülről látható tagok, azaz REJTETT, PRIVATE

- a külvilág számára nem, de az osztályon/példányon belülről, valamint az osztályból származó további osztályok számára elérhető, azaz VÉDETT, PROTECTED

Feljött egy fontos definíció, a származtatás, ÖRÖKLŐDÉS. Ez arra lesz jó, hogy én már megírtam, hogyan kell működnie egy lámpának. De én ezt tovább akarom fejleszteni, létre akarok hozni asztali lámpát és csillárt is. Azért lesz ez nekem jó, mert már én egyszer megírtam, hogy mit kell tudnia egy lámpának - és ezt már nem kell többször megírnom, elég csak azt mondanom, hogy a lámpában szereplő tagok alapján létre akarok hozni egy új osztályt. Ilyenkor kvázi "átmásolódnak" a lámpa osztályból a tagok az asztali lámpa osztályba, ugyanakkor én ebből semmit sem látok, csupán ennyit:

class Lampa {

public int Teljesitmeny;

public int IzzokSzama;

public void Vilagit() {

Console.WriteLine("Világít a lámpa");

}

}

class AsztaliLampa : Lampa {

}

Így bevezetőnek ennyit, ehhez még rengeteg definíció tartozik, például helyettesíthetőség, getter/setter metódusok, referencia- és értéktípusok, és még sorolhatnám...

Mondjuk az, hogy ha egy függvény színt vár paraméterként, akkor még véletlenül se tudsz mondjuk pixelkoordinátát megadni, másrészt meg messziről virít, hogy az egy szín, pedig mindkettő végdő soron csak egy integer.

Az lehet a baj, hogy valami világmegváltó dolgot vársz az oop-től, pedig mindent meg lehet csinálni oop nélkül is, csak éppen kevésbé lesz átlátható vagy bővíthető.

Próbálj meg valamelyik GUI input boxa alapján egy olyan inputboxot csinálni, ami pl. bevitel közben folyamatosan ellenőrzi az inputot. Oop-ben ez elég logikus és egyszerű: csak az új viselkedését kell lekódolnod. Oop nélkül vagy az inputbox kódját írod át, hogy ismerje ezt a viselkedést is vagy lemásolod az inputbox teljes kódját és azt egészíted ki. Meg lehet tehát csinálni, csak egy idő után egy monstrummal állsz szembe, ami mindent tud, de nem is tudsz róla, mert nem látod át. Még nyilvánvalóbb az oop haszna, ha az eredeti kódhoz nincs hozzáférésed vagy más fejleszti. Saját osztályt viszont bármikor építhetsz egy ilyen "fekete dobozra" is.