ugrás a tartalomhoz

OO programozás lényege

stan · 2011. Május. 9. (H), 09.33
Kb. 2 éve programozok php-ben, és már elég jól ismerem a működését és szinte valamennyi lényeges alkotóelemével tisztában vagyok. Már az elejétől fogva egy saját készítésű CMS rendszeren dolgozom, felhasználva azokat a módszereket, amelyek általában javallottak ilyenkor. Most szeretném egy magasabb szintre emelni a tudásomat az OO programozás elsajátításával.

Már el is kezdtem olvasni egy erről szóló könyvet, meg több különböző oldalon is elkezdtem a kapcsolódó leckéket, de még mindig nem értek egy valamit. Jelenleg nagyon sok saját függvényt írtam, amelyek megkönnyítik a programozást. Eddig ezekkel a függvényekkel mindent meg tudtam oldani, amit csak kellett, beleértve olyan eseteket is, amikor egyes függvények egymást hívják meg több különböző módon, így is kevesebbet ismételve önmagam.

De egy valamit még mindig nem értek. Mi az, amiért az objektum orientált programozás a CMS rendszerek fejlesztésében többet tud nyújtani, mintha csak szimplán használom a saját függvény táramat? Mi az, amit a függvények használatával NEM lehet megcsinálni, az OO programozással pedig IGEN?

Lehet, hogy elég láma a kérdés, de még mindig nem tudom, hogy miért kellene ezt a programozási technikát használnom.
‹ http 412 OOP Interface ›
 ■
1

Semmi

Ifju · 2011. Május. 9. (H), 10.20
Nincs semmi, amit ne tudnál megcsinálni csak függvényekkel, és oop-vel igen.

Az objektumorientált programozás nem arról szól, hogy mást tudsz csinálni vele, mint a procedurális programozással, hanem másképp, mert ez csak egy paradigma.

Ami miatt érdemes lehet az OOP-t elsajátítanod: megkönnyíti a munkádat hosszútávon.

Az általános tapasztalatom az, hogy az objektumorientált paradigmát helyesen alkalmazva egy-egy fejlesztésbe bekapcsolódni könnyebb, illetve ha hosszú idő után újra hozzá kell nyúlni egy kódhoz, akkor gyorsabban átlátja az ember, hogy mi mit csinál. Neked is könnyebb bekapcsolódni más projektekbe, ha ismered ezt a paradigmát.

Meg merem kockáztatni, hogy megfelelő átgondoltsággal a procedurális megközelítés ugyanezeket az előnyöket képes adni, csupán a megfelelő átgondoltság kialakításához szükséges idő kicsit több. Természetesen, objektumorientált paradigmában is szükséges az átgondoltság, csupán itt maga a paradigma képes vezetni a fejlesztő gondolkodását.
2

Nem láma kérdés. Nekem is

Numcsi · 2011. Május. 9. (H), 10.48
Nem láma kérdés. Nekem is régebben ugyan ez volt a kérdésem, hogy mi a külömbség a normál function és az OOP között. Mindkettő jó csak másra. Az OOP kimondottan feladat szétbontására jó. Míg a normál function függvényeknél, ha leakarsz menteni 1 változót, a függvény futása közben az kicsit macera. OOP esetén a függvényen kívüli változókra hivatkozol $this->xyx ezzel.

OOP esetén, függvények halmaza csoportosítva, és elágazgató gyermekekké, amik öröklik a szülő osztály függvényeit, tulajdonságait és változóit.

Egy egyszerű OOP kód + szülő-gyermekkel:

<?php
<?php
//public $var1; public: bárhonnan elérhető: osztályon kívül, osztályban és gyermekből
//private $var2; private: csak osztályon belül érhetőek, máshonnan sehogy
//protected $var3; pritected: csal osztályból és gyermekből érhetőek el

class NEGYZET
{
    public $x;
    protected $eredmeny = array();
 
    //public function xy() és function xy() ugyan az. Public az alapértelmezett elérés
    //ajánlott kitenni, de nem kötelező
    private function negyzetKerulet()
    {
        $kerulet = 4 * $this->x;
        $this->eredmeny[] = $kerulet;
    }

    private function negyzetTerulet()
    {
        $terulet = $this->x * $this->x;
        $this->eredmeny[] = $terulet;
    }
    
    public function negyzetAll()
    {
        $this->negyzetKerulet();
        $this->negyzetTerulet();
    }
}

//ez a gyermek osztály, ami örökli a NEGYZET tulajdonságait
class TEGLALAP extends NEGYZET
{
    public $y;

    private function teglalapKerulet()
    {
        $kerulet = 2 * $this->x + 2 * $this->y;
        $this->eredmeny[] = $kerulet;
    }

    private function teglalapTerulet()
    {
        $terulet = $this->x * $this->y;
        $this->eredmeny[] = $terulet;
    }
    
    public function kiras()
    {
        foreach ($this->eredmeny as $value) {
            echo $value."<br />";            
        }
    }
    public function teglalapAll()
    {
        $this->teglalapKerulet();
        $this->teglalapTerulet();
    }
}

$teglalap = new TEGLALAP;
$teglalap->x = 2;
$teglalap->y = 3;
$teglalap->negyzetAll();
$teglalap->teglalapAll();
$teglalap->kiras();
?>
Nos. Elmondom sorban mit is látunk itt. "new TEGLALAP" megnyitjuk a TEGLALAP osztályt. Tudjuk hogy a téglalap rendelkezik a négyzet tulajdonságaival. Mivel public az "x" változó, így a gyermekéből "$teglalap = new TEGLALAP; $teglalap->x = 2;" tudunk neki értéket adni. Majd a y-t is feltöltjük értékkel.

Lefuttatjuk a negyzetAll függvényt, ami meghív az osztályában lévő 2 függvényt.
Majd ugyanezt a másikkal is. És utolsó sorban kiíratjuk.

Ha a számításos függvények: téglalap/négyzet terület/kerület private tulajdonságúak lennének, akkor osztályon kívül nem lennének meghívhatók mint pl. ez: "$teglalap->teglalapAll();"

OOP egyik jó tulajdonsága hogy a változókat többször is alkalmazhatóak. van a függvényen kívüli $x; és van 1 függvényen belüli $x; is. Ez a két változó névben ugyan az, de használatukban nem, így össze sem vesznek. Mivel függvényen belül "$this->x" -ként kell hivatkozni a függvényen kívüli változóra, ami persze nem $x; néven szerepel.
Minden olyan függvény vagy változó ami NEM publicként szerepel nem hívható meg osztályon kívülről.

class xy 
{
    private $x; //osztályon belüli, de fügvényen kívüli
    
    public xy()
    {
        $x; //fügvényen belüli
    }
}

//az alábbiak osztályon kívüliek
$obj = new xy;
$obj->xy();
echo $obj->x; //nem íratja ki, mert private típusú a változó
Ha van még egyéb kérdésed tedd csak fel.
3

Itt nem arról van szó, hogy

inf · 2011. Május. 9. (H), 13.09
Itt nem arról van szó, hogy mi az, amit lehet, és mi az amit nem. Itt arról van szó, hogy amikor megcsináltad az adott dolgot, az mennyire átlátható, mennyire módosítható könnyen, mennyire egyszerű valami új tulajdonságot, funkciót belevinni. Ugyanaz a dolog objektum orientáltan leprogramozva sokkal rendszerezettebb és könnyebben, biztonságosabban módosítható. (Az egységtesztelésről nem is beszélve.) Kb ennyiről szól az oo.