Összefoglalás

Eddig megtanultad az OOP programozáshoz szükséges dolgok 99%-át. Van pár dolog, amit elhallgattam, mert elsőre nem annyira fontosak, de később ezekre is sor kerül.

OOP elvek

Egységbe zárás (encapsulation)

Egy objektum adatok (attribútumok) és az azokat használó műveletek (metódusok) egysége.

Öröklés (inheritance)

Egy leszármazott osztály megörökli az ős-osztály minden attribútumát és metódusát, így nem kell ezeket újra meg újra leírni.

Többalakúság (polimorfizmus)

Egy leszármazott osztály felülbírálhatja az ős-osztályból örökölt metódusokat, amik így képesek másként viselkedni. (override)

(Igaziból van, aki szerint 4 alapelv van, és van, aki szerint 7 alapelv van. Bizonyára lehet találni olyat is, aki mind a 99 alapelvet ismeri, de ez a három a legfontosabb.)

OOP a gyakorlatban

Objektum-osztály

• attribútumok (attribute), azaz tulajdonságok, változók
• ezeken a tulajdonságokon műveleteket végző metódusok (method), azaz függvények
• a konstruktor olyan metódus, ami egy példány létrehozásakor hívódik meg, itt az objektum változóinak adhatunk értelmes kezdőértéket
• mindig nagybetűvel kezdődik, pld. Ember
• olyan, mint egy "terv"

Objektum-példány

• egy osztályból létrehozott használható példány
• a konstruktor meghívásával (new operátor) hozzuk létre: john=new Ember()
• úgy használhatjuk, mint egy szuper-változót, ami egyszerre több értéket tartalmaz, és műveletei is vannak, amihez a . (member operátor) való: john.iszik(...)
• mindig kisbetűvel kezdődik, pld. john=new Ember()
• olyan, mint egy "tárgy"

Minden dolog objektum-példány

• a Java-ban tényleg minden az, beleértve:
• String
• Exception
• Integer
• Boolean
• Char
• Double

Kivéve a néhány primitív típust:

• int
• boolean
• char
• double

A primitív típusok használata picit gyorsabb programot eredményez.

Autoboxing, auto-unboxing:

• matematikai műveleteket objektumokkal nem lehet csinálni, (a john+sör eredménye nem értelmes, de a 3+2 az igen)
• ezért az Integer, Double, stb. objektum típusokat automatikusan primitívre konvertálja, amikor számolni akarunk vele, tehát Integerből int lesz, így úgy tűnik, hogy lehet vele számolni
• a primitív típusokat automatikusan objektumra konvertálja, ha valahova objektum kell, tehát int-ből Integer lesz amikor pld. egy konténerbe tesszük

null

A null azt jelenti, hogy semmi, nem megadott érték. Egy objektum lehet null, ha még nincs példánya létrehozva:

Ember portas; // most john értéke null

if (portas==null) {
    System.out.println("Még nincs portásunk!");
}
else {
    System.out.println(portas);
}

Ember portas; // most john értéke null

portas=new Ember("Géza bácsi"); // most már nem null

if (portas==null) {
    System.out.println("Még nincs portásunk!");
}
else {
    System.out.println(portas);
}

Öröklés

• minden objektum-osztály az Object nevű ős-osztályból származik, és ennek örökli minden metódusát.
• az extends kulcsszóval egy osztály más osztály összes attribútumát és metódusát megörökli, így ezeket nem kell újra meg újra megírni
• a megöröklött dolgokon túl természetesen további attribútumokat és metódusokat is csinálhatunk

Override (felülbírálás)

• egy megörökölt metódust felülbírálhatunk - azaz a megörökölt metódus helyett sajátot adhatunk ugyanolyan névvel, például csinálhatunk saját toString-et
• mindig használj explicit @Override annotációt

this és super

• this = saját magunk, akkor használjuk, ha egy metódusban ugyanolyan nevű változó vagy paraméter van, mint ami már létezik az osztályon belül is. A this-el dekorált név jelenti az osztályon belülit, míg a dekoráció nélküli a metóduson belülit.
• super = a felmenőnk, azaz az ős-osztály, akkor használjuk, ha az ős-osztályból akarunk meghívni egy metódust, pld. super.iszik(). Az ős-konstruktort úgy hívjuk meg, hogy nincs a super mellett semmi, tehát super(1,2,3).

exception

• megállítja a programblokk futását ha olyan dolog történt, ami miatt nem folytatható értelmesen
• elkaphatjuk a try..catch-el
• struktúrált hibakezelés: a "normális" futás és a hibakezelés két külön utasításblokk: a try-ban amit meg szeretnénk csinálni, a catch-ben meg hogy mi legyen, ha ez nem sikerült

visibility (láthatóság)

• ki láthassa az osztályunk attribútumait és metódusait? Aki látja, az bármit csinálhat vele, ami nem mindig értelmes
• private - csak az osztályon belül látszik
• protected - az osztályon belül látszik, és az osztályból leszármazott osztályok is látják
• public - nyilvános, azaz mindenki látja
• van pár egyéb spéci dolog itt, ami most nem lényeges

getter és setter

• getter: külön metódus arra, hogy egy attribútumot kiolvassunk (ezzel szándékosan nem lehet írni),
• setter: vagy külön metódus arra, hogy egy attribútum értékét átírjuk (ezzel meg nem lehet kiolvasni)
• Java bean: olyan osztály, ahol az attribútumok mind private-k és getterekkel, setterekkel
• a boolean mezők gettere nem getXXX, hanem isXXX formátumú!

Konténerek

• használj konténereket, pld. List, ha valamiből több példányt szeretnél tárolni, és tegyük fére a tömböket
• használj for-each ciklust a konténer elemein való végiglépkedéshez, és tegyük félre a hagyományos for ciklusokat

Javadoc

• használd az Alt+Shift+J-t ami javadoc komment vázat tesz arra a nyelvi elemre amin a kurzor áll éppen
• mindem public és protected dolgot kommentálj Javadoc-al

Elnevezések

• használj angol neveket
• az osztályok, attribútumok főnevek
• a metódusok igék

Hogyan tovább?

Ez a pár rész kifejezetten szárazra sikerült. Van egy csomó olyan elv, amit meg kellett ismerned ahhoz, hogy a következő részekben könnyen tudd használni a Java lehetőségeit. Innentől már minden ismerős lesz!

De tudod mit? Nyomtasd ki az összefoglalót hogy mindenre emlékezz!