Kihagyás

Fejlettebb Java nyelvi elemek

Előadásfóliák

A mai (utolsó) anyagban néhány olyan Java nyelvi elemről lesz szó, ami jól használható a programozás során. (Majdnem) mindet meg lehet oldani más módon is, de a használatuk egyszerűbbé teheti a programozást.

Generikus programozás

280: Generics, általános, (majdnem) típusfüggetlen programozás. A generikus programozás arra jó, hogy a megírt osztályainkat, algoritmusainkat típusfüggővé tehessük a nélkül, hogy típusfüggő módon kellene megvalósítani őket. A legjobb, már látott példa a kollekcióké: az alap kollekciók Object-eket tárolnak. Mivel minden osztály az Object-ből származik, ez a tárolásra nem jelent korlátozást, a használata viszont (mint láttuk) nehézkes: nekünk kell odafigyelni, hogy mit pakolunk be, illetve, hogy amit kiveszünk, az valójában micsoda. A generikus programozás során meg tudunk adni típusokat, mint paramétert. Így egy kollekció már nem Object-eket, hanem bármilyen C konkrét(abb) objektumot képes tárolni, és tudja is, hogy mit tárol, vagyis, amikor pl. kivesszük az objektumot, pontosan (?) tudjuk, hogy mi a típusa.

281: Mi magunk úgy készíthetünk generikus, típussal paraméterezhető osztályokat, hogy < és > jelek közé írunk egy szimbólumlistát, amelyet a megvalósításban típusként használhatunk. Ezekre a típusokra megkötéseket tehetünk (P extends Number: csak olyan típus elfogadható, ami a Number leszármazottja, mint például az Integer). Metódusoknak is adhatunk típus paramétert, a metódusnév és a paraméterlista között hasonlóan < és > jelek között. Amikor egy generikus osztályt (vagy metódust) használunk, akkor azt fel kell paraméterezni megfelelő típusokkal, így olyan lesz, mintha eleve ezekkel a típusokkal írtuk volna meg.

Anonymous osztályok

283: Az anonymous osztályok arra jók, hogy ha az adott osztályt mindössze egyetlen helyen, egyetlen példányban használnánk, akkor ne kelljen külön osztályt létrehozni, nevet kitalálni neki, stb. E helyett (látszólag) az ősosztályából hozunk létre egy példányt, amit ott helyben felül is definiálunk/kibővítünk. Ilyenkor gyakorlatilag mégis létrejön egy új típus, és a létrehozott objektum ilyen típusú lesz, de erre a konkrét típusra nem hivatkozhatunk, nem is akarunk hivatkozni.

284: Itt például az új névtelen típus az EventHandler -ből származik (valójában az Object-ből, és az EventHandler-t "csak" implementálja), és az EventHandler handle() metódusát írja felül.

285: Itt pedig a Comparator -nek lesz két leszármazottja (valójában szintén "csak" implementációja), és ezeknek egy-egy példánya, amiket egy-egy rendezésben használunk.

Lambda kifejezések

287: Gyakorlatilag az anonymous osztályok megadásának még tovább egyszerűsítése. Ha egy interfész osztály egyetlen metódust deklarál, akkor az implementáló osztálynak egyetlen metódust kell megvalósítania. Java 8-tól lehetőség van arra, hogy csak ezt a metódust adjuk meg, erre való a lambda kifejezés. Itt például a (Comparable interfész compareTo() metódusával megvalósított) természetes rendezés megfordítását adjuk meg lambda segítségével. A Comparator egyetlen metódust, az int compare(Elem, Elem) metódust definiálja, így ez megadható lambda szintaxissal, amiben a visszatérési érték a jobboldali elem baloldalival való összehasonlítása. Mint látható, a metódus nevét nem kell külön megadni (azt a Java "kitalálja" helyettünk).

290: Ha a lambda-ként megadandó metódus már létezik, akkor lambda szintaxis helyett metódus referenciával hivatkozhatunk a már megírt metódusra, és használhatjuk azt.

Annotációk

293: Az annotáció egy extra jelölésrendszer a Java-ban, amivel nagyon sokmindent meg lehet valósítani. Kezdve az olyan egyszerű dolgoktól, hogy fordítás közbeni ellenőrzések, egészen akár a kódgenerálásig (vagyis amikor egy egyszerű annotáció segítségével megspórolunk magunknak fél óra mechanikus kódolást).

295: A unit tesztek arra jók, hogy a kód egyes elemeinek működését (önmagukban) leellenőrizzük. Java-ban a JUnit keretrendszer segítségével lehet ilyen teszteket írni és futtatni. A JUnit annotációkat használ.

296-297: A tesztírás alapvetően úgy megy, hogy létrehozunk egy (vagy több) teszt osztályt, benne teszt metódusokkal, amik majd az ellenőrzéseket végzik. Az a metódus számít tesztesetnek, ami a @Test annotációval meg van jelölve. Egy-egy ilyen tesztesetben az Assert/Assertions osztályok metódusaival tudjuk ellenőrizni, hogy a tesztelt osztállyal végzett számítások az elvárt eredményt adják-e. Lehetőség van továbbá olyan metódusok megírására is, amelyek minden egyes teszt előtt és után, illetve az osztály összes tesztje előtt és után futnak le, ezeket is külön annotálni kell a megfelelő módon. Ezek a tesztek előkészítésére illetve a végén "takarításra" jók. A JUnit keretrendszer automatikusan össze tudja gyűjteni ezeket a teszteket, le tudja őket futtatni, és rögzíteni tudja az eredményeiket (pass/fail).

Változó paraméterlista

300: A változó paraméterlista Java-ban megint csak egy szintaktikai ügyeskedés. Alapvetően ugye egy metódusnak fix számú és típusú paramétere van. Java-ban ez könnyen kijátszható, ha tömböt adunk át, ez ugyanis akármekkora lehet. Van viszont vele egy kis gond: a tömböt a hívás előtt külön össze kell rakni. No, ehhez kapunk egy kis szintaktikai segítséget a változó paraméterlista formájában. Itt arról van szó, hogy ha egy metódus utolsó paraméterét ...-tal deklaráljuk, akkor a híváskor ide akárhány adott típusú argumentumot megadhatunk. Ugyanúgy egy tömb készül belőlük (és a metódusban a paraméter már tömbként használható), csak a híváskor ezt a tömböt nem nekünk kell kézzel összerakni, hanem a Java megcsinálja helyettünk.


Utolsó frissítés: 2022-03-04 08:24:04