öröklődés - címke - Oldal 3 a 4-ből

Népesedési világnap

2023. augusztus 4.2020. július 11. Szerző: Balogh Péter

Az ENSZ 1987-ben július 11-ét a népesedési világnappá (World Population Day) nyilvánította. Bolygónk lakossága aznap érte el az 5 milliárdot. További kerek számok voltak: 1999. október 12-én 6 milliárd, 2011. október 30-án 7 milliárd. További kerek számok várhatóak: 2023 – 8 milliárd, 2037 – 9 milliárd, 2057 – 10 milliárd. A KSH elemzése részletes elemzéseket közöl évről-évre a témában, például: 2019-ben, 2018-ban. A worldometer.info weboldalon folyamatosan frissülő kimutatások érhetők el a népességhez globálisan, valamint országonként is: például Magyarország aktuális népesedési adatai.

A népesedési világnap inspirált egy Java program megtervezésére és megírására. A swing GUI-s program megjeleníti a worldometer.info weboldalról kinyerhető adatok alapján régiónként (kontinensenként) az elérhető adatokat 1950-től 2020-ig az alábbiak szerint egy világtérképen.

Az elkészült program

Tervezés

Objektumorientált szemlélettel, MVC architekturális tervezési mintát követünk, angol nyelvű interfész, osztály, változó, objektum, metódus nevekkel. A projekt neve: WorldPopulation, a csomag neve: worldpopulation. Amit lehet, konstansként interfészbe (szeparálva) teszünk és az MVC rétegekhez kötődő osztályok implementálják. A modell minden évszámhoz tárolja a szükséges adatokat, mindezt egyetlen betöltéssel/letöltéssel éri el. A program kliensként hat régióra vonatkozó adatot gyűjt össze, alkalmazkodva a szerver adatforráshoz. A címsorban lévő összesített adat is elérhető közvetlenül a weboldalon, de a kisebb adatforgalom érdekében hasznos inkább a kliensben összesíteni. Mindössze egyetlen eseménykezelés szükséges: a csúszka beállításával megadott évszám alapján frissíteni kell a régiók címkéit és az ablak címsorát. Öröklődés hasznos a feladat megoldása során: egyrészt interfészek, másrészt osztályok között.

Interfészek

Az ősinterfész a WorldPopulationConstants, benne az évszám intervallum MIN_YEAR és MAX_YEAR határaival, valamint a megjeleníthető régiók neveivel tömbben: REGION_NAME_ARRAY. Két utódinterfész épül az ősre: ModelConstants és ViewConstants. Előbbi interfész az adatforráshoz kapcsolódik: URL_COMMON az URL eleje, URL_ARRAY az URL végei régiónként tömbben. Utóbbi interfész a megjelenítéshez kapcsolódik: WORLD_MAP_IMAGE a háttérkép annak WORLD_MAP_RECT méretével együtt, valamint a régiónkénti REGION_RECT_ARRAY téglalapok tömbje a kezdeti pozíciókkal/méretekkel, TITLE a sablon a program címsorához (frissítendő az évszámmal és az összesített népességgel). A megfelelő utódinterfészt mindig implementálja az MVC szerint hozzá illeszkedő osztály.

Osztályok

A belépési pont a WorldPopulation.java fájlban található.

Három összetartozó elemi adatot fog össze egybe a RegionData POJO, ezek name, year, population nevű rendre String, int, long típusú adatok. Például: Európa, 2020, 747643253. Tartalmaz két függvényt: getPopulation(), valamint toString(). Utóbbi HTML formátumban adja vissza a megjelenítendő adatokat.

A JLabel-ből származik az igényekhez alakított RegionLabel osztály. Ennek van előre megadott pozíciója, mérete, betűtípusa, betűmérete, sárga háttérszíne, piros kerete. Ezenkívül a téglalap átlátszó, valamint a benne megjelenő HTML tartalom vízszintesen középre igazított. Némi extra funkció, hogy egérrel megfogva – drag and drop – áthelyezhető, ami a MouseMotionListener egérmozgást figyelő interfész mouseDragged() metódusának felülírásával válik lehetővé. A mozgathatóságáért saját maga felel. Példaként közöljük az osztály teljes forráskódját:

package worldpopulation;

import java.awt.Color;

import java.awt.Font;

import java.awt.Rectangle;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionAdapter;

import javax.swing.BorderFactory;

import javax.swing.JLabel;

import javax.swing.SwingConstants;

