Jim beszáll

Azt állítottuk, hogy az OOP-vel programozást lehet megtakarítani. Kevesebbet kell írni. Amit eddig csináltunk, az szép, olvasható, nagyszerű, de lehet, hogy ha megszámolnánk, több sor program lenne, mint az első Kocsma próbálkozás OOP nélkül.

Hol térül meg az OOP?

Szerintem az OOP már a tervezésnél megtérül, hiszen vacakolás nélkül, az eredeti feladatot modellezve tudtunk programot csinálni. Akkor is megéri, ha változtatni kell valamin, és nagyon nagyon megéri, ha egy dologból több példányra van szükségünk.

Lássuk, mi van, ha Jim is beszáll!

Mit kell átírni? Jim egy Ember, aki a Kocsmába került, és ugyanazokat az Innivalókat issza, mint Jack és Jane. Tehát csak a Kocsma osztályt kell megváltoztatni.

Jim nagyivó, és 2 decinyi nyers alkoholt is kibír. Hát lássuk:

public class Kocsma {

    public static void main(String[] args) {
        Ember jack=new Ember("Jack",1.2); 
        Ember jane=new Ember("Jane",1);
        Ember jim=new Ember("Jim",2); // Hurrá, Jim!

        jack.igyal(new Sor());
        jack.igyal(new Sor());

        jane.igyal(new Palinka()); 

        jack.igyal(new Palinka()); 
        jack.igyal(new Palinka()); 

        jane.igyal(new Bor()); 

        // na most Jim jön, pálesz-sör fordulókkal
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
        jim.igyal(new Palinka()); 
        jim.igyal(new Sor()); 
    }

}

Mit kellett változtatni?

Egyetlen sorral kifejeztünk minden dolgot, amit Jim csinál. Nincsnenek mágikus változók, szorzások, if-ek, stb.

Ha mondjuk karácsonyi partit csinálunk? Akkor 400 Ember példányt is létrehozhatunk, és össze-vissza itathatjuk őket. Ennek ellenére csak new Ember, meg igyál metódus van, tehát tényleg csak a lényeg látszik.

Ez a lényeg. Ez magasszintű programozás (ami nem azt jelenti, hogy "olyan bonyolult hogy senki sem érti meg", hanem azt jelenti, hogy a lényegre fókuszálunk, és nem a lényegtelen dolgokra).

Ha bármikor csúnya, hosszú, csak sok-sok megjegyzéssel megérthető programot látsz, tedd fel magadnak a kérdést: ennek muszáj ilyen alacsony-szintűnek lennie?

"Egy programozási nyelv akkor alacsony szintű, ha arra kényszeríti az embert, hogy az érdektelen dolgokra is odafigyeljen."

-Alan J. Perlis, több programozási nyelv atyja, a Turing Award első díjazottja

Mi a konklúzió?

A magasszintű objektum-orientált programozás egyszerűvé és átláthatóvá teszi a programjainkat, ráadásul az igazi progikat sokkal rövidebbekké is.