Kaczur Sándor informatikus mérnök, matematika-informatika-közgazdásztanár, az it-tanfolyam.hu alapítója és oktatói csapatának szakmai vezetője. Részletes bemutatkozása az Oktatók lapon található. 2017 óta blogol velünk.
Az it-tanfolyam.hu szakmai blogjába 111 bejegyzést írt:
Dr. Sheldon Cooper karakterét nem kell bemutatni. Ha a kockáknak döntéseket kell hozniuk, akkor az Agymenők (The Big Bang Theory) sorozatban többször is előkerül a kő-papír-olló-gyík-Spock játék.
A 2. évad 8. epizódjában – amelynek címe Fogd a nőt, és fuss! (The Lizard–Spock Expansion) – ismerjük meg a játékszabályt és rögtön alkalmazásra is kerül. Raj és Sheldon megpróbálja eldönteni, hogy melyik sci-fi sorozat a (leg)jobb, illetve Howard és Sheldon így próbálnak osztozni a vacsora maradékán. Végül az 5. évad 17. epizódjában – amelynek címe Itt a festmény, hol a festmény! (The Rothman Disintegration) – újra hallhatjuk a játékszabályt. Ekkor Kripke és Sheldon egy egyetemi iroda sorsáról (kié legyen) próbál dönteni.
Vajon hogyan bővül ki a klasszikus kő-papír-olló játékszabálya további két kézjel/fegyver hozzáadásával? Íme a játékszabály videóban:
Az olló elvágja a papírt,
a papír bevonja a követ,
a kő agyonüti a gyíkot,
a gyík megmarja Spockot,
Spock eltöri az ollót,
az olló lefejezi a gyíkot,
a gyík megeszi a papírt,
a papír cáfolja Spockot,
Spock feloldja a követ,
a kő eltöri az ollót.
Ugye mi sem egyszerűbb? 🙂
A játékszabálynak számos grafikus ábrázolása is van. Ezeken többnyire irányított gráf csomópontjai mutatják a kézjeleket és a nyilak iránya mutatja, hogy mi mit győz le. Például a gyíktól Spock felé mutató jelzi, hogy a gyík megmarja (azaz legyőzi) Spock-ot. Íme az egyik ábra:
Az objektumorientált tervezés egyik lehetősége az öröklődés beépítése. Közös pontokat, funkcionalitást keresünk. Ezeket beépítjük az ősosztályba és az utódokban kiegészítjük, testre szabjuk. Kiindulunk az alábbi absztrakt Dontes ősosztályból:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
abstract class Dontes { private static final String[] DONTES={ "kő", "papír", "olló", "gyík", "Spock"}; //-1: döntetlen // 0 1 2 3 4 protected static int veletlenDontes() { return (int)(Math.random()*5); //0-4 } private String dontesEredmeny(int d) { return d==-1 ? "döntetlen" : DONTES[d]+ " nyert"; } protected String kiiras(int d1, int d2) { if(d1<-1 || d1>=DONTES.length || d2<-1 || d2>=DONTES.length) throw new IllegalArgumentException("Hiba! Érvénytelen döntés."); return DONTES[d1]+" és "+ DONTES[d2]+": "+ dontesEredmeny(eredmeny(d1, d2)); }; protected int eredmeny(int d1, int d2, int d3) { return eredmeny(d1, eredmeny(d2, d3)); } public abstract int eredmeny(int dontes1, int dontes2); } |
A konstans DONTES tömb (indexelhető adatszerkezet) tárolja a kézjelek/fegyverek elnevezését. Ezek közül választ véletlenszerűen a veletlenDontes() függvény. Az eredményt ki kell tudni írni a konzolra, illetve kezelni kell a döntetlent is. Ezekért közösen felelnek a dontesEredmeny() és a kiiras() függvények. A túlterhelt metódusokként létrehozott eredmeny() függvények kezelik a 2 illetve 3 játékos esetén a döntéseket. A háromparaméteres függvény visszavezet a kétparaméteres esetre. Utóbbi metódus – mivel absztrakt – csak az utódosztályban valósul meg. Így lehetővé válik a játékszabály többféle megvalósítása.
Az első megoldás során adatszerkezet nélkül valósul meg a játékszabály a KoPapirOlloGyikSpockV1 utódosztályban:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class KoPapirOlloGyikSpockV1 extends Dontes { @Override public int eredmeny(int d1, int d2) { if(d1==d2) //döntetlen return -1; return (d1==2 && d2==1) || //Az olló elvágja a papírt, (d1==1 && d2==0) || //a papír bevonja a követ, (d1==0 && d2==3) || //a kő agyonüti a gyíkot, (d1==3 && d2==4) || //a gyík megmarja Spockot, (d1==4 && d2==2) || //Spock eltöri az ollót, (d1==2 && d2==3) || //az olló lefejezi a gyíkot, (d1==3 && d2==1) || //a gyík megeszi a papírt, (d1==1 && d2==4) || //a papír cáfolja Spockot, (d1==4 && d2==0) || //Spock feloldja a követ, (d1==0 && d2==2) ? //a kő eltöri az ollót. d1 : d2; } } |
A második megoldás során a játékszabályt konstansként deklarált MATRIX szomszédsági -, csúcsmátrix, kétdimenziós tömb adatszerkezet tárolja. Ez alapján döntést tud hozni a KoPapirOlloGyikSpockV2 utódosztály.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
class KoPapirOlloGyikSpockV2 extends Dontes { private static final int[][] MATRIX={ // kő papír olló gyík Spock /*kő*/ {0, 0, 1, 1, 0}, //A kő eltöri az ollót, a kő agyonüti a gyíkot, /*papír*/ {1, 0, 0, 0, 1}, //a papír bevonja a követ, a papír cáfolja Spockot, /*olló*/ {0, 1, 0, 1, 0}, //az olló elvágja a papírt, az olló lefejezi a gyíkot, /*gyík*/ {0, 1, 0, 0, 1}, //a gyík megeszi a papírt, a gyík megmarja Spockot, /*Spock*/ {1, 0, 1, 0, 0} //Spock feloldja a követ, Spock eltöri az ollót. }; @Override public int eredmeny(int d1, int d2) { if(d1==d2) //döntetlen return -1; return MATRIX[d1][d2]==1 ? d1 : d2; } } |
10 lépésből álló játékmenetet hoz létre az alábbi vezérlés:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class KoPapirOlloGyikSpock { public static void main(String[] args) { KoPapirOlloGyikSpockV1 jatekV1=new KoPapirOlloGyikSpockV1(); KoPapirOlloGyikSpockV2 jatekV2=new KoPapirOlloGyikSpockV2(); for(int i=1; i<=10; i++) { int d1=Dontes.veletlenDontes(); int d2=Dontes.veletlenDontes(); System.out.println(jatekV1.kiiras(d1, d2)); System.out.println(jatekV2.kiiras(d1, d2)); System.out.println(); } } } |
Egyben tesztelés is: igazolja, hogy azonosan működik a két különböző megoldás.
Mivel minden véletlenszerűen alakul a játékban, ezért az alábbi csupán egy a sokféle lehetséges kimenet közül:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
papír és gyík: gyík nyert papír és gyík: gyík nyert kő és kő: döntetlen kő és kő: döntetlen kő és papír: papír nyert kő és papír: papír nyert Spock és papír: papír nyert Spock és papír: papír nyert olló és Spock: Spock nyert olló és Spock: Spock nyert kő és Spock: Spock nyert kő és Spock: Spock nyert papír és papír: döntetlen papír és papír: döntetlen gyík és Spock: gyík nyert gyík és Spock: gyík nyert gyík és kő: kő nyert gyík és kő: kő nyert gyík és kő: kő nyert gyík és kő: kő nyert |
A bejegyzéshez tartozó teljes forráskódot – többféle változatban is – 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 5-8. óra: Vezérlő szerkezetek, 9-12. óra: Metódusok, rekurzió, 13-16- óra: Tömbök, illetve a 17-24. óra: Objektumorientált programozás 1. és 2. rész alkalmaihoz kötődik.
A PDF népszerű fájlformátum. Az Adobe cég 30+ éves szabványa. Hordozható: azaz minden eszközön, platformon ugyanúgy jelenik meg. Számos nézegető program támogatja, köztük böngészőprogramok is. A PDF rövidítés a Portable Document Format betűszava. Többnyire kimeneti formátumnak tekinthető. Az évek során folyamatosan fejlődött: ma már űrlapokat is tartalmazhat, elektronikusan aláírható, hitelesíthető, és hivatalos ügyek során is használják.
PDF fájl többféleképpen is készíthető. Például:
Utóbbi esetekre néhány példa:
Adatokra van szükség. Korábbi Munkakör, létszám, névsor lekérdezése blog bejegyzésünkben az Oracle HR sémából kétféleképpen is lekérdeztük a szükséges adatokat. Ezt érdemes előzetesen tanulmányozni, hogy a további tartalom könnyebben érthető legyen. A Java SE szoftverfejlesztő tanfolyam megközelítése alapján, az egyszerűbb SQL paranccsal előállított eredménytáblát a PDF generálása előtt még csoportosítani kell (munkakörönként). A Java adatbázis-kezelő tanfolyam megközelítése alapján, az összetettebb SQL paranccsal elkészített, denormalizált eredménytábla közvetlenül felhasználható.
A cél egy táblázat elkészítése, amely 3 oszlopból áll: munkakör, létszám és névsor. Az azonos munkakörű alkalmazottak névsora egy táblázat egyetlen cellájában legyen megjeleníthető. Az elkészült táblázatból készüljön PDF fájl.
Szükséges az iText csomag importálása: com.itextpdf.text. Korábbi változata az 5-ös, aktuális változata a 8-as. Előbbi nagyon elterjedt, utóbbi még kevésbé ismert. A továbbiakban a kötelező kivételkezeléshez kötődő forráskód-részletek bemutatásától eltekintünk.
Tehát adott az összes szükséges adat egy ArrayList<MunkakorLetszamNevsor> lista generikus listában. A POJO mindhárom szükséges és összetartozó tulajdonságot tárolja: String munkakor, int letszam, String nevsor.
Hasznos egy általánosan használható cella() függvény elkészítése, amely képes adott szöveget, adott betűmérettel, adott betűstílussal, adott igazítással „megjeleníteni”:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
private PdfPCell cella(String szoveg, int betumeret, boolean felkover, int igazitas) throws DocumentException, IOException { PdfPCell cella=new PdfPCell(); BaseFont betutipus=BaseFont.createFont( BaseFont.HELVETICA, BaseFont.CP1250, BaseFont.EMBEDDED); Paragraph bekezdes=new Paragraph(szoveg, new Font(betutipus, betumeret, felkover?Font.BOLD:Font.NORMAL)); bekezdes.setAlignment(igazitas); cella.addElement(bekezdes); cella.setPadding(2); cella.setVerticalAlignment(Paragraph.ALIGN_CENTER); return cella; } |
Létre kell hozni a pdfFajl objektumot, beállítani a méretét és a margókat, illetve fájlba kell irányítani:
|
1 2 3 4 |
Document pdfFajl=new Document(PageSize.A4, 15, 15, 30, 20); PdfWriter.getInstance(pdfFajl, new FileOutputStream("./files/jelentes.pdf")); pdfFajl.open(); |
Létre kell hozni a táblázat előtt megjelenő szöveget (ez nem a szövegszerkesztés szerinti valódi fejléc):
|
1 2 3 4 5 6 |
BaseFont betutípus=BaseFont.createFont( BaseFont.HELVETICA, BaseFont.CP1250, BaseFont.EMBEDDED); Paragraph fejlec= new Paragraph("Jelentés", new Font(betutípus, 20, Font.BOLD)); fejlec.setAlignment(Paragraph.ALIGN_CENTER); pdfFajl.add(fejlec); |
Létre kell hozni a táblázatot, megfelelő beállításokkal:
|
1 2 3 4 |
PdfPTable tablazat=new PdfPTable(3); tablazat.setWidthPercentage(85); tablazat.setSpacingBefore(40); tablazat.setWidths(new float[] {0.2f, 0.1f, 0.7f}); |
Létre kell hozni a táblázat fejlécét:
|
1 2 3 4 5 6 |
tablazat.addCell( cella("Munkakör", 14, true, Paragraph.ALIGN_CENTER)); tablazat.addCell( cella("Lét-\nszám", 14, true, Paragraph.ALIGN_CENTER)); tablazat.addCell( cella("Névsor", 14, true, Paragraph.ALIGN_CENTER)); |
Végig kell haladni az adatokon és elő kell állítani a szükséges táblázatcellákat, végül le kell zárni a fájlt:
|
1 2 3 4 5 6 7 8 9 10 |
for(MunkakorLetszamNevsor mln: lista) { tablazat.addCell( cella(mln.getMunkakor(), 12, false, Paragraph.ALIGN_LEFT)); tablazat.addCell( cella(""+mln.getLetszam(), 12, false, Paragraph.ALIGN_CENTER)); tablazat.addCell( cella(mln.getNevsor(), 12, false, Paragraph.ALIGN_LEFT)); } pdfFajl.add(tablazat); pdfFajl.close(); |
A PDF fájl és a belekerülő táblázatobjektum szerkezete DOM-szerű, illetve azonos a grafikus felhasználói felület felépítése során használt AWT/swing konténerszemlélettel.
A felhasznált programozási tételek: sorozatszámítás, kiválasztás, megszámolás, kiválogatás, illetve kombináltan: csoportosítás, rendezés.
Az elkészült PDF fájl másfél oldalas, itt letölthető, megtekinthető. A dokumentumról készült képernyőkép:
Igényeinktől függően, illetve előzetes tapasztalatainkra és a meglévő tudásunkra építve számos ötlet merülhet fel. Mindhárom tanfolyam esetén testre tudjuk szabni azt az SQL parancsot, ami a szükséges adatokat lekérdezi. Az iText csomag helyett felfedezhetjük a PDF Clown, a PDFBox, illetve a Spire.PDF csomagok funkcionalitását 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 nemzetközi Pi nap alkalmából (március 14) Java programmal grafikusan ábrázoljuk a π számjegyeit. Kiindulunk egy négyzet alakú grafikus felület középpontjából. Ezt tekintjük origónak. Sorra vesszük a π első néhány számjegyét: 100, 1000, 10000 paraméterezhető módon. Minden számjegyet egy rövid szakasszal ábrázolunk. A szakaszok egymást követik. Az előző végpontja megegyezik a következő kezdőpontjával. A rajzolás elejét és végét kör jelzi.
Az alábbi szabály alapján döntjük el, hogy a π előforduló számjegyei esetén melyik irányba és milyen színnel rajzolunk szakaszt:
A π első 100000 db számjegyét tároljuk egy szövegfájlban. Ömlesztve, sortörés, tizedesvessző nélkül. Így a π első 30 számjegye: 314159265358979323846264338327. A szövegfájl helyét a String PI_FILE konstans jegyzi meg. A paraméternek megfelelően ebből vesszük az első N db számjegyet. Ezt a Java program beolvassa egy String típusú pi szövegobjektumba. A számjegyek összetartozó adatait egy Digit osztály rendeli egymáshoz. Ennek három adattagja van: melyik számjegy: int digit, melyik irányba kell szakaszt rajzolni java.awt.Point direction, milyen színnel kell szakaszt rajzolni java.awt.Color color. A tízféle színt egy konstans tömb tárolja: Color[] COLORS.
A π tízféle számjegyéből az alábbi forráskód-részlettel létrejön egy tömb adatszerkezet: Digit[] digits. A koordináták/vektorok kiszámítása követi az analóg óra számlapjának 36 fokonként való felosztását.
|
1 2 3 4 5 6 7 |
for(int i=0; i<10; i++) { Point p=new Point( (int)(Math.cos(Math.toRadians(i*36-90))*LINE_LENGTH), (int)(-Math.sin(Math.toRadians(i*36-90))*LINE_LENGTH) ); digits[i]=new Digit(i, p, COLORS[i]); } |
A rajzoláshoz szükséges még néhány konstans: milyen vastag vonalat kell rajzolni: double PEN_RADIUS, mekkora átmérőjű kör jelzi a rajzolás kezdő- és végpontját: double POINT_RADIUS, milyen hosszú vonalat kell rajzolni: int LINE_LENGTH, a rajzterületet mekkorára kell méretezni/skálázni: int SCALE.
Mindezek alapján az alábbi forráskód-részlet vizualizálja a π számjegyeit:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
private void piDraw() { StdDraw.setScale(-SCALE, SCALE); StdDraw.setPenRadius(PEN_RADIUS); Point p1=new Point(0, 0); StdDraw.setPenColor(digits[3-1].getColor()); StdDraw.circle(p1.x, p1.y, POINT_RADIUS); for(int i=0; i<PI.length(); i++) { int digit=Integer.parseInt(""+PI.charAt(i)); Point p2=new Point( p1.x+digits[digit].getDirection().x, p1.y+digits[digit].getDirection().y); StdDraw.setPenColor(digits[digit].getColor()); StdDraw.line(p1.x, p1.y, p2.x, p2.y); p1=p2; } StdDraw.circle(p1.x, p1.y, POINT_RADIUS); } |
Eredményül ezek az ábrák készíthetők el:
A rajzoláshoz felhasználtuk az StdDraw osztályt, amely ennek a tankönyvnek a példatárából származik: Robert Sedgewick, Kevin Wayne: Computer Science: An Interdisciplinary Approach, 1st edition, Princeton University, Addison-Wesley Professional, 2016, ISBN 978-0134076423. Az osztály metódusaival könnyen beállítható a nézőpont, a vízszintes/függőleges skála, a rajzoláshoz használt toll mérete/színe és a grafikai primitívek közül csak a kör és szakasz ábrázolása szükséges.
Korábban is megemlékeztünk néhány közelítő algoritmus – Viète-féle sor, Leibniz-féle sor, Wallis-formula, Csebisev-sor – implementálásával erről az ünnepnapról: Nemzetközi Pi nap. Ajánljuk korábbi blog bejegyzéseinket rajzolás, animáció, grafika címkékkel, illetve ASCII művészet Java-ban.
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 5-8. óra: Vezérlési szerkezetek, 13-16. óra: Tömbök, 17-28. óra: Objektumorientált programozás, 29-36. óra: Grafikus felhasználói felület, 37-44. óra: Fájlkezelés alkalmaihoz kötődik.
Az USA-ban és még néhány országban február 9-én ünneplik a nemzeti pizza napot. Ehhez kötődően kreatív ötletekkel és persze finom pizzákkal vonzzák az éttermek a vendégeket.
Kreatív ötletekkel a mi oktatói csapatunk is rendelkezik. A nemzeti pizza nap inspirált bennünket az alábbi feladat megoldására.
Az igazságost úgy értelmezzük, hogy mindenkinek ugyanannyi (ugyanakkora szelet) pizza jut. Két megoldást mutatunk be grafikusan. Ötleteket adunk ahhoz, hogyan programozható le mindez Java nyelven: swing grafikus felületen, grafikai primitívekkel vagy ismert algoritmusokkal. Ábrákkal mutatjuk be a megoldásokat, színekkel kiemelve az azonos/különböző méretű pizzaszeleteket.
Mind a 9 db pizzából vágjunk ki egytized méretű szeletet. Marad 9 db kilenctized méretű pizzaszelet és a 9 db egytizedből összeállítható a 10. főnek járó szintén kilenctized méretű pizzaszelet/adag.
A 9 db pizzából 5 db pizzát vágjunk ketté. Keletkezik 10 db fél pizza. A maradék 4 db pizzát harmadoljunk fel. Keletkezik 12 db egyharmad pizza. A keletkező 2 db egyharmad pizzát osszuk fel 5-5 részre. Keletkezik 10 db egytizenötöd méretű pizzaszelet. Az egyharmad ötödrésze adja az egytizenötöd részt. A 10 főnek járó adaghoz rakjuk össze a 30 db részből a különbözőket: egy adag kilenctized, ami egy fél és egy harmad és egy tizenötöd részből áll össze. Másképpen: 9/10 = 27/30 = 15/30 + 10/30 + 2/30.
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 matematikai háttértől eltekintve – a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás 2. rész, valamint a 29-36. Grafikus felhasználói felület alkalmaihoz kötődik.
Időnként készítünk oktatóprogramokat is tanfolyamainkon. Most az volt a cél, hogy kódolás/dekódolás szakterület egyik ismert betűkeveréses algoritmusának működését mutassa be lépésről-lépésre az oktatóprogram. A rácsrejtjelezést választottuk.
Az elkészült program Java swing-es felületű és Windows Classic look-and-feel bőrrel így néz ki működés közben:
A rácsrejtjelezés a képernyőképen látható 4×4-es Kódrács használatán alapul.
A titkosítandó szöveget karakterenként beleírjuk az aktuális kódrácsba soronként lefelé, azon belül balról jobbra haladva. Ha a négy pozíció betelt, akkor el kell fordítani a kódrácsot az óramutató járásával megegyező irányban 90 fokkal. Ha a szöveg hosszabb 16 karakternél, akkor elölről kell kezdeni. Ha készen vagyunk, akkor soronként haladva leírjuk egymás után a kódrácsban található karaktereket.
A megfejtéshez ismernünk kell a titkosított karaktersorozaton kívül a felhasznált kódrácsot is. A karaktersorozatot soronként lefelé haladva beírjuk a kódrácsba, az ismert kódrácsot ráhelyezve soronként lefelé, azon belül balról jobbra haladva kiolvashatjuk a megfejtést. Természetesen a kódrácsot most is forgatni kell minden negyedik karakter után.
Megfigyelhető, hogy bármely karaktert tudunk titkosítani és megfejteni. Ezért a rácsrejtjelezés ebből a szempontból univerzális módszer.
A kódrács ismerete nélkül a titkosított szöveg nem fejthető meg, tartalmára csak nehézkes következtetést adhatunk. Például, ha tudjuk, hogy milyen nyelvű a titkosított szöveg, akkor támpontot adhat a megfejtéséhez a nyelv ábécéjében előforduló betűk ismert gyakorisága.
A képernyőkép éppen a megfejtés egyik pillanatában készült. A feladó továbbította a titkosított szöveget és a kódrácsot a címzettnek, aki elkezdte annak megfejtését. A negyedik karakter a b volt, utoljára erre kattintott a (4;4) pozícióban. Ezt követte egy rácsforgatás, amelyhez tartozik egy ablak, amely megjeleníti a „Rácsforgatás következik.” szöveget. Ezután a kódrács elfordult, és a következő cella a második sor első cellája lesz. Ha hibás cellára, pozícióra kattintunk, akkor a következő hibaüzeneteket kaphatjuk: „Hibáztál! Folytathatod a titkosítást.” vagy „Hibáztál! Folytathatod a megfejtést.” Ha befejeztük a titkosítást, vagy a megfejtést, akkor a következő üzeneteket kaphatjuk: „A kódolás sikerült.” vagy „A megfejtés sikerült.”
A program tartalmaz egy gyakorlást támogatandó szövegkészletet. Ennek minden eleme 16 hosszúságú, az egyszerűség kedvéért – így nem kell véletlenszerű karakterekkel feltölteni a rács kimaradt celláit, illetve nem kell 16-os csoportokkal foglalkozni.
A Titkosítás és megfejtés fülön látható egy véletlenszerűen kiválasztott szöveg, amelyet karakterenként kódolni lehet a kódrács megfelelő cellájára kattintva. Ha kész, a Továbbítás gombbal a feladó elküldi a címzettnek a titkosított karaktersorozatot, aki hasonlóan megfejti. „Útközben” megfigyelhető, hogy éppen hányadik elforgatásnál tartunk és természetesen megjelenik az aktuális ráccsal titkosított szöveg is.
Az űrlapon lévő Kódrács csoportablak az aktuálisan, véletlenszerűen legenerált kódrácson kívül a kiválasztott cellák pozícióit is tartalmazza. Az (1;1) pozícióban a bal felső cella található. A kódrács a Másik nyomógombbal véletlenszerűen újragenerálható. Ennek megvalósításakor több probléma, ötlet is felmerülhet. Például használható visszalépéses keresés algoritmus.
Most nem specifikáljuk részletesebben, például objektumorientált tervezés, eseménykezelés, háttérbeli objektumok vagy GUI komponensek működésének/vezérlésének szintjén. Aki kedvet kapott és úgy érzi, hogy meg tudja ugrani ezt a kihívást, akkor bátran elkészítheti. Hajrá! Mivel oktatóprogram, szükséges hozzá Leírás és Teszt 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 oktatóprogramot tervezni, kódolni, tesztelni.