public class RegionLabel extends JLabel {

public RegionLabel(Rectangle bounds) {

setBounds(bounds);

setFont(new Font("Tahoma", Font.PLAIN, 14));

setHorizontalAlignment(SwingConstants.CENTER);

setBorder(BorderFactory.createLineBorder(Color.RED, 2, true));

setBackground(Color.YELLOW);

setOpaque(true);

addMouseMotionListener(new MouseMotionAdapter() {

@Override

public void mouseDragged(MouseEvent e) {

setLocation(getX()+e.getX()-getWidth()/2,

getY()+e.getY()-getHeight()/2);

}

});

}

A webről adatokat szerez és tárolja a Model osztály, a java.io és java.net csomagokra építve. Egy példa: a https://www.worldometers.info/world-population/europe-population/ oldal forrásából nyeri ki az osztály az alábbi adatokat:

var dataT=new google.visualization.DataTable(

{cols: [

{type:'date',label:'Date'},{type:'number',label:'Europe Population'}

rows: [

{c:[{v:new Date(1950,6,1)},{v:549328883}]},

{c:[{v:new Date(1951,6,1)},{v:554324469}]},

...

{c:[{v:new Date(2019,6,1)},{v:747182751}]},

{c:[{v:new Date(2020,6,1)},{v:747636026}]}

]});

Ezek parszolását követően elkészül egy optimálisnak tekinthető, generikus listákból álló regionListArray tömb adatszerkezet. A parszolás történhet egyszerű szövegkezeléssel vagy JSON feldolgozással is. Erre épülnek a konstruktorral és vezérlővel összehangoltan működő getter metódusok: getHTML(), getRegionList(), getRegionData(), getPopulation(). A JSON adatforrás feldolgozását most nem részletezzük, de hasonlóról blogoltunk már: Időjárás Budapesten.

A grafikus felhasználói felületet adja a JFrame utód View osztály. Három GUI komponensből áll: pnWorldMap – háttérkép JPanel, lbYear – kiválasztott/aktuális év JLabel, slYear – kiválasztható/görgethető aktuális év JSlider. Izgalmas megoldani egymásra/egymáson elhelyezni a komponenseket. Egy JLayeredPane komponens DEFAULT_LAYER rétegére kerül a térképet tartalmazó háttérkép, majd a PALETTE_LAYER rétegére kerül dinamikusan a hat RegionLabel osztályú/típusú objektum. A csúszka komponens slYearStateChanged() eseménykezelő metódusa vezérlőként megszólítja a modell réteget és a visszakapott adatokkal frissíti a nézet réteget (a címsorban lévő összesítéssel együtt, ezres szeparátorokkal).

Ötlet továbbfejlesztésre

Hat különböző weboldal forráskódjából kell összegyűjteni a megjelenítendő adatokat. Ez 2020-ban régiónként 71 számot jelent és hat régió van. Érdemes lehet olyan adattárolást megvalósítani, amely csökkenti a szerverhez fordulások számát, illetve a letöltendő adatok mennyiségét. Hiszen a múltbeli évekhez kötődő historikus adatok nem változnak. Ha ezekre valamilyen formában a program emlékszik, akkor elegendő az utolsó tárolt évből kiindulva az aktuális évig évenként, régiónként lekérni mindössze 6, 12, 18… számot, a program utolsó futtatásának évéből kiindulva. Ez lényegesen kevesebb lenne, mint a jelenlegi 6*71 lekért szám. A koncepció kulcsszava: inkrementális adatfrissítés. Ha megvalósítjuk az ötletet, akkor figyelni kell arra, hogy az aktuális/utolsó évben az adatok akár másodpercenként is változhatnak.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam tematikájához kötődik (ha a swing GUI-ra koncentrálunk és az adatok helyi fájlrendszerből elérhetők), és a Java EE szoftverfejlesztő tanfolyam tematikájához kapcsolódik (ha az adatokat közvetlenül a webről olvassuk).

Hóesés szimuláció

2023. augusztus 4.2019. december 18. Szerző: Balogh Péter

Hóesés szimulációt tervezünk és valósítunk meg Java nyelven. A téma igazi örökzöld. Elvileg minden télen aktuális. 😉 A grafikus felülethez és az eseménykezeléshez a swing gyűjteményt használjuk. Adott egy téglalap alakú terület amelyen – méretéhez igazodva – több száz hópehely mocorog. A területet önállóan programoztuk le – azaz ez alkotja a teljes GUI-t –, de lehetne egy nagyobb kép része is. Többféleképpen is beépítünk véletlenszerűséget a szimulációba. Tervezünk is, hiszen az sosem árt. 😉

Többnyire beépített komponenseket, elemeket használunk, de van saját, örökítéssel testre szabott komponensünk is:

A szimuláció a Window osztályból példányosított felületen működik, amely JFrame utód. Nem átméretezhető és látható.
A területet JPanel típusú pnTransparentWindow alkotja. Mérete 300*200 pixel. Színe a szürke egyik árnyalata. Ezen mozognak a hópelyhek.
A hópehely Snowflake típusú JPanel utód. Mérete 2*2 pixel. Színe fehér. Saját swing-es Timer biztosítja az eseménykezelését. A szimulációban 600 hópehely szerepel.

Az elkészült szimuláció

A teljes forráskódból íme a hópehely megvalósítása

public class Snowflake extends JPanel {

private Rectangle rectangle=null;

private Dimension size=new Dimension(2, 2);

private int delay=(int)(Math.random()*5+1)*50

private Timer timer=new Timer(delay, (ActionEvent e) -> {

move();

});

A hópehelynek „tudnia kell” hol van, azaz mekkora területen mozoghat, ez a rectangle. A hópehelynek van size mérete. A hópehely saját magát mozgatja a területen a timer segítségével. Az időzítés várakoztatására/késleltetésére vonatkozó delay értéke véletlenszerűen 50, 100, …, 250 milliszekundum lehet. Másképpen: a szél által össze-vissza fújt hópelyhek között lehetnek lassabban és gyorsabban mozgók is. Az eseményobjektumhoz lambda kifejezés rendeli hozzá a reakciót jelentő, mozgást megvalósító move() metódus meghívását, amely így adott időközönként bekövetkezik.

public Snowflake(JPanel pnTransparentWindow) {

rectangle=pnTransparentWindow.getBounds();

setPreferredSize(size);

int x=(int)(Math.random()*rectangle.width);

int y=(int)(Math.random()*rectangle.height);

setBounds(x, y, size.width, size.height);

setOpaque(true);

setBackground(Color.WHITE);

timer.start();

}

A hópelyhet a konstruktora hozza létre. Átveszi azt a pnTransparentWindow területet, amelyre később rákerül a Window példányosítása során. A gyengébb setSize() metódus helyett az erősebb setPreferredSize() metódus állítja be a méretet. Véletlenszerű x és y pozícióba kerül ki/fel a területre. A setBounds() örökölt metódus beállítja a pozícióját és méretét. Erre épít a fogadó oldalon az abszolút helyzet, külön elrendezésmenedzser nélkül. Végül a hópehely átlátszó, fehér és elindítja saját időzítőjét a timer.start() metódushívással.

Az időzítés/várakoztatás véletlenszerűsége után íme a második véletlenszerűség a szimulációban. A hópehely mozgása során a szél által össze-vissza fújva eltérő eséllyel/valószínűséggel mozog 8 lehetséges irányba az alábbiak szerint:

5-5% eséllyel felfelé, azon belül jobbra vagy balra (átlósan),
10-10% eséllyel jobbra vagy balra,
20-20% eséllyel lefelé, azon belül jobbra vagy balra (átlósan),
30% eséllyel lefelé, függőlegesen,
felfelé, függőlegesen nem mozog.

Az esélyek összege 100%. Másképpen kulcsszavakban: 1 = biztos esemény (teljes eseménytér, nincs más lehetőség), egymást kizáró események, geometriai valószínűség. A képen középen lévő hópehely a 8 szomszédja közül a 7 szóba jöhető közül valamelyikre adott eséllyel mozog. A geometriai valószínűséget az ábra alapján az óramutató járásával megegyezően leképeztük az 1..100 intervallumra:

public void move() {

Point location=getLocation();

int tip=(int)(Math.random()*100+1); //1-100

if(1<=tip && tip<=5)

location.translate(size.width, -size.height); //jobbra fel

else if(6<=tip && tip<=15)

location.translate(size.width, 0); //jobbra

else if(16<=tip && tip<=35)

location.translate(size.width, size.height); //jobbra le

else if(36<=tip && tip<=65)

location.translate(0, size.height); //le

else if(66<=tip && tip<=85)

location.translate(-size.width, size.height); //balra le

else if(86<=tip && tip<=95)

location.translate(-size.width, 0); //balra

else //96<=tip && tip<=100

location.translate(-size.width, -size.height); //balra fel

if(rectangle.height<location.y)

location.translate(0, -(int)location.getY());

setLocation(location);

}

A move() metódus megvalósítja a fenti tervnek megfelelően a hópehely mozgatását. Első lépésben tudni kell a jelenlegi/kiinduló location helyét (a bal felső csúcs, elkérjük). Ezután véletlenszerű esély/ tip generálódik. Az első elágazásban a hópehely translate() metódusával eltoljuk az előbb elkért pontot. Az eltolás relatív. Az utolsó elágazásban kompenzálunk, ha a hópehely alul kilépne a területről. Ekkor felül újra belép a területre. Végül beállítjuk a hópelyhet megvalósító komponenst a manipulált location helyre.

Takarékosak vagyunk: ezzel a megoldással „újrahasznosítjuk” a hópelyheket. Csak annyi van belőlük, amennyi szükséges. Nem kell őket folyamatosan megszüntetni és újra létrehozni. Nem mozognak feleslegesen. Nem mozognak olyan területen, ahol nem láthatóak.

Ötletek továbbfejlesztésre

A hópelyhek színe lehetne véletlenszerű a fehér és a középszürke között. Ezzel a nézőtől való távolságot, esetleg a kép élességét lehetne modellezni.
A szél nem feltétlenül szimmetrikus, vagy a hópelyhek mozgatását meg lehetne oldani jobbra és balra eltérő eséllyel is.
A terület lehetne más alakú, például trapéz, íves, kör, ellipszis.
Másképpen is vezérelhetnénk a szimulációt. Ahelyett, hogy most minden hópehelynek van saját időzítője, lehetne csak 5 db (lassabbak és gyorsabbak), amelyek közül véletlenszerűen kiválaszthatnánk, hogy melyik hatására mozgatjuk az adott hópelyhet. Fordítva is mehetne: az 5 db időzítőhöz előre hozzárendelhetnénk a hópelyheket. Ez így más-más felelősség, kommunikáció, üzenetküldés, vezérlés lenne az objektumok között. Hasznos tapasztalat lehet megvalósítani bármelyiket.
A terület lehetne egy nagyobb kép része. Például meghatározhatnánk egy tetszőleges átlátszóságot (színt vagy arányt) és többrétegű felületet megvalósítani képes JLayeredPane komponens elé vagy mögé is elhelyezhető lehetne a terület a grafikus felületen.
Aki kihívást keres: illessze a területet az alábbi hangulatos képre úgy, hogy a középső ablakok téglalap alakúak, a két szélső trapéz alakú vagy perspektivikus nézetű és a kör/ellipszis alakú tükörben pedig tükröződik valahonnan a hóesés látványa.
Még bátrabbaknak: a kandallóban lévő tüzet is lehet hasonlóan szimulálni. Itt már többféle fizikai paraméter is figyelembe vehető, például fényerősség, tükröződés. Egy 3D modellezett térben a sugárkövetés (Ray Tracing) algoritmus is megvalósítható. A hópelyheknél lehetne az egyszerű mozgástól eltérő más fizikát is programozni: rugalmas ütközéssel összetapadhatnának vagy rugalmatlan ütközéssel lepattanhatnának egymásról és mindez hathatna a sebességükre is.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A Java SE szoftverfejlesztő tanfolyamunkon, a szakmai modul Objektumorientált programozás témakörét követő 29-36. óra Grafikus felhasználói felület alkalmain már tudunk egyszerűbb szimulációs programot tervezni, kódolni, tesztelni.

ASCII művészet Java-ban

2023. augusztus 4.2018. december 7. Szerző: Berecz Antónia

Áttekintjük a karakteralapú rajzolás lehetőségeit Java 2D grafikával, illetve a karakterfüzérek képként való kezelésének újabb lehetőségeit is.

Az ASCII művészet jelentése és kezdete

Az ábécék betűiből/szövegeiből kialakított ábrák egyidősek lehetnek az írásbeliséggel. A technológiától függetlenül a karakterekből kialakított kép megjeleníthető: papír és penna vagy írógép, illetve számítógép és nyomtató vagy monitor segítségével.
Az ASCII művészet (ASCII art) tágabb értelemben a szövegalapú vizuális művészetre vonatkozik. Szűkebb értelemben véve a számítógépes grafika részterületének tekinthető. Az ASCII művészet számítógépet használ nyomtatható standard ASCII kompatibilis karakterekből álló képek készítéséhez és megjelenítéséhez. A képeken a képi elemek a nyomtatható karakterek, amelyek a pointilizmushoz hasonló optikai effektust mutatnak.
A művészeti ág indulása arra vezethető vissza, hogy a korai nyomtatókkal nem lehetett grafikát nyomtatni, a monitorokon nem lehetett grafikát megjeleníteni. Cégek, programok bannerjeinek, logóinak készítésére pedig akkor is volt igény. Ezek mellett például prezentációkhoz, kapcsolási rajzokhoz is használták az ASCII művészetet, valamint természetesen a korai e-mailekben is. A grafikus kártyák megjelenése előtti időkben pedig a videójátékok „grafikája” is ezzel a technikával készült.
Most nézzünk meg néhány lehetőséget saját programmal való képkészítésre.

ASCII képek rajzolása programozási alapismeretek tanulásakor

Saját programmal már az alapok tanulásakor készíthetők ASCII képek a vezérlő szerkezetek megismerése kapcsán. Az alábbi képek bemutatják a lehetőségeket.

További sok-sok kép található az alábbi weboldalakon:

Christopher Johnson’s ASCII Art Collection: https://asciiart.website
ASCII Art Archive: https://www.asciiart.eu
ASCII Art Dictionary / Collection: http://www.ascii-art.de/ascii

A 2D grafikával való szövegrajzoláshoz használható BufferedImage osztály

A BufferedImage osztály a java.awt.image csomag része. Az Image osztály utódja. Hozzáférhető képadat-puffert tartalmaz, colorModel-ből és képadatok raster-éből áll. A raster sampleModel-jében a sávok számának és típusainak illeszkedniük kell a színt és átlátszó (alpha) komponenseket megadó colorModel által megkívánt számhoz és típusokhoz. A BufferedImage típusú objektumnak van bal felső koordinátája (0, 0), ezért a létrehozásához használt raster-nek kell legyen minX=0 és minY=0 értéke. A BufferedImage osztály a raster fetch és set metódusaira, valamint a colorModel színmódosítási módszereire támaszkodik.

Szöveg képként megjelenítése karakterekkel a konzolon

public class ASCIIArtKep {

public static void main(String[] args) {

int kepSzelesseg=150, kepMagassag=20;

BufferedImage pKep=new BufferedImage(

kepSzelesseg, kepMagassag, BufferedImage.TYPE_INT_RGB);

Graphics2D kep2D=(Graphics2D)pKep.getGraphics();

kep2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,

RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

kep2D.drawString("it-tanfolyam.hu", 5, 10);

for(int y=0; y<kepMagassag; y++) {

StringBuilder kepEpito=new StringBuilder();

for(int x=0; x<kepSzelesseg; x++)

kepEpito.append(pKep.getRGB(x, y)==-16777216?" ":"X");

if(!kepEpito.toString().trim().isEmpty())

System.out.println(kepEpito);

}

A kép méretét beállítjuk. A Graphics2D osztály drawString() metódusával String-et képként jeleníthetünk meg. Bár elég „munkás”, de Java-ban gyakran BufferedImage példány létrehozásával oldjuk ezt meg, és a Graphics példányt attól kérjük el. A Graphics2D osztály karakterfüzérek rajzolásakor egyszerű mátrixszerű technikát használ. A String-et kirajzoló mátrixrészek nullától különböző értéket kapnak. A megjelenítendő terület értékét egyszerű adatként, például int-ként kell megadnunk, nem RGB színértékekkel. Ehhez a képtípust int-módba állítottuk: BufferedImage.TYPE_INT_RGB. Az ASCII képek alapötlete az, hogy a képmátrix nem nulla indexeihez hozzárendelt értékeket a kívánt művészi karakterrel helyettesítjük. A nulla értékű mátrixindexeknek szóközt adunk. A nulla integer-módban -16777216-tal egyenlő. Ezután a Java 2D grafika haladó renderelő beállításainak használatához kasztoljuk a Graphics objektumot Graphics2D példánnyá. Majd beállítjuk a kívánt renderelési paramétereket, végül meghívjuk a drawString() metódust egy karakterlánccal.

Íme az elkészült szöveg/képernyőkép:

A karakterek cserélgetésével a pozitív képből könnyen kaphatunk inverz/negatív képet is. A generált/renderelt képet fájlban is tárolhatjuk, például a javax.imageio.ImageIO osztállyal és adott a lehetőség a kép méretének megadására, a rajta megjelenő szöveg betűtípusának beállítására, háttérszín és szövegszín alkalmazására is.

A Java BufferedImage osztály néhány lehetőségének áttekintése után jó szórakozást kívánunk az ASCII képek létrehozásához, a lehetőségek további tanulmányozásához. Aki nem programból szeretne karakterekből/szövegekből felépülő képeket készíteni, használhat online alkalmazásokat is, például az Image to HTML/ASCII-t.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás, 2. rész alkalmához kötődik.

Denevérek a barlangban

2023. július 8.2018. július 6. Szerző: Kaczur Sándor

Évekkel ezelőtt hálózatos Java EE esettanulmányt akartunk készíteni Lengyel Borisz kollégával. Ötleteltünk: milyen technológiával és hogyan kommunikáljon egymással a szerver és a kliens(ek). A távoli metódushívás (Remote Method Invocation) mellett döntöttünk és elkészült a denevérek a barlangban projekt, amely evolúciós projektként azóta több változatot is megélt. A felhasználói felület (barlang) betölt néhány képet (denevér kliensek), amelyek a szerver segítségével mozognak.

Ismertetjük a tervezés folyamatát, a kliens és szerver funkcióit részletesen, végül ötleteket adunk a továbbfejlesztésre.

A főbb feladatokat így határoztuk meg:

az RMI kommunikációs módszer megismertetése,
az RMI szolgáltatás reprezentálása látványos grafikus/swinges klienssel,
alternatíva nyújtása a TCP protokoll közvetlenül csatlakozó socket-jére.

Elkészítettük az alábbi osztálydiagramot (persze ez nem az első változat):

A szerver és kliens funkcióit megvalósító osztályok/interfészek feladatait így határoztuk meg:

BarlangDenevérInterfész interfész:

véletlen 5 és 10 közötti a denevérek száma,
méretek a GUI-hoz.

Denevér osztály:

megvalósítja az RMI kliens funkciót,
JLabel leszármazott, külső képfájlt tölt be ( bat.jpg),
egyedi azonosítója van,
eldönti mozgásának irányát (4) és léptékét (3), mintha ultrahangot adna,
a szerver megadja neki, hogy az új helyre elmozdulhat-e,
saját magát képes mozgatni.

Pozíció interfész:

öröklődik a java.rmi.Remote interfészből,
két távolról hívható metódus fejét tartalmazza.

BarlangSzerver osztály:

megvalósítja az RMI szerver funkciót,
implementálja a Pozíció interfészt,
JFrame leszármazott,
figyel arra, hogy a denevérek ne mozogjanak ki a barlangból.

BarlangFelület osztály:

JFrame leszármazott,
GUI az RMI kliensek megjelenítéséhez.

BarlangSzerverTérkép osztály:

JPanel leszármazott,
GUI a szerveren a kliensek mozgásának követésére.

Ha futtatjuk az elkészült szerver és kliens programot, akkor ezt láthatjuk:

A fejlesztés és tesztelés közben sok-sok továbbfejlesztési ötletet/javaslatot fogalmaztunk meg:

háttérkép a barlangról,
a háttérkép megvalósíthat labirintust, koordináta-rendszert,
átlátszó illetve egyedi képfájlok a denevéreknek,
a denevérek mozgásának tetszőleges iránya (360°),
a denevérek mozgásának egyedi léptéke,
a denevérek figyeljenek egymásra (ne ütközzenek össze),
a denevérek figyeljenek a környezetükre (ne ütközzenek bele sziklákba, cseppkövekbe),
a szerver követheti a denevérek útvonalát,
a szerver archiválhat, szerializálhat, készíthet statisztikát.

A bejegyzéshez tartozó – több lépésben továbbfejlesztett – forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java EE szoftverfejlesztő tanfolyam 21-24. óra: RMI alapú kommunikáció alkalmához kapcsolódik.

Ismerkedjünk lambda kifejezésekkel!

2023. augusztus 4.2017. július 22. Szerző: Kaczur Sándor

A Java 8-tól használhatunk lambda kifejezéseket, amivel hatékonyabban, rövidebben és könnyebben valósíthatunk meg tipikus műveleteket.

Korábban általában az eseménykezelést globálisan (interfészek implementálásával), vagy lokálisan (névtelen interfész implementálásával) oldottuk meg, illetve besegítettek adapterek is. Sok- és többféle eseménynél ez a forráskódunk elaprózódásához vezetett, ami nehézkes olvashatóságot és karbantarthatóságot eredményezett.

A lambda kifejezés egy olyan kódrészlet, amelyben valamihez hozzárendelünk valamit, például egy metódus paraméteréhez a végrehajtandó forráskódot ( x -> y). Ehhez építünk a funkcionális interfészekre és a metódus referenciákra (szintén Java 8-tól), illetve a típus kikövetkeztetés képességére is (Java 7-től).

A kiválogatás programozási tételt valósítjuk meg többféle implementációval, felhasználva a Java nyelv újdonságait, és a fentieken kívül még a Stream API-t is.

Adatforrás

Először is kellenek adatok, hiszen azokat dolgozzuk fel. Egy Termek osztályú egyszerű POJO-val dolgozunk, nev és ar tulajdonságokkal, generált konstruktorral, getter metódusokkal és toString()-gel. Az adatforrást biztosító absztrakt Lista ősosztályban a POJO-kból felépítünk egy termekLista nevű generikus listát (például CSV vagy XML fájlból beolvasva az összetartozó adatokat) – listaFeltolt() eljárás – és implementálunk egy univerzálisan használható listaKiir(String uzenet, List termekLista) eljárást is.

abstract class Lista {

private File xmlFajl=new File("./files/prod.xml");

private File csvFajl=new File("./files/prod.csv");

protected ArrayList termekLista=null;

public Lista() {

listaFeltolt();

listaKiir("Összes termék listája", termekLista);

}

private void listaFeltolt() {

…

}

public void listaKiir(String uzenet, List termekLista) {

System.out.print(uzenet+" - ");

if(termekLista.isEmpty()) {

System.out.println("Nincs ilyen termék.\n");

return;

}

System.out.println(termekLista.size()+" db:");

termekLista.forEach(termek -> System.out.println(termek));

System.out.println();

}

Örökítünk három utódosztályt a Lista osztályból, amelyek különbözőképpen dolgozzák fel a termekLista-t, bemutatva a fejlődés útját, illetve a rendelkezésre álló lehetőségeket.

Válogassunk a termékek közül négyféleképpen és adjuk vissza azon termékeket, amelyek:

limit alatti áron kaphatók,
ára limit1 és limit2 közé esik (zárt intervallumban),
neve adott szöveggel kezdődik (kis- és nagybetű különbözik),
neve adott szöveget tartalmaz (kis- és nagybetű nem különbözik)!

1. változat

Hagyományos megközelítéssel a fentiek megvalósításához külön egy-egy függvény tartozik, ahogyan az alábbiakban látható:

class Kivalogatas1 extends Lista {

private List termekListaLimitAr1(int limit) {

//limit ár alatti termékek listája

List lista=new ArrayList<>();

// for (int i = 0; i < termekLista.size(); i++) //1

// if(termekLista.get(i).getAr()<limit)

// lista.add(lista.get(i));

//// Iterator i=termekLista.iterator(); //2

//// while(i.hasNext()) {

//// Termek termek=i.next();

//// if(termek.getAr()<limit)

//// lista.add(termek);

//// }

////// for (Termek termek : termekLista) //3

////// if(termek.getAr()<limit) ////// lista.add(termek); //////// termekLista.stream(). //4 //////// filter(termek -> termek.getAr()<limit). //////// forEach(termek -> lista.add(termek));

lista=termekLista.stream(). //5

filter(termek -> termek.getAr()<limit).

collect(Collectors.toList());

return lista;

}

private List termekListaLimitAr2(int limit1, int limit2) {

//limit1<=ár<=limit2 termékek listája

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> limit1<=termek.getAr() &&

termek.getAr()<=limit2). forEach(termek -> lista.add(termek));

return lista;

}

private List termekListaSzoveg1(String szoveg) {

//szoveg-gel kezdődő terméknevek listája (kis- és nagybetű különbözik)

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> termek.getNev().startsWith(szoveg)).

forEach(termek -> lista.add(termek));

return lista;

}

private List termekListaSzoveg2(String szoveg) {

//szoveg-et tartalmazó terméknevek listája (kis- és nagybetű nem különbözik)

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> termek.getNev().toLowerCase().

contains(szoveg.toLowerCase())).

forEach(termek -> lista.add(termek));

return lista;

}

public void run() {

listaKiir("Terméklista - ár<10", termekListaLimitAr1(10));

listaKiir("Terméklista - 10<=ár<=20", termekListaLimitAr2(10, 20));

listaKiir("Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik)",

termekListaSzoveg1("Sir"));

listaKiir("Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik)",

termekListaSzoveg2("hot"));

}

A termekListaLimitAr1() függvényben látható ötféle lehetőség a kiválogatásra a termekLista-ból:

//1: hagyományos, index alapú változat,
//2: iterátorra közvetlenül építő változat,
//3: bejáró ciklus, iterátorra közvetve építő változat,
//4: Stream API-ra építő változat, kiválogatás lambda-kifejezéssel ( filter), a megmaradó termékekre végrehajtandó forEach művelet lambda kifejezéssel,
//5: Stream API-ra építő változat, kiválogatás lambda-kifejezéssel ( filter), a megmaradó termékeket összegyűjtő/leképező collect művelettel.

Jól megfigyelhető, hogy négy függvény vázszerkezete megegyezik, és csupán a filter-ben található lambda-kifejezések különböznek. Ez a megoldás meglehetősen redundáns, nem általánosítható, valamint további műveletek megvalósítása további függvények implementálását igényli.

2. változat

Őrizzük meg a négyféle funkciót, sőt tegyük lehetővé, hogy ez tetszőlegesen bővíthető legyen. Használjunk saját generikus, funkcionális Feltetel interfészt saját döntés megvalósítását biztosítani tudó implementálandó teszt() függvénnyel, az alábbiak szerint:

class Kivalogatas2 extends Lista {

private List termekListaFeltetel(Feltetel feltetel) {

//feltetel-t teljesítő termékek listája

List lista=new ArrayList<>();

// for (Termek termek : termekLista)

// if(feltetel.teszt(termek))

// lista.add(termek);

termekLista.stream().

filter(termek -> feltetel.teszt(termek)).

forEach(termek -> lista.add(termek));

return lista;

}

public void run() {

listaKiir("Terméklista - ár<10",

termekListaFeltetel(new Feltetel() {

@Override

public boolean teszt(Termek t) {

return t.getAr()<10;

}

}));

// listaKiir("Terméklista - ár<10", termekListaFeltetel((Termek termek) -> termek.getAr()<10));

listaKiir("Terméklista - 10<=ár<=20",

termekListaFeltetel((Termek termek) ->

10<=termek.getAr() && termek.getAr()<=20));

listaKiir("Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik)",

termekListaFeltetel((Termek termek) ->

termek.getNev().startsWith("Sir")));

listaKiir("Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik)",

termekListaFeltetel((Termek termek) ->

termek.getNev().toLowerCase().contains("hot".toLowerCase())));

}

A termekListaFeltetel() függvény paramétere a saját Feltetel interfészünket implementáló névtelen osztály példánya, amely felhasználható:

//6: ciklusban egyszerű feltételként,
//7: Stream API filter műveletében megadott lambda-kifejezésben,
//8: a listaKiir() metódusban paraméterként átadva névtelen osztály példányaként,
//9-től: a listaKiir() metódusban paraméterként átadva lambda-kifejezésként.

Látszik, hogy többféle kiválogató művelethez egyetlen implementált függvény szükséges. Ez a megoldás már jóval általánosabb.

3. változat

A saját interfész helyett használjuk fel a beépített Predicate generikus, funkcionális interfészt, építve annak test() függvényére az alábbiak szerint:

class Kivalogatas3 extends Lista {

private List termekListaFeltetel(Predicate feltetel) {

//feltetel-t teljesítő termékek listája

List lista=new ArrayList<>();

termekLista.stream().

filter(termek -> feltetel.test(termek)).

forEach(termek -> lista.add(termek));

return lista;

}

public void run() {

listaKiir("Terméklista - ár<10",

termekListaFeltetel(new Predicate() {

@Override

public boolean test(Termek t) {

return t.getAr()<10;

}

}));

listaKiir("Terméklista - ár<10",

termekListaFeltetel( (Termek termek) -> termek.getAr()<10));

listaKiir("Terméklista - 10<=ár<=20",

termekListaFeltetel((Termek termek) ->

10<=termek.getAr() && termek.getAr()<=20));

listaKiir("Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik)",

termekListaFeltetel( (Termek termek) ->

termek.getNev().startsWith("Sir")));

listaKiir("Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik)",

termekListaFeltetel((Termek termek) ->

termek.getNev().toLowerCase().contains("hot".toLowerCase())));

}

Belépési pont

Végül következzen a közös belépési pont, amelyben tetszőlegesen aktiválható és tesztelhető mindhárom változat működése:

public class Kivalogatas {

public static void main(String[] args) {

//new Kivalogatas1().run();

//new Kivalogatas2().run();

new Kivalogatas3().run();

}

Mit ír ki a program a konzolra?

Összes termék listája - 77 db:

Chai, 18.0

Chang, 19.0

Aniseed Syrup, 10.0

---

Rhönbräu Klosterbier, 7.75

Lakkalikööri, 18.0

Original Frankfurter grüne Soße, 13.0

Terméklista - ár<10 - 11 db:

Konbu, 6.0

Teatime Chocolate Biscuits, 9.2

Tunnbröd, 9.0

Guaraná Fantástica, 4.5

Geitost, 2.5

Jack's New England Clam Chowder, 9.65

Rogede sild, 9.5

Zaanse koeken, 9.5

Filo Mix, 7.0

Tourtiere, 7.45

Rhönbräu Klosterbier, 7.75

Terméklista - ár<10 - 11 db:

Konbu, 6.0

Teatime Chocolate Biscuits, 9.2

Tunnbröd, 9.0

Guaraná Fantástica, 4.5

Geitost, 2.5

Jack's New England Clam Chowder, 9.65

Rogede sild, 9.5

Zaanse koeken, 9.5

Filo Mix, 7.0

Tourtiere, 7.45

Rhönbräu Klosterbier, 7.75

Terméklista - 10<=ár<=20 - 29 db:

Chai, 18.0

Chang, 19.0

Aniseed Syrup, 10.0

Genen Shouyu, 15.5

Pavlova, 17.45

Sir Rodney's Scones, 10.0

NuNuCa Nuß-Nougat-Creme, 14.0

Gorgonzola Telino, 12.5

Sasquatch Ale, 14.0

Steeleye Stout, 18.0

Inlagd Sill, 19.0

Chartreuse verte, 18.0

Boston Crab Meat, 18.4

Singaporean Hokkien Fried Mee, 14.0

Gula Malacca, 19.45

Spegesild, 12.0

Chocolade, 12.75

Maxilaku, 20.0

Valkoinen suklaa, 16.25

Ravioli Angelo, 19.5

Escargots de Bourgogne, 13.25

Louisiana Hot Spiced Okra, 17.0

Laughing Lumberjack Lager, 14.0

Scottish Longbreads, 12.5

Outback Lager, 15.0

Röd Kaviar, 15.0

Longlife Tofu, 10.0

Lakkalikööri, 18.0

Original Frankfurter grüne Soße, 13.0

Terméklista - 'Sir'-rel kezdődő terméknevek (kis- és nagybetű különbözik) - 3 db:

Sir Rodney's Marmalade, 81.0

Sir Rodney's Scones, 10.0

Sirop d'érable, 28.5

Terméklista - 'hot'-ot tartalmazó terméknevek (kis- és nagybetű nem különbözik) - 2 db:

Louisiana Fiery Hot Pepper Sauce, 21.05

Louisiana Hot Spiced Okra, 17.0

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás 2. rész, 25-28. óra: Objektumorientált programozás 3. rész, valamint a Java EE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: XML feldolgozás alkalmaihoz kötődik.

Máskor is blogolunk a témakörben: Stream API lambda kifejezésekkel.