PHP objektum orientált programozás mit könnyít meg, mire jó?

Előnye: kevesebbet kell írni ès átláthatóbb a program

Hátránya: több erőforrást használ.

#1 pont nem előnye :-)

Nem kell kevesebbet írni, sőt pont hogy többet, és egy kezdőnek még fele annyira se átlátható.

Procedurálisan sokkal átláthatóbb, kevesebb kódból megvalósítható.

Egyetlen fő előnye van: Az osztályok (class -ok) jól elkülönülnek, bennük lévő funkciók, változók véletlen sem ütköznek más osztályok funkcióival. (hiába azonos a nevük)

Az MVC pedig nem feltétlen az OOP -hez kapcsolódik.

Ennek lényege hogy a controller ami meghatározza milyen funkciókat, külsőt kell meghívni, a php funkciók, és megjelenés, külső jól elkülönűl.

Így gyakorlatilag csak egy templates fájlt ami a külsőt tartalmazza kell babrálni, ha alakítani akarsz a megjelenésen, de a funkciókon szolgáltatásokat nem akarod változtatni.

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 fájlrendszerben léteznek könyvtárak. Egy-egy könyvtárnak legyen példányszintű tulajdonsága a benne lévő fájlok száma, azok összegzett mérete. Például a C:\valami könyvtárra jellemző, hogy van benne 3 fájl azok mérete összesen 20KiB, vagy C:\másvalami 8 fájllal és 2GiB mérettel. Ezek létező példányok. Ugyanakkor, ami az osztályt magát jellemezheti, hogy hány könyvtár van a fájlrendszerben. Ez természetesen egyik példányra sem vonatkozik, ezért lesz osztályszintű tag.

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, mi az az aktuális példány (this/self), getter/setter metódusok, referencia- és értéktípusok, és még sorolhatnám...

Ami az MVC-t illeti... Az alapvető gond az, hogy amikor programozol, az adatkezelés, a program vezérlése és a megjelenítés módosítása egy azon kódban keveredik. Példa:

//Egy kódból piszkáljuk az adatbázist:

$Results = array();

$ResultSet = $DbConnection->query('SELECT * FROM `asd`');

//Az adatokat feldolgozó logikát:

while ($Current = $ResultSet->fetch_assoc()) {

.. $Results[] = ...;

}

//Még egy picikét az adatbázist:

$ResultSet->close();

//A nézetet:

print "Rekordok:<br/><ul>";

foreach ($Results as $Current) {

.. print "<li>$Current"</li>";

}

print "</ul>";

MVC architektúra szerint (ez a kód menne a vezérlőbe, azaz a controllerbe):

//A modelltől elkérjük az adatot:

//Egy darab SQL lekérdezést nem látunk, ennek elintézése a modell dolga!

$ResultSet = Model::findAll();

//A programunk logikája feldolgozza az adatokat:

$Results[] = array();

foreach ($ResultSet as $Current) {

.. $Results[] = ...;

}

//Nagyon kedvesen megkérjük a nézetet (view), hogy jelenítse meg az adatokat:

//Egy darab HTML kód sem keveredik a controller kódjába, ez a nézet dolga!

View::render('DataDisplay', [

.. 'DataToDisplay' => $Results

]);