03-Az út az OOP-ig

Az OOP az Objektum-orientált programozás kifejezés rövidítése. A leggyakrabban használt programnyelvekben ez a koncepció már a 90-es évektől szerepel, hiszen ez egy jó dolog: kevés munkával lehet nagyon összetett programokat csinálni. Amik annak ellenére, hogy összetettek, valójában nem tűnnek bonyolultnak. Igazi mágia!

Sokan "félnek" az OOP-től. Igaziból ez... más. Ha más módszerekkel programoztál már, akkor olyan fura lesz, mint a régi Igazi Programozók számára a Pascal nyelv. (Sok szakember úgy gondolja, hogy egyenesen csak annyi a baj, hogy van, aki nem eleve OOP-ben tanul meg programozni.)

Azt gondolom, hogy a legnagyobb különbség az OOP és a nem-OOP megközelítésben az, hogy a hagyományos esetben intuitív módon, saját magunk által "megálmodva" kell egy-egy valós feladatot a számítógép nyelvén megfogalmazni. Eközben fejben kell tartanunk az egész feladatot.

Az OOP esetben ez sokkal könnyebb: hiszen egyszerűen azonosítjuk a program szereplőit, összeszedjük hogy azok mit csinálnak, és ezeket pár programsorban leírjuk. Bármennyire szuper-bonyolult több millió soros szoftverrendszert csinálunk, mégis egyszerre csak pár programsorral kell foglalkozni.

De hogyan jutottunk el az OOP-ig? Emlékszel, ezt már fejtegettük. A Pascal előtt teljes volt a sötétség. A C és a Pascal hozta a strukturált programozás gyakorlatát, aztán van még a moduláris, és végül az objektum-orientált programozási paradigma (módszertan). Remélem, arra is emlékszel még, hogy a mai nyelvek ezeket mind támogatják! Lássuk, hogy hogyan!

Strukturálódjunk

Az eddigi programjaink az előző részben csak be voltak öntve a main belsejébe. Ez igazán nem kényelmes, hiszen nem lehet reciklálni (újrahasznosítani) a már egyszer megírt dolgokat. Márpedig, ha valaki sok programot ír, egyáltalán nem tartja viccesnek, ha az idő jó részében ugyanazokat a dolgokat kell újra meg újra bepötyögni. Elvégre is, ez programozás, nem pedig gépírás-tanfolyam, ugye? :)

Emlékszel még a Trinketen megírt SOS morze progira? Próbáljunk meg valami hasonlót!

package hello;

public class Hello {
    public static void main(String[] args) {
        System.out.println("... --- ...");
    }
}

Húú de jó! De nyilván csaltunk, hiszen csak egyszerűen kiírtuk az SOS-t :)

Hogy is csináltuk a Trinketen? Csináltunk egy rövid csippantást, meg egy hosszú csippantást, és beraktuk ezeket egy-egy függvénybe. Itt hogy kell függvényt csinálni? Hát másolással!

package hello;

public class Hello {

    public static void ti() {
        System.out.print(".");
    }

    public static void ta() {
        System.out.print("-");
    }

    public static void main(String[] args) {
        ti();
        ti();
        ti();
        ta();
        ta();
        ta();
        ti();
        ti();
        ti();
    }
}

Hogy ebben mi a jó? Először is az, hogy bármikor megváltoztathatjuk, hogy éppen mit írjon ki a ti meg a ta, vagy éppen később képesek leszünk ezeket igazi csippantássá alakítani. Ehhez csak azt a két egysoros függvényt kell piszkálni - és nem az egész programot.

Természetesen ez még annyira nem meggyőző. Igazából nem látszik, hogy most SOS-t fogunk küldeni, tehát az egész progi még nem "szép". Persze működni működik, de az nekünk már nem elég, nem igaz?

Hogy is csináltuk a Trinkettel? Csiáltunk s() meg o() függvényeket! Sőt, most csinálok egy pause függvényt is, amivel a betűk közti szünetet lehet "kiírni".

package hello;

public class Hello {

    public static void ti() {
        System.out.print(".");
    }

    public static void ta() {
        System.out.print("-");
    }

    public static void pause() {
        System.out.print(" ");
    }

    public static void s() {
        ti();
        ti();
        ti();
        pause();
    }

    public static void o() {
        ta();
        ta();
        ta();
        pause();
    }

    public static void main(String[] args) {
        s();
        o();
        s();
    }
}

No, már látszik az sos a main-ban!