Kezdődhet a party!

Szóval karácsonyi party, 400 részvevő, mindenki kap mindenféle innivalót, ki dől ki először, vagy kinek kell mosdóba menni előszőr?

A 400 Embert nem akarom 400 sorban létrehozni! Tegyünk inkább őket egy List konténerbe, és sorra itassuk őket Feri piájával!

// legyen egy konténer
List<Ember> emberek=new ArrayList<>();

// teszünk bele 400 vendéget, a nevük Vendég 0, Vendég 1, stb... 
// mind 1 deci alkoholt bír
for (int i=0;i<400;i++) {
    emberek.add(new Ember("Vendég "+i,1));
}

Eddig okés? Okés! Na akkor hogyan kínálunk meg mindenkit Feri piájával? For each ciklussal!

for (Ember ember:emberek) {
    ember.igyal(feri.adjEgyet());
}

Oké, akkor ez volt egy kör! De persze addig itatjuk őket, amíg valaki feladja! Szóval gyarkolatilag ameddig csak bírjuk, itatjuk, mert ha valaki feladja, abból úgyis egy exception lesz, ami megállítja a programot... megállítaná, de persze mi elkapjuk majd az exceptiont.

while (true) {
    for (Ember ember:emberek) {
        ember.igyal(feri.adjEgyet());
    }
}

A végén hogy írjuk ki, hogy ki mit ivott? Persze for-each ciklussal végigszaladunk rajta, és ki lehet iratni minden Embert. Ekkor a toStringje hívódik meg, ami mindent összerak:

for (Ember ember:emberek) {
    System.out.println(ember));
}

Készen vagyunk!

No tegyük össze: 400 személyes kocsmai buli,

• túl sok alkoholfogyasztás ellenőrzéssel
• mosdószünet-ellenőrzéssel
• a végén az első mosdózó vagy kidőlő vendég kiírásával
• minden vendég teljes fogyasztásának kiírásával

éééés (dobpörgés) csak ennyi az egész:

public class Kocsma {

    public static void main(String[] args) {
        List<Ember> emberek=new ArrayList<>();

        for (int i=0;i<400;i++) {
            emberek.add(new Ember("Vendég "+i,1));
        }

        Pultos feri=new Pultos();
        try {
            // megy amig birják
            while (true) {
                for (Ember ember:emberek) {
                    ember.igyal(feri.adjEgyet());
                }
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        for (Ember ember:emberek) {
            System.out.println(ember);
        }
    }
}

Vendég 1 most feladta, mert szünetre van szüksége!
Vendég 0 megivott 6.5 deci italt, össz. 0.52 deci alkohol tartalom.
  Kozel sör, 5.0 deci, 4.0%
  Törkölypálinka, 0.5 deci, 40.0%
  Kannás bor, 1.0 deci, 12.0%

Vendég 1 megivott 11.0 deci italt, össz. 0.52 deci alkohol tartalom.
  Kannás bor, 1.0 deci, 12.0%
  Kozel sör, 5.0 deci, 4.0%
  Kozel sör, 5.0 deci, 4.0%

Vendég 2 megivott 2.0 deci italt, össz. 0.24 deci alkohol tartalom.
  Kannás bor, 1.0 deci, 12.0%
  Kannás bor, 1.0 deci, 12.0%.
.
.

Szerintem igazán nem rossz! Persze, lehet, hogy Te másként gondolod. Jogos a kérdés, hogy miért kell 6 külön file-ba tenni a program osztályait, meg hogy egyáltalán, azért valljuk be, elég sokat küzdöttünk, mire eljutottunk eddig. Talán még az a gyarló ötlet is megfordulhatott a fejedben, hogy mégiscsak jobb lett volna inkább így csinálni:

public class Kocsma {

    public static void main(String[] args) {
        double jack=0;
        double jane=0;

        jack+=5*0.05; // egy sör
        if (jack > 1.2) {
            System.out.println("Jack kidőlt!");
        }

        jack+=5*0.05; // második sör
        if (jack > 1.2) {
            System.out.println("Jack kidőlt!");
        }

        jane+=0.5*0.40; // egy pálinka
        if (jane > 1) {
            System.out.println("Jane kidőlt!");
        }

        jack+=0.5*0.40; // egy pálinka
        if (jack > 1.2) {
            System.out.println("Jack kidőlt!");
        }

        jack+=0.5*0.40; // még pálinka
        if (jack > 1.2) {
            System.out.println("Jack kidőlt!");
        }

        jane+=1*0.12; // egy bor
        if (jane > 1) {
            System.out.println("Jane kidőlt!");
        }

        System.out.println("Jack "+jack+" deci alkoholt tartalmaz.");
        System.out.println("Jane "+jane+" deci alkoholt tartalmaz.");
    }

}

és erőből másolgatni a sorokat, közben óvatosan figyelve a számokra.

Nos, egy új dolog, egy új technológia először mindig nehéznek tűnik. Emberi tulajdonság, hogy utáljuk az új dolgokat, félünk tőlük: hiszen az új ismeretlen, meg kell tanulni. Volt idő, amikor az emberek nem mertek vonatra szállni, mert rettegtek, hogy mi történik olyan hatalmas sebességnél (ami akkor kb. 30 km/h volt).

Viszont az új dolgok előnyöket is hordoznak, és okkal léteznek. Az autók gyorsabbak, mint a lovak - igaz, hogy autókat tervezni és gyártani nehezebb, mint lovakat. Az Interneten keresni gyorsabb, és könnyebb, mint egy könyvben - igaz, hogy Internetet és számítógépet csinálni nehezebb, mint könyvet nyomtatni.

Az OOP is valami ilyesmi: sokkal jobban járunk vele, de természetesen nem ígértem, hogy egyszerű lesz. Az OOP célja pont az, hogy a nehéz feladatokat lehessen vele könnyen megoldani, nem pedig az, hogy a könnyű feladatokat legyen könnyű megoldani. Emiatt jogos a felvetés, hogy a nyomi programokhoz túlzás az OOP, ugye? Azok túl könnyűek, az OOP-vel csak bonyolítjuk őket.

Valahogy így képzelem:

• az OOP-vel a feladat bonyolultságával lassan nő a megoldás bonyolultsága
• nem OOP-vel a feladat bonyolultságával hatványozottan hirtelen nő a megoldást bonyolultsága

Valahol a 100 soros programoknál van a határ. Ha attól nagyobbra vágyunk, akkor az OOP-vel jól fogunk járni!