2017. szeptember 28., csütörtök

Számítógép-szerelő, karbantartó képzés SZAKMAI KÖVETELMÉNYEK

Tematika - oktatott modulok
1142-06 - Számítógépkezelés, szoftverhasználat, munkaszervezés
Feladatprofil:
o Hardvert üzemeltet, szoftvert telepít o Irodai programcsomagot egyedi és integrált módon használ o Multimédiás- és kommunikációs alkalmazásokat kezel o Adatmentést végez, informatikai biztonsági eszközöket használ o LAN- és WAN-hálózatokat használ o Informatikai angol nyelvű szakmai szöveget megért o Tevékenységét dokumentálj a o Szoftverhasználati j ogokat alkalmaz o Tervezi és szervezi a munkavégzést o Betartja a munkavégzéssel összefüggő szabályokat o Alkalmazza a munkahelyi minőségbiztosítási előírásokat
Tulajdonságprofil:
Szakmai kompetenciák:
A típus megjelölésével a szakmai ismeretek:
B Minőségbiztosítással kapcsolatos alapfogalmak B Munka-, környezet- és tűzvédelem A Elektromos áram élettani hatásai, elsősegélynyújtás B Erőforrások tervezése C Műszaki dokumentációk
A szint megjelölésével a szakmai készségek:
2 ECDL 1. m. IT alapismeretek 2 ECDL 2. m. Operációs rendszerek 2 ECDL 3. m. Szövegszerkesztés 2 ECDL 4. m. Táblázatkezelés 2 ECDL 5. m. Adatbázis-kezelés 2 ECDL 6. m. Prezentáció
2 ECDL 7. m. Információ és kommunikáció
3 Idegen nyelvű olvasott szöveg megértése
Személyes kompetenciák:
Precizitás
Fejlődőképesség, önfejlesztés
Társas kompetenciák:
Együttműködés Módszerkompetenciák: Logikus gondolkodás Rendszerező képesség
1173-06 - Számítógép összeszerelés
Feladatprofil:
Meghatározza a pontos konfigurációt Kiválasztja a megfelelő eszközöket Hardver-optimalizálást végez Összeszereli a számítógép konfigurációt
Elvégzi a kábelek csatlakoztatását, rögzítését az alaplaphoz és a házhoz
Elvégzi a hardver és szoftver teszteket
Üzembe helyezi az UPS-t
Csatlakoztatja a külső számítógépes perifériákat
Telepíti a perifériákat
Ellenőrzi a kapcsolatok helyes működését
Teszteli a számítógép és perifériák működését
Tervet ad a számítógépes megoldás kialakítására
Meghatározza a szükséges eszközöket
Kiépíti és beüzemeli a vezetékes és vezeték nélküli hálózatot
Alkalmazza a tesztprogramokat
Készlet nyilvántartó programot kezel
Telepíti a vírusvédelmi, a személyes tűzfal és az egyéb irodai és alkalmazási szoftvereket Telepíti az operációs rendszert Telepíti a drivereket Frissíti a firmware-t
Hálózat optimalizációs programot alkalmazza
Tulajdonságprofil:
Szakmai kompetenciák:
A típus megjelölésével a szakmai ismeretek:
C Információ technológiai ismeretek C Számítógép főbb részei B Processzor és típusai B Memóriák és típusai B Ki és bemeneti eszközök B Perifériák B Portok és használatuk C Titkosítás
C Adattovábbítási módszerek C Számítógépes környezet kialakítása C Fájlok, mappák kezelése C Jogosultságok kiosztása
C Nyomtatáskezelés B Folyamat és processzorkezelés B Erőforrás kiosztás B Memória kezelés B Felhasználói felület kialakítása B Szoftverek installálása és környezetének kialakítása B Kábelek és csatlakozásaik, topológiák B Hálózati csatolóegység és feladatai B Vezeték nélküli átviteli módok B Protokollok használata, beállítása B Hálózati operációs rendszer alapjai B Hálózati biztonságtechnika B Jogok, attribútumok B Fájlkezelés, megosztás B Nyomtatás hálózatban B Lokális hálózatok fizikai szerelése B Hálózati figyelés, mérések
A szint megjelölésével a szakmai készségek:
3 Alaplap szerelése, összeállítása 3 Memóriabővítés 3 Portok, perifériák csatolása
Személyes kompetenciák:
Pontosság
Társas kompetenciák:
Módszerkompetenciák:
Ismeretek helyén való alkalmazása
1174-06 - Számítógép javítása, karbantartása
Feladatprofil:
Tesztprogramokat futtat Archivált adatokat visszatölt Távfelügyeletet ellát A berendezés műszaki jellemzőit méri Műszaki dokumentációt olvas és értelmez Mérőműszert kalibrál és méréseket végez Mérőprogramot futtat, a mérés eredményeit értékeli A mérés alapján a berendezést minősíti
Segédanyagok, szűrők, alkatrészek állapotát ellenőrzi, szükség esetén cseréli azokat Berendezések állapotát ellenőrzi, karbantartói méréseket végez, portalanít, tisztít Hibajelentést átvesz, munkavégzéshez engedélyeket megszerez Hibát behatárol, hibás alkatrészt/egységet a helyszínen javítja, vagy cseréli, selejtezi Javított, cserélt egység vagy berendezés működését ellenőrzi
Telephelyet bejár, munkaterületre felvonul Régi berendezést bont, munkaterületet előkészíti
Hálózati passzív elemek felszerelését ellenőrzi, átviteli hálózati berendezéseket átveszi Nyomvonalat kialakít, aktív és passzív elemeket csatlakoztat Berendezést felszereli, installálja, teszteli Berendezést a megrendelőnek átadja
Tulajdonságprofil:
Szakmai kompetenciák:
A típus megjelölésével a szakmai ismeretek:
B Hálózati figyelés, mérések B Hibabehatárolás
B Konfigurációs és biztonsági kérdések B SNMP
B MIB, a hálózati menedzsment B Távfelügyelet B Javítási lehetőségek B Hibadokumentálás B Rendszer és eszközvezérlők B BIOS, bios setup beállítások B Processzor illesztése B Memóriahelyek, foglalatok illesztése B ATX szabvány B Slotok használata B Jumperek, kapcsolók, érintkezők B Tápegység, ventilátor, Chipset B ISA, EISA buszrendszer B PCI- és a PCMCIA és interfészek B USB-kezelés B SCSI-interfész kezelése B AGP port alkalmazása B Egyéb portok kapcsolódása B Kapcsolatok vezérlése B Vezeték nélküli adatátvitel B Teljesítmény fokozása B A csővezeték (pipeline) működése B Szuperskalár architektúra B Tuningolás
B Tesztelési programok használata B Optimalizálás B Processzor utasításkészlete B Processzor típusok B Felmérés, javítás előkészítés B Processzor cseréje, hűtőventillátor B Memória bővítése B Tokozások és aljzatok B Merevlemez beállítások B Formatálás, particionálás B Hibaszűrés, mérések
B Karbantartások dokumentálása, minőségbiztosítás
A szint megjelölésével a szakmai készségek:
2 Hálózati ismeretek 2 Számítógép szerelése 2 Számítógép karbantartása
Személyes kompetenciák:
Kézügyesség
Társas kompetenciák:
Módszerkompetenciák:
Áttekintő képesség Kontroll (ellenőrzőképesség)


Adatátvitel

Redundancia

Köznyelvi értelemben bőbeszédűség, terjengősség, felesleges elemeket tartalmazó közlemény.
Információelméleti értelemben a redundancia több jel felhasználása, mint amennyire az adott információ közvetítéséhez feltétlenül szükség van.
Az üzenet közvetítéséhez minimálisan szükséges és az aktuálisan felhasznált jelek mennyisége alapján a redundancia mértéke számszerűen is kifejezhető.
A természetes nyelvek jelentős mennyiségű redundanciát tartalmaznak: a szavak több betűből állnak, mint amennyire egymástól megkülönböztethető szavak létrehozásához szükség lenne, és a mondatszerkesztés nyelvtani szabályai, valamint a stilisztikai követelmények is további információelméleti értelemben felesleges jelekkel növelik a közleményeket. Ugyanakkor a redundancia teszi lehetővé, hogy felfogjunk, megértsünk bizonyos határok között pontatlanul vagy hiányosan közvetített jelsorozatokat (helyesírási hibákat, hiányzó betűket tartalmazó szövegek, rosszul hallható beszéd) is lényeges információk elvesztése nélkül. A technikai kommunikációban a zajos csatornán áthaladó közlemények redundanciáját ugyancsak megnövelik (pl. a jelsorozat többszöri közvetítésével, ellenőrző kódok, hibajavító mechanizmusok beépítésével), hogy megakadályozzák az információk elveszítését.
A tananyagok tervezése során szintén fontos a redundancia optimális mértékének megállapítása. A nehézséget elsősorban az okozza, hogy ugyanazt a tananyagot különböző előzetes tudással rendelkező tanulók használják, így nem határozható meg teljes biztonsággal (néhány, szigorúan egymásra épülő tudáselemeket tartalmazó, ún. zárt tantárgy, pl. a matematika kivételével), mely kifejezéseket ismer egy adott tanuló, milyen bonyolultságú, logikai szerkezetű mondatokat képes értelmezni. Ezért általában az információkat különböző megfogalmazásban többször is közölni kell, esetleg más információközvetítő csatornák felhasználására (képek, ábrák, grafikonok, táblázatok, technikai eszközök, stb.) is szükség lehet.


Adatátviteli sebesség: Digitális hálózatokat az átviteli sebességükkel – az időegység alatt átvitt bitek számával – jellemezhetjük. Ezt bit/s-ban (bps) vagy ennek többszöröseiben (kbps, Mbps) mérjük.

Sávszélesség: Digitális hálózatok esetén a hálózatra (pontosabban a kommunikációs csatornára) jellemző legnagyobb adatátviteli sebességet nevezik sávszélességnek. A sávszélesség minden átviteli eszköz jellemző mennyisége (hálózati kártya, modem, hálózati vonal, stb.). Sok esetben a szolgáltatók két sávszélességi adatot adnak meg. Más sebességgel történhet a letöltés, mint a feltöltés. Pl.: 768/128 kbps. Az átvitel sávszélességét mindig a leglassabb elem sebessége határozza meg (pl.: egy nagysebességű hálózatra kapcsolt modem esetén a modem, telefonvonal esetén a telefonvonal sebessége).

Átviteli közegek

Az adatátvitelhez többféle fizikai közeg használható.

Vezetékes

Fizikai felépítése alapján több fajtát különböztetünk meg. Ezek fizikai tulajdonságai erőteljesen befolyásolják alkalmazhatóságukat. A csomagok elektromos vagy fény impulzusok formájában utaznak. Az egy hálózatot összekötő kábeleket szegmensnek hívjuk. Átviteli sebességük és használhatóságuk alapján három hálózati kábeltípust különböztetünk meg:

koaxiális kábel (hasonló a TV antennához ) A 80-as, 90-es évek elején használták helyi hálózatok kiépítésére. Alacsony adatátviteli sebessége és sérülékenysége miatt az új hálózatokban már nem használják.

csavart érpár
UTP (unshilded twisted pair – árnyékolatlan csavart érpár) napjaink legelterjedtebb hálózati kábele. A külső szigetelésen belül nyolc, egyenként szigetelt eret találunk, melyeket párosával összetekernek, majd a párokat ismét összetekerik, így árnyékolják egymást. A nyolc érből négyet használ a hálózat, 2 küldőt és 2 fogadót, a többit pl. a telefon használja.

STP (shilded twisted pair – árnyékolt csavart érpár) a kábelt fóliával árnyékolják, így biztonságosabban használható hosszabb távolságra is. Két összekötött hálózati végpont között a távolság az ajánlás szerint legfeljebb 100 m. Átviteli sebessége: 10 vagy 100 Mbps.

optikai kábel (üvegszálas kábel) az igen vékony, de hajlékony üvegszálat rugalmas védőanyaggal (gumi vagy kevlár) veszik körül. Az üvegszálas kábelben fényimpulzusok mennek át. Nagyon nagy hálózati sebességet lehet vele elérni, jó hibatűréssel. Az áthidalható távolság több km. A kábel, a csatlakozók és a szerelésükhöz szükséges felszerelés nagyon drága. Viszont nem érzékeny az elektromágneses zavarokra. Vékony, könnyű. Nehéz lehallgatni. teljes visszaverődés
Vezeték nélküli

Amikor nem lehetséges vezetékes összeköttetést létesíteni az állomások között, vezeték nélküli technológiák közül lehet választanunk:

Infravörös (1012-1014 Hz): Elsősorban kistávolságú adatátvitel esetén (pl. TV távirányító). Olcsó, könnyen előállítható, viszonylag jól irányítható, viszont óriási hátrány, hogy szilárd testeken nem képes áthatolni. Így is alkalmasak lehetnek épületen belüli lokális hálózatok átviteli rendszerének kialakítására.
Rövidhullámú, rádiófrekvenciás átvitel (WiFi, Bluetooth) kisebb távolságra. Mikrohullámú tartományban (100 MHz felett). Egyenes vonal mentén terjed (ismétlők kb. 50 km-enként), jól fókuszálható (parabolaantenna).
Mikrohullámú átvitel, mely működésének feltétele, hogy a két antennának látnia kell egymást.
Lézer
Műholdas átvitel: Geostacionárius műholdak. A műholdakon lévő transzponderek a felküldött mikrohullámú jeleket egy másik frekvencián felerősítve visszasugározzák (3,7...4,4 GHz le, 5,9...6,4 GHz fel). Jelentős a késleltetés (250-300 ms).

TCP/IP



A TCP/IP egy hálózati protokoll. (Transmission Control Protocol/Internet Protocol, magyarul: Átvitel Vezérlési Protokoll/Internet Protokoll) A TCP/IP kezdettől fogva az Internet (és a Linux) protokollja. A modern számítógépes hálózatokban a továbbítandó adatok nem egybefüggő folyamként haladnak egyik géptől a másikig, hanem több különálló adatcsomag (datagram) formájában.

A TCP/IP protokoll két alrendszerének az alábbi feladatai vannak:
TCP - A küldő számítógépen a továbbítandó adathalmaz feldarabolása adatcsomagokra, és az adatcsomagok címkézése. Az adatokat fogadó számítógépen pedig a kapott adatcsomagok összerakása, és így az eredeti adathalmaz előállítása.
IP - Az adatcsomagok irányítása, a kommunikációban résztvevők (gépek) azonosítása.
Ez utóbbi feladat igen összetett és sokrétű. Egy IP alapú hálózat, minden egyes számítógépe (sőt ezen túlmenően minden egyes hálózati interfész pl. hálózati kártya) egyedi azonosítóval rendelkezik (IP cím). Ne felejtsük el, hogy egy PC-ben lehet több hálózati kártya is! Az egyediség, vagyis az, hogy minden PC más és más IP címmel rendelkezik, az összefüggő hálózatokban elengedhetetlen alapkövetelmény.
Ez azt is jelenti, hogy egy "kifelé" zárt hálózatban (pl. vállalati, vagy otthoni intranet) használhatóak olyan IP címek, amelyek egyébként az interneten szerepelnek, hiszen ütközés nem lehetséges, mivel a hálózat nem kapcsolódik az internethez.
Nagyon fontos!!! Az IP címét egy hálózati kártya nem a gyártásakor kapja meg, és így az nem egy végleges valami. Az IP címet az adott hálózat üzemeltetői határozzák meg, természetesen egy rendszer szerint, bizonyos kritériumok figyelembevételével. A kifelé zárt rendszernél, - hálózatnál - az egyetlen dolog amire figyelni kell, hogy a hálózatben ne legyen két azonos IP cím, tehát az egyediség a fontos. Ha azonban a gépünk, illetve a hálózatunk kifelé nyitott, vagyis kapcsolódik egy másik hálózathoz, (pl. az Internethez) akkor nagyobbrészt az Internet szolgáltatótól (ISP=Internet Service Provider) függ, hogy milyen IP címeket használhatunk.

Nézzük meg azt az esetet, amikor pl. egy PC-ben lévő hálózati kártyának mindig ugyanaz az IP címe, (fixre van állítva)! Ebben az esetben úgynevezett: "statikus IP cím"-ről beszélünk. Ha az IP cím csak akkor derül ki, amikor az Internet kiszolgáló szerverhez kapcsolódik a PC, vagyis a szolgáltató osztja ki az ő IP tartományából véletlenszerűen, akkor már "dinamikus IP cím"-ról van szó.

Az IP cím felépítése, jellemzői

Az IP cím egy 4 byte-ból, azaz 32 bit-ből álló számsorozat. Leggyakrabban pontokkal elválasztott decimális formában találkozhatunk vele: xxx.xxx.xxx.xxx alakban. Mind a négy tag, 0-255 közötti értéket vehet fel. Példa egy lehetséges IP címre: 192.168.1.215

Egy rendkívül fontos kérdés az, hogy egy olyan hálózatban, amelyben több ún. "alhálózat" van fizikailag összekötve, milyen IP címeket alkalmazhatunk. Vagyis mi az alhálózat és a hálózat közötti különbség.
Tételezzük fel, hogy otthon a lakásban van egy egymással fizikailag összekötött számítógép rendszer. Mindenkinek külön gépe van, és az összekötések révén, a 4 PC kommunikálni tud egymással. Mondjuk a szomszédban, és a ház még néhány lakásában is van egy-egy ilyen rendszer. Ezek mindegyike egy önálló számítógépes hálózat. Ha felmerül az igény, hogy az egyes lakásokat is kössük össze egymással, akkor ez kétféleképpen tehető meg:

Átkábelezzük az egész épületet, és csinálunk egy nagyobb, (minden PC-t magába foglaló) új hálózatot. (Ez elég bonyolult és valljuk be, hülye megoldás.)
Meghagyjuk a már meglévő lakásonkénti hálózatokat, és a lakásokat fűzzük fel egy új hálózattá. Ebben a pillanatban már a lakásokban lévő összekötött PC-k a házban kialakított hálózat alhálózataivá válnak.
Visszatérve az előbbi kérdésre, hogy tudniillik: Milyen IP címeket használhatunk a fizikailag összekötött alhálózatok esetében? Nos ennek a kérdésnek a megválaszolásához szükség van, - az IP címeken kívül - az úgynevezett "hálózati maszk"-ra (netmask). A netmask ugyanúgy néz ki mint egy IP cím, tehát 4 pontokkal elválasztott decimális szám. A hálózati maszk azonban azt mutatja meg, hogy egy adott alhálózaton, az elejétől fogva, hány bitnek kell megegyeznie az IP címben. Ha például az első 24 bitnek kell megegyeznie, akkor az alhálózati maszk a következő lesz:
1111 1111 1111 1111 1111 1111 0000 0000
255 255 255 0
netmaszk
A megismert módon, a fenti netmask helyesen felírva: 255.255.255.0 lesz. Ebből az derül ki, hogy ennek az alhálózatnak 256 tagja lehet. Vagyis ezzel a maszkkal 256 db PC köthető hálózatba. Természetesen ezeknek a gépeknek egyedi IP címei lesznek, de a maszk által meghatározott módon, minden PC-nek az IP címe ugyanazzal a három taggal kezdődik! Tehát ennek a hálózatnak a gépei pl. az alábbi IP címekkel rendelkezhetnek:
192.168.0.1
192.168.0.2
192.168.0.3 ...
192.168.0.255
Látszik, hogy az IP cím két részre osztható. Az egyik része az alhálózat minden gépén ugyanaz, ez tehát a hálózati azonosító.
A másik, a maradék rész az adott alhálózaton belül egy gép (hálózati kártya) egyedi azonosítója. Tehát a 192.168.0.113 IP címnél a 192.168.0 a hálózati azonosító, a gépet az alhálózaton belül pedig a 113 azonosítja.
Ha a hálózati azonosító végén lévő biteket 0-ra írjuk, akkor megkapjuk a az alhálózat címét, ami egyúttal az adott alhálózat legkisebb címe. Példánkban: 192.168.0.0

Az IP címeket, eredetileg három csoportba osztották. (Az IP címek rohamos fogyása miatt ez a rendszer már jelenleg is átalakulóban van. Lásd IPv6!)

"A" osztályú IP cím.
Az "A" osztályú hálózatban, az első byte a hálózati azonosító. A fennmaradó 24 bit azonositja a hálózati interfészeket (PC-ket). Egy "A" osztályú hálózat 224, azaz kb. 16,7 millió(!) tagból állhat.
1111 1111 0000 0000 0000 0000 0000 0000
255 0 0 0
"A" osztályú IP tartomány
Ilyen nagyméretű hálózat kevés létezik. Egy "A" osztályú hálózat az alábbi IP tartományt használja: 1.0.0.0 - 127.255.255.255
"B" osztályú IP cím.
A "B" osztályú hálózatban, az első 2 byte a hálózati azonosító. A fennmaradó 16 bit azonosítja a hálózati interfészeket. Egy "B" osztályú hálózat 216 azaz 65536 tagból állhat.
1111 1111 1111 1111 0000 0000 0000 0000
255 255 0 0
"B" osztályú IP tartomány
A "B" osztályú, közepes méretű hálózat a 128.0.0.0 - 191.255.255.255 IP tartományt használja.
"C" osztályú IP cím.
A "C" osztályú hálózatban az első 3 byte a hálózati azonosító. A fenmaradó 8 bit azonosítja a hálózati interfészeket. Egy "C" osztályú hálózat 28 azaz 256 tagból állhat.
1111 1111 1111 1111 1111 1111 0000 0000
255 255 255 0
"C" osztályú IP tartomány
A "C" osztályú, kisméretű hálózat 192.0.0.0 - 223.255.255.255 IP tartományt használja.
A 224.xxx.xxx.xxx és a 255.xxx.xxxx.xxx számmal kezdődő IP címeket speciális célokra tartják fenn, ezért ez a tartomány nem osztható ki. Vannak azonban úgynevezett "privát" IP címek, amelyek általában magáncélra, Internethez nem kapcsolódó gépekhez alkalmazhatóak.
"A" osztályú hálózathoz: 10.0.0.0
"B" osztályú hálózathoz: 172.16.0.0 - 172.31.0.0
"C" osztályú hálózathoz: 192.168.0.0 - 192.168.255.0
Van egy speciális hálózati cím, nevezetesen a 127.0.0.0
Ez a cím, helyi IP forgalomhoz van fenntartva, és ezen belül a 127.0.0.1 az ún. "LOOPBACK" (visszahurkoló) interfész címe. Ez egy "virtuális" hálózati kártya, amely olyan gépeken is lehetővé teszi a TCP/IP alapú tevékenységet, amelyben fizikailag nincs is hálózati kártya.
Az IP-címek, tartományok kiosztása, és nyilvántartása a Network Information Center (NIC) nevű szervezet feladata. Magyarországi szervezete megtalálható, a http://www.nic.hu/ URL címen.

Tekintettel arra, hogy a még ki nem osztott IP tartományok köre rohamosan fogy, a szükség elvezetett a "C" osztályúnál kisebb tartományokhoz is. Nézzünk meg egy negyed "C" osztályú tartományt! Az elv ugyanaz, mint a korábban megismert, vagyis az alhálózat azonosítója az első 3 és 1/4 byte.
1111 1111 1111 1111 1111 1111 1100 0000
255 255 255 192
negyed "C" osztályú IP tartomány
Vegyük például, a 192.168.0.0 hálózati címet! Ha elosztjuk a fenti táblázat szisztémája szerint négy egyenlő nagyságú IP tartományra, akkor a négy tartomány kezdő és végcímei az alábbiak szerint alakulnak:
192.168.0.0 - 192.168.0.63
192.168.0.64 - 192.168.0.127
192.168.0.128 - 192.168.0.191
192.168.0.192 - 192.168.0.255
Minden alhálózatban vannak fenntartott címek. Az előbbiekben már volt arról szó, hogy a legkisebb cím, az alhálózatot címzi meg, ezért hálózati címnek (hálózati kártya címnek) nem osztható ki.
Ugyanígy foglalt az adott alhálózat legnagyobb IP címe is, mert ez a cím van kijelölve üzenetszórásra (broadcast). Ezen a broadcast címen az alhálózat valamennyi eleme, tagja elérhető. Ez az adattovábbítás szempontjából igen fontos.

Speciális IP-címek

 
00000000.00000000.00000000.00000000 Az aktuális gép.
00000 ... 00000 host Az aktuális hálózat megadott gépe
11111111.11111111.11111111.11111111 Broadcast az aktuális hálózaton.
network 00000 ... 00000 A megadott hálózat azonosítója.
network 11111 ... 11111 Broadcast a megadott hálózaton.
01111111 bármi Loopback
Nézzük meg egy IP csomag továbbítását!

Első példánk, egy egyszegmensű hálózat, ahol egyetlen kábel köti össze az összes PC-t. A küldő gép IP címe legyen pl.: 192.168.0.193! A hálózat "C" osztályú, innen már tudjuk, hogy a netmaszk: 255.255.255.0.
A célállomás IP címe, - ahová a küldő indítja az adatcsomagot - 192.168.0.253.
A küldő PC a fenti három adatból meg tudja állapítani, hogy a célgép ugyanazon az alhálózaton van, mint ő maga. Az adatok elküldéséhez, szükség van a célgép Ethernet címére. Ezt a küldő gép le tudja kérdezni egy ethernet-specifikus ún. ARP kérdéssel (Adress Resolution Protocol). Ez az a kérés, ami a broadcast címre megy, (az alhálózat legnagyobb címe) így az összes gép megérti, de csak a keresett IP című gép fog rá válaszolni, mégpedig a saját Ethernet címével. (Az ethernet címet a hálózati kártya, a gyártásakor kapja meg). Ezután a küldő PC az IP csomagból ethernet-csomagot állít elő, és elküldi azt.
De mi van olyankor, ha a hálózat nem egyszegmensű, hanem több alhálózatból áll?
Ebben az esetben szükség van egy forgalom irányító eszközre (router) is.
A router, egy olyan hálózati eszköz, amely 2 vagy több hálózati interfésszel rendelkezik, és a feladata, hogy összekössön több fizikai hálózatot. (Természetesen ha egy PC-be két hálózati interfészt építünk, akkor az is lehet router!) Ilyenkor a hálózatba kapcsolt gépeknél az IP címen és a netmaszkon kívül ismerni kell az alapértelmezett átjáró útvonalát (default gateway). Az esetek többségében ez megegyezik az azonos alhálózaton lévő router IP címével.

Nézzünk most egy konkrét példát a routolás megértéséhez!

routolás
Amint az látható, a két "fél C osztályú" tartományt egy olyan router köti össze, amelynek mindkét alhálózathoz van IP címe! A küldő gép, a saját IP címéből és a netmaszkból, valamint a célgép IP címéből rájön hogy nincsenek egy alhálózaton. Ezért a nála beállított alapértelmezett átjáróhoz fordul és ide küldi el az adatcsomagot. A routerben kiderül, hogy a célgép IP címe a router másik interfészével azonos alhálózaton van, így a már ismert módon a küldemény célba ér.
Ha a cél a router egyik interfészével sincsen közös alhálózaton, akkor ő is továbbküldi a csomagot a saját alapértelmezett átjárójára és így tovább mindaddig, amíg az egyik gateway talál egy számára megfelelő szegmenst.
DNS

A TCP/IP alapú hálózatokban a címzés az IP címekkel történik. Ezzel a kommunikáció kiválóan működik, de a mindennapi használat során igen nehézkessé válhat. Gondoljon csak arra, hogy hogyan jutott el például a prog.hu weboldalára? Valószínűleg nem ezt írtja be a böngészödbe, hogy http://94.199.48.135 bár az eredmény ugyanaz, mintha azt írta volna, hogy http://www.prog.hu
Egy-két IP-cím példa:

origo.hu: 195.228.240.145
www.nanaskabel.hu: 212.24.176.130
www.csihagy-hnanas.sulinet.hu: 195.199.145.57
www.korosi-hnanas.sulinet.hu: 195.199.145.65
az én gépem címe (egyszer valamikor): 82.141.176.5
Szívesebben használjuk a szemléletesebb szimbolikus címeket (DNS neveket). A domain név szolgáltatás szerverei biztosítják számunkra azt, hogy szemléletesebb nevek megadásával az adott nevet megfelelteti az azt jelentő IP címmel.
Ezek a szimbolikus nevek egy jobbról induló hierarchiában foglalnak helyet. Nézzünk egy ilyen nevet közelebbről és fejtsük meg, hogy mit is jelentenek a részei!
A kérdéses szimbolikus név legyen pl. a http://www.prog.hu
Ebben a névben a ".hu" végződés, a felsőszintű domain arra utal, hogy ez egy magyar oldal. Az aldomain, a "prog" az oldal jellegére utal. A "www" a world wide web mozaikszava és világméretű, széles hálózatot jelent. (Ez átvitt értelemben, hiszen a hálózat angolul network, a web szó szerint pókhálót jelent, de az internetet ismerve, az elnevezés teljesen találó.) A http pedig az internetes böngészés szabványára utal (HiperText Transfer Protocol).
Mivel a TCP/IP alapú hálózatoknál (az Internet is ilyen) az adatcsomagok IP-cím alapján jutnak célba, ezért szükséges a nevekből megállapítani az IP-címet. Ezt a feladatot végzik el az ún. DNS szerverek. (Domain Name System) Minden körzetben van egy regisztrált DNS kiszolgáló, amelyik felel a körzetért. A DNS szerverek azonban nem csak arra képesek, hogy a névből IP címet állítsanak elő, hanem arra is, hogy az IP címre névvel válaszoljanak (reverse funkció).
Útválasztás

Tegyük föl, hogy az "A" hoszt szeretne információt küldeni a "J" hosztnak! Milyen útvonalon menjenek a csomagok?

Jellemzők:
Visszafelé nem megyünk. (Tehát a pl. "H"-ból az "F" felé megyünk, mert a "G"-ből értünk oda.)
Ha egy routertől két vagy több másik router felé ugyanaz a költség, akkor az elsőt választjuk. (pl. a "B"-ből a "C"-t választjuk a "G" helyett.)
(Persze ez csak akkor, ha csak a közvetlen szomszédokhoz vezető költségeket ismerjük. Ha már a 2. szomszédhoz vezető költségeket is ismernénk, akkor más lenne a szitu.)
Mivel a különböző útvonalak költségei pillanatról pillanatra változnak, ezért a csomagok nem ugyanazon az útvonalon fognak közlekedni.
Az "A" router táblája (routing table)
Melyik routerhez? Mennyi az odavezető költség?
B 3
G 2
H 4


Ha csak a közvetlen szomszédba vezető költségeket ismerjük.

Ha minden router a szomszéd router felé ismeri a kölstéget, akkor a fenti útvonalon halad a csomag. Így a költség 13.


Az ideális útvonal

Viszont a fenti útvonalat választva a költség csak 11.

Ha nem csak a közvetlen szomszádokhoz vezető költségeket ismerjük, hanem pl. a 2. szomszédhoz vezetőt is, akkor nagyobb eséllyel tudjuk az optimális utat kiválasztani. Ekkor viszont bonyolultabb lesz a routing tábla. (Az is időt vesz el, míg meghatározzuk a következő állomást!)
A routerek állandóan frissítik a táblázataikat.

Az optimális útvonal nem biztos, hogy a fizikailag legrövidebb útvonalat jelenti, ugyanis nagyon sok tényező befolyásolja az optimális választást. Ilyen lehet pl. a csomópont átlépések száma; az az idő, amennyi alatt a csomag eljut a következő csomóponthoz; vagy a vonalhasználat költsége.

Óraterv

A hálózatok célja, alkalmazása, alapfogalmak

Szervezési feladatok. Követelmények ismertetése
A számítógépes hálózatok előnyei, hátrányai
Hálózati struktúrák
Két pont közötti csatornával rendelkező alhálózat (pont-pont összeköttetés)
Üzenetszórásos csatornával rendelkező alhálózatok (multipont összeköttetés)
Hálózati architektúrák
Rétegek, protokoll, réteginterfész.
Szimplex, halfduplex, full duplex átvitelek.
Hálózatszabványosítás (de-jure, de-facto)
Az OSI modell I.
Az OSI modell II.
Szolgálatok a rétegek között
Összeköttetés alapú szolgálat.
Összeköttetés-mentes szolgálat.
Tartalék óra
Összefoglalás
Számonkérés
Fizikai átviteli jellemzők és módszerek

Bevezető óra: a fizikai átvitellel kapcsolatban felmerülő kérdések
Általános elméleti alapok
Vonalak megosztása
Multiplexelés frekvenciaosztással, ill. időosztással
Vonalkapcsolás
Üzenet és csomagkapcsolás
Vezetékes átviteli közegek
Csavart érpár (UTP, STP, FTP)
Koaxiális kábelek (alapsávú, szélessávú).
Egyéb átviteli közegek
Üvegszálas kábel.
Vezeték nélküli átviteli közegek (infravörös, lézer átvitel; rádióhullám; szórt spektrumú sugárzás; műholdas átvitel).
Analóg átvitel I.
Telefónia.
Cellás mobil rádiótelefonok.
Analóg átvitel II.
Modemek.
Faxok
Digitális átvitel
Digitális jelek kódolása
Karakterek ábrázolása
az ASCII kódrendszer
Unicode
Párhuzamos és soros adatátvitel, aszinkron soros adatátvitel
ISDN - integrált szolgáltatású digitális hálózat
ATM - Asychronous Transfer Mode
Tartalék óra
Tartalék óra
Összefoglalás
Számonkérés
Közeg-hozzáférési módszerek

Bevezető óra: közeg-hozzáférési kérdések
Véletlen átvitel-vezérlés
Osztott átvitel-vezérlés
Adatkapcsolati protokollok

Bevezető óra: az adatkapcsolati protokollal kapcsolatban felmerülő kérdések (karakter-, ill. bitorientált átvitelek)
Keretek képzése
Hibakezelés
Tartalék óra
Összefoglalás
Számonkérés
Hálózati réteg

Bevezető óra: A hálózati réteg feladata. A réteggel kapcsolatban felmerülő kérdések
Forgalomirányítás
A legrövidebb út meghatározása
Determinisztikus forgalomirányítás
Torlódásvezérlés
Tartalék óra
Összefoglalás
A felsőbb rétegek

Szállítási réteg
Viszonyréteg
Megjelenítési réteg
Adatábrázolás
Adattömörítés
Hálózati biztonság és védelem (titkosítás)
Alkalmazási réteg
Tartalék óra
Összefoglalás
Számonkérés
Lokális hálózatok

IEEE 802-es szabványok
Az IEEE 802.3 szabvány és az ETHERNET
Lokális hálózati operációs rendszerek és funkcióik
Tartalék óra
Összefoglalás
A TCP/IP protokoll és az Internet

TCP/IP protokoll
Az Internet szállítási rétege: a TCP
Az Internet hálózati rétege: az IP
IPv4 – IPv6
Címzési rendszer
IP útválasztás (routing)
Internet szolgáltatások
Kapcsolódás az Internetre
E-mail (Electronic mail)
FTP (File Transfer Protocol)
Telnet
Levelezési listák
WWW (World Wide Web)
A HTTP-protokoll
A hálózat emberi tényezői
Tartalék óra
Összefoglalás
Számonkérés
Az éves munka értékelése
A hálózatok célja, alkalmazása, alapfogalmak
Hálózati struktúrák (két pont közötti csatornával rendelkező alhálózat: pont-pont összeköttetés, üzenetszórásos csatornával rendelkező alhálózat: multipont összeköttetés)
Hálózati architektúrák
Hálózatszabványosítás (de-facto, de-jure)
OSI modell
Átviteli közegek
Csomagkapcsolás
Cellás mobil rádiótelefonok
Párhuzamos és soros átvitel
Analóg átvitel (amplitúdó moduláció, frekvencia moduláció, fázis moduláció)
Digitális jelek kódolása (NRZ, RZ, NRZI, AMI, HDB3, Manchester)
Közeghozzáférési módszerek (véletlen vezérlés, osztott vezérlés, központosított vezérlés)
CSMA/CD (Carrier Sense Multiple Acces with Collision Detection - ütközést jelző vivőérzékeléses többszörös hozzáférés)
Keretek képzése (karakterszámláló módszer, kezdő- és végkarakterek alkalmazása karakterbeszúrással, kezdő- és végjelzők bitbeszúrással)
Forgalomirányítás
A TCP/IP protokoll
MAC, IP, ipconfig, stb.
A HTTP protokoll
Internetszolgáltatások (e-mail, ftp, telnet)
A hálózat emberi tényezõi

Virtuális gép használata

A legbiztosabb módszer – virtuális gép

https://vessoft.hu/software/windows/download/virtualbox

Ha nincs kéznél egy tartalék PC, akkor a virtuális gép létrehozása a legkönnyebb és legbiztosabb módszer. Ehhez ráadásul mindössze az ingyenes VirtualBox programra van szükség, na és persze egy kompatibilis processzorra.

Meg kell jegyezni, hogy az operációs rendszerek virtuális környezetben való futtatásakor feláldozunk egy keveset a gép teljesítményéből – főleg akkor, ha eleve nem sok processzormaggal és memóriával dolgozik a PC-nk.

A Windows 10 előzetesének VirtualBox alatti telepítésekor sok apró hibába lehet belefutni. A leggyakoribbak közé tartozik a kékhalál, a fekete képernyő és a fekete képernyős hibaüzenet. Ha valamelyikbe belefutunk, engedélyezni kell a Rendszer fülön az EFI-t, a Processzor alatt pedig a PAE/NX-et.

Többek közt oktatási célra is remekül használható a Portable VirtualBox.
Az elmúlt években az ingyenes VirtualBox és VMware Player szoftvereknek köszönhetően a virtualizáció kitört a vállalati szférából, elérhetővé vált az otthoni felhasználók számára is. Elsőként tisztázzuk, hogy miről is van szó: a virtualizációs szoftverek a számítógépünk bármely más felhasználói alkalmazásához hasonlóan az operációs rendszeren futnak, azonban létrehoznak egy izolált környezetet, amelybe további operációs rendszereket telepíthetünk. Ilyenkor nem történik semmiféle particionálás vagy hasonló, a virtualizált OS háttértára egy szimpla állomány (lemezkép) lesz.

Ez lehetővé teszi, hogy például a Windows rendszerű számítógépünkön kipróbálhassuk egy új Linux-disztribúciót: létrehozhatunk a virtualizációs programban egy virtuális számítógépet (VM), majd erre feltelepíthetjük a kipróbálandó disztribúciót. Ha elindítjuk a VM-et, akkor szó szerint kettő operációs rendszer fut majd szimultán a számítógépünkön. Sejthetően a virtuális számítógépek nem képesek olyan sebességgel működni, mintha hagyományos telepítést hajtottunk volna végre, a 3D-gyorsításról pedig tegyünk le.


Hordozható VM
Maguk a virtuális számítógépek mindig is hordozhatóak voltak, azonban a futtatásukhoz szükséges környezet nem. Ennek oka, hogy a virtualizációs szoftverek működéséhez különféle meghajtókra van szükség, a hordozható alkalmazásoktól eltérően számos extra függőséggel rendelkeznek. Szerencsére nem teljesen lehetetlen kialakítani egy hordozható környezetet, a Portable VirtualBox nevű alkalmazás ugyanis képes egy „burkot” képezni a VirtualBox köré, azaz a szoftver telepítés nélkül futtatható vele. Az elkészített környezetet egyszerűen kimásolhatjuk egy megfelelő kapacitású pendrive-ra.

Néhány perc alatt létrehozható egy hordozható virtuális környezet

A szoftver két komoly megkötéssel rendelkezik: egyrészt csak Windowsos számítógépeken működőképes, másrészt pedig a futtatásához adminisztrátori jogosultságot kell biztosítani. Ettől függetlenül nagyon hasznos eszközről van szó, akár oktatási és prezentációs célokra is használható, például anélkül mutathatunk konfigurált Linuxot az érdeklődő ismerőseinknek vagy diákjainknak, hogy hosszas macerán kellene keresztülmennünk. Előkapjuk az USB-kulcsot, csatlakoztatjuk a legközelebbi Windowsos számítógéphez, elindítjuk a Portable VirtualBoxot, 2 percen belül pedig indulhat is a demonstráció.

Beüzemelés
A Portable VirtualBox viszonylag egyszerű eszköz. Elsőként töltsük le magát az alkalmazást, egy önkicsomagolás .exe fájlt kapunk. A kitömörítés után indítsuk el a programot, válasszuk ki a preferált nyelvet. A megjelent ablakban kattintsunk a „Download installation files of VirtualBox” szövegre, mire a program letölti a VB legfrissebb telepítőkészletét. Ennek végeztével pipáljuk ki az összes lehetőséget („Extract the files...” és „Start Portable-Virtualbox...”), végül klikkeljünk az OK gombra.

Az USB-t és hálózatot külön kell bekapcsolni

Ezzel lényegében meg is vagyunk, elindult maga a VirtualBox. Egy dolgunk van még: a jobb egérgombbal kattintsunk a Portable VirtualBox Tálcán lévő ikonjára, ott válasszuk ki a „Settings” menüt. Az USB és Network fülekben kapcsoljuk be a kérdéses eszközök támogatását.


Innentől kezdve már csak a virtuális gépeket kell létrehoznunk, a komplett Portable VirtualBox mappát szabadon mozgathatjuk a számítógépünk mappái, vagy éppen külső meghajtók közt, természetesen a virtuális gépekkel együtt.
A portable programok gyakorlatilag bárhová elvihetőek egy pendrive segítségével. A Portable-VirtualBox segítségével már egy virtuális gép hordozása sem probléma többé.

A Portable-VirtualBox telepítése egy hordozható eszközre

Az első lépésben le kell tölteni magát a programot a fejlesztő weboldaláról. A letöltés befejezte után indítsuk el és csomagoljuk ki a pendrive-unkra (nálam most a H betűjelet kapta).

A kicsomagolás végezte után lépjünk fel az eszközünkre és keressük meg a Portable-VirtualBox.exe fájlt.

Ha megnyitottuk, akkor kérdezni fogja a használandó nyelvet. Hagyjuk angolul (english), majd kattintsunk az OK gombra.

A megnyílt ablakban tudjuk letölteni magát a programot. Jelöljük be a az Extract files for a 32-Bit system és Extract files for a 64-Bit system melletti jelölőnégyzeteket. Ha ez megvan, akkor kattintsunk a Download installation files for VirtualBox gombra és várjunk, míg a fájlok letöltődnek.

Ha végzett, indítsuk el még egyszer a programot a pendrive-ról.

A megjelenő ablakban pipáljuk be újra az Extract files for a 32-Bit system és az Extract files for a 64-Bit system opciókat, de most kattintsunk a Search gombra. A megjelenő ablakban válasszuk ki a program által letöltött VirtualBox.exe fájlt, ami a pendrive-on van. Jelöljük ki lent a Start Portable-VirtualBox after the extract and/or compress jelölőnégyzetet is. Kattintsunk az OK gombra. Innentől már csak várni kell!

Ha végzett, a program magától meg fog nyílni. Lent az értesítési tálcán meg fog jelenni a VirtualBox. Kattintsunk rá jobb egérgombbal, majd menjünk a Settings lehetőségre.

Kattintsunk az USB fülre, majd jelöljük be a második lehetőséget.

Menjünk a Network fülre, és ott is jelöljük be a második lehetőséget. Ezután kattintsunk a Save gombra. Virtuális gép készítése és futtatása

Ez a lépés igazából nagyon egyszerű, ugyan úgy működik, mint az eredeti verzió esetében. Kattintsunk a New gombra, és a varázsló utasításai szerint menjünk végig a folyamaton.

Az elkészített virtuális gépet hordozhatjuk a pendrive-on, és bárhol használhatjuk egy telepítő birtokában, ahol szükségünk van rá. (A programot mindig a Portable-VirtualBox.exe fájlal kell elindítani!)

Megjegyzés: A program bezárása után mindig rá kell kattintani az Exit Portable-VirtualBox gombra (ez általában az asztalon jelenik meg)! A pendrive eltávolításánál először mindig menjünk az eszköz biztonságos eltávolítása gombra, mert ha a biztonságos eltávolítás nélkül kivesszük a pendrive-ot, akkor a fájlok megsérülhetnek.

2017. szeptember 26., kedd

Jáva óravázlat


A Java egy objektum-orientált programozási nyelv, amelyet a C++ programnyelvből fejlesztettek ki. Elsődleges célja az volt, hogy legyen egy olyan programozási nyelv, amelyet az Interneten keresztül is használhatunk, biztonságos, és lehetőleg platformfüggetlen.
A platformfüggetlenség azt jelenti, hogy nemcsak UNIX-on, PC-n, ... stb, lehet futtatni az adott programot, hanem bármilyen géptípuson. Ez annyiban sántít csupán, hogy "bármilyen géptípuson" futtatható egy Java program, amely rendelkezik Java futatóval, az ún. Java Virtual Machine-nal (JVM), azaz egy virtuális, Java programot futtatni képes környezettel.
Az Interneten keresztül történő használat azt jelenti, hogy a Web-böngészőben megjelenő Weblapjainkról indulhatnak ún. Java appletek, amelyek azonos módon fognak megjelenni és futni, minden platformon futó Web-böngészőben. A Java appletek a Java programoktól abban különböznek, hogy az appletnek korlátozottak a képességei. Például nem írhatja, olvashatja a helyi fájljainkat, míg egy Java programból ugyanúgy beolvashatom, írhatom mintha azt egy másik programozási nyelven tettem volna meg.
A Java programozási nyelv jellemzői:
    •egyszerű
    •objektumorientált
    •előfordított
    •értelmezett
    • robusztus
    • biztonságos
    •semleges architektúrájú
    •hordozható
    •nagy teljesítményű
    •többszálú
    • dinamikus
A Java fordítóprogramos programnyelv, de a fordítás folyamata az alábbiak alapján történik:
1. Először a forrásprogramot a Java-fordító (compiler) egy közbülső nyelvre fordítja >     Java bájtkódot kapunk eredményül. (ez a bájtkód hordozható)

Ezt a kódot értelmezi és futtatja a JVM. A JVM tehát egy interpreternek tekinthető.

A Java programok készítéséhez az alábbiakra lesz szükségünk:
    •Java integrált fejlesztőkörnyezet (Java SE + NetBeans).
Letöltés: http://java.sun.com/javase/downloads/index.jsp
Telepítés: A telepítés a Windowsban megszokott egyszerűséggel történik, általában elegendő a Next gombra kattintani.

 Java dokumentációk a dokumentációk letölthetők a http://java.sun.com oldalról.
                                                                                                                                                                                                     
A programok készítésénél a Sun saját fejlesztőkörnyezetét a NetBeanst fogjuk használni. Ez egy integrált fejlesztőkörnyezet (Integrated Development Environment, IDE). A NetBeans lehetővé teszi a programozók számára a programok írását, fordítását, tesztelését, valamint hibakeresés végezését, majd a programok profilozását és telepítését is.
Ismerkedjünk meg egy egyszerű projekt készítésének a folyamatával!
(Hogyan lehet Java alkalmazást készíteni?)
1.2.1.    Projekt létrehozása
A NetBeans indítása után File > New Project

A Java kategórián belül a Java Application projektet válasszuk ki.

A következő lépésben a projekt nevét kell megadnunk.
Kapcsoljuk be a Create Main Class, valamint a Set as Main Project opciót.

A Finish gomb lenyomásával indul a varázsló és elkészíti a projektünket.
A varázsló futtatásának eredménye:

Az előző lépéseket végrehajtva elkészítettünk egy Szerbusz_Világ nevű projektet, amely tartalmaz egy szerbusz_vilag nevű csomagot, valamint egy Main nevű osztályt. Ezekről a későbbiek során fogunk tanulni.
1.3.   Az első program elkészítése
Feladat: Üdvözlő szöveg kiírása a képernyőre. ("Szerbusz Kedves Idegen!")
Fontos tudnunk, hogy a Java nyelvben megkülönböztetjük a kis-és nagybetűket. Ezenkívül a forrásprogram fájlneve és a benne definiált public típusú osztály neve azonos kell legyen, még a betűállást tekintve is.
Készítsünk egy új projektet ElsoProgram néven.
A készítés menete az előző részben leírtak alapján történik, azzal az eltéréssel, hogy most ne hagyjuk bekapcsolva a Create Main Class, valamint a Set as Main Project opciót.
Szúrjunk be a projektbe egy üres Java fájlt.

Az osztály neve egyezzen meg a projekt nevével.

Elkészült az ElsoProgram projektünk, egy ugyanolyan nevű osztállyal.

Gépeljük be a forrásprogramot a fejlesztőrendszerbe!
Különösen figyeljünk oda minden zárójelre, pontosvesszőre, mert egy jel hiánya is szintaktikai hibát eredményez, és nem fogja a fordító elfogadni. A beíráskor a példa szerinti tagolásban vigyük be a programot. Ez azért fontos, mert így könnyen áttekinthető lesz a programunk, és a hibákat gyorsan felfedezhetjük.
A parancsok begépelésénél használhatunk rövidítéseket, általában a parancs első két karakterének a begépelése után nyomjuk meg a TAB billentyűt. pl.
pu + <TAB> public
cl + <TAB> class
psvm + <TAB> public static void main(String[] args{})
sout + <TAB> System.out.println("");

Vizsgáljuk meg soronként a program felépítését.
1. A // kezdetű sorok megjegyzések, és nem kerülnek feldolgozásra. Itt a program érthetőségét növelő egyéni megjegyzéseket helyezhetünk el.

2. Ebben a sorban adjuk meg az osztály definícióját, amelyben meghatározzuk a láthatóságát (public), a nevét (ElsoProgram) és egyebeket, melyekről a későbbiekben lesz szó. Ezt követi egy blokk, amelyet kapcsos zárójelek közé zárunk.

3. Programunk egy metódust tartalmaz, amelynek neve "main", vagyis "főmetódus". Az íves zárójelben egy karakterlánctömböt definiálunk "String args[]", amelyben a parancssori paramétereket kapjuk meg. A main metódus tartalmát is kapcsos zárójelek közé zárjuk.

4. A "System.out.println" az íves zárójelben megadott karakterláncot írja ki a képernyőre.
Fordítás, hibakeresés
Ha sikeresen begépeltük a forrásprogramunkat, mentsük el, és fordítsuk le.
Figyelem! Előtte állítsuk be a következőt: Jobb egérgombbal kattintsunk a Projekt ablakban található ElsoProgram projektünkre. A megjelenő menükből válasszuk ki a Set as Main Project opciót!

A fordítást a Run menüben, vagy az eszköztáron érhetjük el  , ahol kétféle lehetőség közül választhatunk. (Build Main Project, Clean and Build Main Project)
Az Output ablakban kapunk tájékoztatást a fordítás eredményéről, és az előforduló hibákról.


Futtatás
A sikeresen lefordított programot futtathatjuk.

A futás eredményét az Output ablakban tekinthetjük meg.


1.4.   Tesztkérdések
1.5.   Feladatok
1.5.1.  Töltsd le, telepítsd, és ismerkedjél a fejlesztőkörnyezettel! (megoldás)

2. hét    Nyelvi alapelemek
Tartalom:
    2.1. Karakterkészlet
    2.2. Szimbólikus nevek
        2.2.1. Azonosító
        2.2.2. Kulcsszó             
    2.3. Címke     
    2.4. Megjegyzések     
    2.5. Literálok   
     2.6. Változó 
    2.7. Tesztkérdések
    2.8. Feladatok

Ezen a héten a Java programozási nyelv alapelemeivel fogunk megismerkedni.

2.1. Karakterkészlet
A program forrásszövegének legkisebb alkotórészei a karakterek.
Az UNICODE 16 bites kódtáblára épül, ahol betű minden nyelv betűje lehet. Tartalmazza az összes nemzetközi abc-t. Megkülönbözteti a kis-és nagybetűt.
Kategóriák:
    •betűk (minden nyelv betűje)
    •számjegyek (0-9 decimális számjegy)
    •egyéb karakterek (műveleti jelek, elhatároló jelek, írás jelek, speciális karakterek)
2.2.   Szimbolikus nevek
2.2.1    Azonosító
Olyan karaktersorozat, amely betűvel kezdődik, és betűvel vagy számjeggyel folytatódhat. Arra használjuk, hogy a programozói eszközeinket megnevezzük vele, és ezután bárhol a program szövegében hivatkozhassunk rá. Betűnként nem csak a nemzeti karaktereket, hanem az _ és $ jelet is használhatjuk.
Azonosító képzési szabályok:
•Az azonosító bármilyen hosszú Javában használható unikód karaktersorozat lehet
•Egy azonosító nem kezdődhet számjeggyel, nem lehet kulcsszó, és nem lehet a nyelv egy előre definiált konstansa (true, false vagy null).
•Két azonosító csak akkor egyezik meg, ha unikód karaktereik rendre megegyeznek.
Példák az azonosítóra:
Szabályos Java azonosítók: Nem azonosítók:
x x+y
ár x*y+3
diak_kod 12öt
Néhány gyakorlati hasznos tanács az azonosítók készítéséhez:
•Próbáljunk meg jól olvasható, beszédes azonosítókat választani! (minSebesseg, karakterekSzama)
•Az osztályok azonosítóját nagybetűvel kezdjük. (Emberek,Diákok)
•A változók és metódusok azonosítóját kisbetűvel kezdjük. (szám, darab)
•A konstansokat csupa nagybetűvel írjuk. (ALAPAR)
•Az azonosítókat úgy tagoljuk, hogy az összetett szavak kezdőbetűit nagybetűvel, a többit kisbetűvel írjuk. (maxSebessegHatar)
2.2.2.    Kulcsszó
Olyan karaktersorozat, amelynek az adott nyelv tulajdonít jelentést, és ez a jelentés a programozó által nem megváltoztatható.
A java kulcsszavai a következők:
abstract default if package transient
boolean do implements private try
break double import protected void
byte else instanceof public volatile
case extends int return while
catch final interface short synchronized
char finally long static this
class float native super throw
continue for new switch throws
A const és a goto szintén foglalt szó, de nincs implementálva, egyik sem használatos.
2.3.   Címke
A végrehajtható utasítások megjelölésére szolgál, bármely végrehajtható utasítás megcímkézhető. Azért alkalmazzuk, hogy a program egy másik pontjáról hivatkozni tudjunk rá.
A címke egy azonosító, az utasítás előtt áll kettősponttal elválasztva.
Szintaktika:
cimke: {     }, vagy  cimke: utasítás
A címkét a break vagy a continue paranccsal  együtt használjuk úgy, hogy megadjuk a parancs után azt, hogy melyik egységre vonatkozik.
Példa:


2.4.   Megjegyzések
A megjegyzés olyan programozási eszköz, amely arra szolgál, hogy a program írója a kód olvasójának valamilyen információt szolgáltasson.
A megjegyzést a forrásszövegben háromféle módon helyezhetjük el:
•//-től sorvégig megjegyzés.
•/*    */ zárójelek között tetszőleges hosszan.
•/**    */ dokumentációs megjegyzés. A fejlesztőkörnyezet segítségével automatikusan lehet generálni hypertext (HTML) dokumentációt, ami felhasználja a dokumentációs megjegyzéseket is. (Run > Generate Javadoc (Projekt név))
Példa a megjegyzésekre:


2.5.   Literálok
A literál olyan programozási eszköz, amelynek segítségével fix, explicit értékek építhetők be a program szövegébe. Két komponense van: típus és érték.
Fajtái:
•egész: egy pozitív vagy negatív egész szám, vagy nulla.(pl. +200, -3, 1256987)
•valós: egy tizedesekkel leírható szám. Két formában adható meg: tizedes forma és lebegőpontos forma (pl. 6.32, 100.0, 0.0006, 6.3E2, 5E-4)
•logikai: két logikai konstans létezik, a true (igaz) és a false (hamis).
•karakter: egy unicode karakter (szimpla aposztrófok közé tesszük). (pl. 'a', 'B')
•szöveg: akármilyen hosszú, unicode karakterekből álló sorozat (idézőjelek közé tesszük).
(pl. "Szia")
•null
2.6.   Változó
A programok adatokon végeznek különféle manipulációkat, ezek az adatok a program futása alatt változtatják értéküket. A kezdeti adatokat a program eltárolja a változókba, az értékek az algoritmusnak megfelelően módosulnak a program futása folyamán. Az algoritmus végén a változó a végeredmény értékével rendelkezik.
A változó olyan adatelem, amely azonosítóval van ellátva. Az egyik legfontosabb programozási eszközünk.
A változókat használat előtt deklarálni kell. Ez azt jelenti, hogy meg kell adni a típusát, nevét, esetleg értékét is. Amikor egy változónak kezdeti értéket adunk, akkor a változót inicializáljuk.
pl. byte a; int x = 0;
Egy változót a program tetszőleges részén deklarálhatunk.
A változó érvényességi tartománya a programnak az a része, ahol a változó használható. A változódeklaráció helye határozza meg az érvényességi tartományt.
A változó lehet (A deklarálás helyétől függően.):
•tagváltozó: Az osztály vagy objektum része, az osztály egészében látható (alkalmazható). Az osztály változók deklarálásánál a static kulcsszót kell használni.
•lokális változó: Egy kódblokkon belül alkalmazzuk. A láthatósága a deklaráció helyétől az őt körülvevő blokk végéig tart.
•A metódusok formális paraméterei az egész metóduson belül láthatók.
•A kivételkezelő paraméterek hasonlók a formális paraméterekhez.
Példa a változókra:

A változót lehet véglegesen is deklarálni (konstans változó), a végleges változó értékét nem lehet megváltoztatni az inicializálás után.
A végleges változók deklarációnál a final kulcsszót kell használni:
pl. final int aKonstans = 0;

2.7.   Tesztkérdések
2.8.   Feladatok
2.8.1.    Jelenítsd meg a konzolon a "Holnap jó leszek!" szöveget.    (megoldás)
2.8.2.    Rajzolj egy vízszintes vonalat a konzolra.    (megoldás)
2.8.3.    Mi lesz a következő program outputja:

(megoldás)
2.8.4.    Rajzolj egy négyzetet a konzolra.    (megoldás)                                             
                                             
3. hét    Nyelvi eszközök
Tartalom:
    3.1. Kifejezések
        3.1.1. Operátorok
                3.1.1.1. Aritmetikai operátorok
                3.1.1.2. Relációs operátorok
                3.1.1.3. Logikai operátorok
                3.1.1.4. Léptető operátorok
                3.1.1.5. Értékadó operátorok
                3.1.1.6. Egyéb operátorok       
    3.2. Deklarációs és végrehajtható utasítások     
    3.3. Alprogramok
        3.3.1. Eljárás
        3.3.2. Függvény
    3.4. Blokk 
    3.5. Tesztkérdések
    3.6. Feladatok

3.1.   Kifejezések (operandusok és operátorok)
A kifejezések szintaktikai eszközök, arra valók, hogy a program egy adott pontján ismert értékekből új értékeket határozzunk meg. Két komponense van típus és érték.
Alapvetően kétféle feladata van: végrehajtani a számításokat, és visszaadni a számítás végeredményét.
Összetevők:
•Operandusok: Az értéket képviselik. Lehet literál, nevesített konstans, változó vagy függvényhívás az operandus.
•Operátorok: Műveleti jelek (pl. *,  /,  +,  -).
•Kerek zárójelek: A műveletek végrehajtási sorrendjét befolyásolják.
Példa a kifejezésre:
a + sin(0)
Operandus Operátor Operandus
Attól függően, hogy egy operátor hány operandussal végez műveletet, beszélhetünk:
•egyoperandusú (unáris pl. (+2)),
•kétoperandusú (bináris pl. (2+3)) vagy
•háromoperandusú (ternáris pl. (a*b*c)) operátorokról.
3.1.1.    Operátorok:
            (Az operanduson hajtanak végre egy műveletet.)
3.1.1.1.    Aritmetikai operátorok: Alapvető matematikai műveletek végzésére használjuk őket.

+    (összeadás),
-     (kivonás),
*    (szorzás),
/     (osztás),
%   (maradékképzés).
Példa az aritmetikai operátorok használatára:


Implicit konverzió: Amikor egy aritmetikai operátor egyik operandusa egész a másik pedig lebegőpontos, akkor az eredmény is lebegőpontos lesz. Az egész érték implicit módon lebegőpontossá konvertálódik, mielőtt a művelet végrehajtódna.
Példa: Egy egész számot osztunk egy valós számmal, a végeredmény automatikusan valós lesz.

A konverziót ki is "kényszeríthetjük" explicit konverzióval. A programozó ebben az esetben a kifejezés értékére "ráerőltet" egy típust.
Szintaxis:
(<típus>) <kifejezés>
Példa:
6/4  >> eredmény: 1 (Itt két egész számot osztottunk egymással.)
(double) 6/4  >> eredmény: 1.5
3.1.1.2.    Relációs operátorok: Összehasonlítanak két értéket, és meghatározzák a köztük lévő kapcsolatot.

>      (nagyobb),
>=    (nagyobb vagy egyenlő),
<      (kisebb),
<=    (kisebb vagy egyenlő),
= =   (egyenlő),
! =    (nem egyenlő).

Példa a relációs operátorok használatára:


3.1.1.3.    Logikai operátorok:

&&    (logikai és),
||      (logikai vagy),
!       (logikai nem),
&      (bitenkénti és),
|       (bitenkénti vagy),
^      (bitenkénti nem),
~      (Bitenkénti tagadás (negáció)).
Példa a logikai operátorok használatára:


3.1.1.4.    Léptető operátorok: A léptető operátorok bitműveleteket végeznek, a kifejezés első operandusának bitjeit jobbra, vagy balra léptetik.

<<    (op1 << op2; op1 bitjeit op2 értékével balra lépteti, jobbról nullákkal tölti fel)
>>    (op1 >> op2; op1 bitjeit op2 értékével jobbra lépteti, balról a legnagyobb helyértékű bitet tölt fel)
>>>  (op1 >>> op2; op1 bitjeit op2 értékével jobbra lépteti, balról nullákkal tölt fel)

3.1.1.5.    Értékadó operátorok

= Alap értékadó operátor, arra használjuk, hogy egy változóhoz értéket rendeljünk.

Rövidített értékadó operátorok: + =,  - =,  * =,  / =,  % =,  & =,  | =,  ^ =,  << =,  >> =, >>> =       (pl. i = i + 1; rövidítve: i + = 1;)

Példa az értékadó operátorok használatára:


3.1.1.6.    Egyéb operátorok:

? :     Feltételes operátor.
[ ]     Tömbképző operátor.
.        Minősített hivatkozás.
new   Új objektum létrehozása.

A kifejezés alakja lehet:
•prefix: Az operátor az operandusok előtt áll (* 2 5).
•infix: Az operátor az operandusok között áll (2 * 5).
•postfix: Az operator az operandusok mögött áll (2 5 *).
Azt a folyamatot, amikor a kifejezés értéke és típusa meghatározódik, a kifejezés kiértékelésének nevezzük. A kiértékelés során adott sorrendben elvégezzük a műveleteket, előáll az érték, és hozzárendelődik a típus.
A Javában a következő módon megy végbe a kiértékelés:
•Zárójelezéssel meghatározhatjuk, hogy egy kifejezés hogyan értékelődjön ki.
pl. (x + y) / 2 Először a zárójelben szereplő kifejezés hajtódik végre.
•Ha nem jelezzük, hogy milyen sorrendben akarjuk, az összetett kifejezést kiértékelni, akkor a sorrendet az operátorok precedenciája fogja meghatározni. A magasabb precedenciával rendelkező operátorok hajtódnak végre elsőként.
•pl. x + y / 2 Ebben a kifejezésben, mivel az osztás precedenciája magasabb mint az összeadásé, ezért először ez hajtódik végre, majd az összeadás következik. A következő kifejezés egyenértékű vele:
 x + (y / 2).
Operátor precedencia szintek:
postfix expr++  expr--
unáris ++expr  --expr  +expr  -expr  ~  !
multiplikatív *  /  %
additív +  -
léptetés <<  >>  >>>
relációs <  >  <=  >=  instanceof
egyenlőség = =   !=
bitenkénti és &
bitenkénti kizáró vagy ^
bitenkénti vagy |
logikai és & &
logikai vagy | |
feltételes ? :
értékadás =  +=  -=   *=   /=   %=   &=   ^=   |=   <<=   >>=  >>>=
A táblázat a Java platformon használt operátorok precedencia szintjeit mutatja be. Az operátorok precedencia szint szerint vannak rendezve, mégpedig úgy, hogy legfelül a legnagyobb precedenciájú, legalol a legkisebb precedenciájú található. Az azonos szinten elhelyezkedő operátorok azonos precedenciával rendelkeznek. Ha azonos precedenciájú operátorok szerepelnek egy kifejezésben, akkor balról jobbra történik a végrehajtás, kivéve az értékadó operátorokat, amelyek jobbról balra hajtódnak végre.
Azt a kifejezést, amelynek értéke fordítási időben eldől konstans kifejezésnek nevezzük. Létrehozására a final módosítót használjuk, így érjük el, hogy az adattag értékét nem változtathatja meg senki.
pl. final double PI: Pi értékét jelenti.
3.2.   Deklarációs és végrehajtható utasítások
A deklarációs utasítások mögött nem áll tárgykód. A programozó a névvel rendelkező saját programozási eszközeit tudja deklarálni.
pl. int i=10;
A végrehajtható utasításokból generálja a fordító a tárgykódot.
Melyek ezek?
•Üres utasítás (pl. ;)
•Kifejezés utasítás (pl. 8;  a = b;)
•Vezérlő utasítások (szekvencia, feltételes utasítás, többszörös elágaztatás, ciklusok, vezérlésátadó utasítások)
•Módszerhívások (metódushívások)
•Objektumot létrehozó kifejezések

3.3.   Alprogramok
A programot célszerű kisebb egységekre (alprogram) bontani, melyeket a program bizonyos pontjairól aktivizálhatunk. Így áttekinthetőbbé, olvashatóbbá válik a forrásprogram, valamint a többször előforduló tevékenységeket elegendő egyszer megírni (elkészíteni).
A Javaban metódusnak nevezzük az alprogramot. A metódus utasítások összessége, melyet meghívhatunk a metódus nevére való hivatkozással.
Egy metódus lehet eljárás vagy függvény aszerint, hogy van-e visszatérési értéke.
3.3.1.    Eljárás
Az eljárásnál nincsen visszatérési érték, egyszerűen végrehajtódik az eljárás nevére való hivatkozással. A végrehajtás után a program azzal az utasítással folytatódik, amelyik az eljárást meghívó utasítást követi. Az eljárás visszatérési típusa void (semleges), ami azt jelenti , hogy a visszatérési típus nincs definiálva.
Példa az eljárásra:
(Az eljárás egy vonalat "rajzol" a képernyőre.)

3.3.2.    Függvény
A függvénynél van visszatérési érték. A függvényt is egyszerűen a nevére való hivatkozással hívunk meg, de visszaad egy értéket, melyet a függvény neve képvisel.
Példa a függvényre:
(A függvény megduplázza az x változó értékét.)


3.4.   Blokk
A blokk nulla vagy több utasítás kapcsos zárójelek között, amely használható bárhol, ahol az önálló utasítások megengedettek.
Jellemzői:
•{ } zárójelek között szerepel.
•Címkézhető.
•Tetszőleges mélységben egymásba skatulyázható.
•A változó a blokk lokális változójaként deklarálható.
•A blokkon belül tetszőleges a deklarációs- és végrehajtható utasítások sorrendje.

3.5.   Tesztkérdések
3.6.   Feladatok
3.6.1.    Készíts egy eljárást, amely egy fenyőfát rajzol a konzolra. (megoldás)

3.6.2.    Készíts egy függvényt, amely összead két számot. (megoldás)

3.6.3.    Mi lesz a következő program outputja:
public class Feladat7{
    public static void main(String[] args) {
        int x=1;
        int y=4;
        System.out.println(x+"+"+y+"="+z);
    }
 }
(megoldás)
3.6.4.    Add meg a kifejezés  (a / 2) + 2 * b  zárójel nélküli alakját! (megoldás)

3.6.5.    Készíts programot, ami bemutatja a normál és a maradékos osztás közötti különbséget. (megoldás)
4. hét    Numerikus- és egyéb adattípusok
Tartalom:
    4.1. Egész és valós számtípusok
        4.1.1. Egészek
        4.1.2. Valós számok
    4.2. Egyéb típusok       
    4.3. Szám és szöveg közötti konvertálások
        4.3.1. Szövegből számmá konvertálás
        4.3.2. Számból szöveggé konvertálás
    4.4. A Math osztály
        4.4.1. Alapvető metódusok
        4.4.2. Hatványozással kapcsolatos metódusok
        4.4.3. Trigonometrikus függvények
        4.4.4. Véletlen szám készítés
    4.5. Tesztkérdések
    4.6. Feladatok

A Java nyelvben az adattípusoknak két fajtája van: primitív és referencia típusok. A primitív adattípusok egy egyszerű értéket képesek tárolni: számot, karaktert vagy logikai értéket.
Primitív típusok:
Egész típus
Valós típus
Karakter típus
Logikai típus Referencia típusok:
Tömb típus
Osztály típus
Interfész típus

4.1.   Egész és valós számtípusok
4.1.1.    Egészek
Típus Leírás Méret / formátum
byte bájt méretű egész 8 bit kettes komplemens  (-128 - 127)
short rövid egész 16 bit kettes komplemens (-32768 - 32767)
int egész 32 bit kettes komplemens (-2147483648 - 2147483647)
long hosszú egész 64 bit kettes komplemens
(-9223372036854775808 - 9223372036854775807)
4.1.2.    Valós számok
Típus Leírás Méret / formátum
float egyszeres pontosságú lebegőpontos 32 bit IEEE 754
double dupla pontosságú lebegőpontos 64 bit IEEE 754

4.2.   Egyéb típusok
Típus Leírás Méret / formátum
char karakterek 16 bit Unicod karakter
boolean logikai érték true vagy false

4.3.   Szám és szöveg közötti konvertálások
4.3.1.    Szövegből számmá konvertálás
Előfordulhat, hogy a sztringként rendelkezésre álló adatot számként kell kezelnünk. pl. A szöveges állományból beolvasott adatok sztringként állnak a rendelkezésünkre és ha szeretnénk velük valamilyen matematikai műveletet végezni, akkor át kell alakítani szám típusúvá.
Az átalakítást a valueOf metódussal tudjuk elvégezni.
Példa: (Két szöveg típusú változó számként történő összeadása.)


4.3.2.    Számból szöveggé konvertálás
Az a helyzet is előfordulhat, hogy a számból szövegbe konvertálásra van szükségünk. pl. A program által szolgáltatott szám értékeket szeretnénk egy szöveges állományba kiírni.
Az átalakítást a toString metódussal tudjuk elvégezni.
Példa: (Egy egész típusú szám számjegyeinek megszámlálása.)


4.4.   A Math osztály
Az alapvető aritmetikai számításokon (+, -, /, %) túl a Java nyelv biztosítja számunkra a Math osztályt. Az osztály metódusai magasabb rendű matematikai számítások elvégzését is lehetővé teszik. (pl. egy szög szinuszának a kiszámítása.)
A Math osztály metódusai osztály metódusok, így közvetlenül az osztály nevével kell őket meghívni.
pl. Math.abs(-32);
Nézzük meg a legfontosabb metódusokat!
4.4.1.    Alapvető metódusok:
double abs(double)
float abs(foat)
int abs(int)
long abs(long) abszolút érték
A kapott paraméter abszolút értékével tér vissza.
double ceil(double) felfelé kerekítés
A legkisebb double értékkel tér vissza, ami nagyobb vagy egyenlő a megkapott paraméterrel.
double floor(double) lefelé kerekítés
A legnagyobb double értékkel tér vissza, ami kisebb vagy egyenlő a megkapott paraméterrel.
double rint(double) a legközelebbi egészhez kerekít
A megkapott paraméterhez legközelebb álló double értékkel tér vissza.
long round(double)
int round(float) kerekítés
A legközelebbi long vagy int értéket adja vissza.
double min(double, double)
float min(float, float)
int min(int, int)
long min(long, long) A két paraméter közül a kisebbel tér vissza.
double max(double, double)
float max(float, float)
int max(int, int)
long max(long, long) A két paraméter közül a nagyobbal tér vissza.
A következő program bemutatja a fenti táblázatban ismertetett metódusok használatát:


4.4.2.    Hatványozással kapcsolatos metódusok:
double exp(double) A szám exponenciális értékével tér vissza.
double log(double) A szám természetes alapú logaritmusával tér vissza.
double pow(double, double) Az első paramétert a második paraméter értékével megadott hatványra emeli.
double sqrt(double) A megadott paraméter négyzetgyökével tér vissza.
A következő program bemutatja a fenti táblázatban ismertetett metódusok használatát:


4.4.3.    Trigonometrikus függvények:
double sin(double) Egy szám szinuszával tér vissza.
double cos(double) Egy szám koszinuszával tér vissza.
double tan(double) Egy szám tangensével tér vissza.
double asin(double) Egy szám arc szinuszával tér vissza.
double acos(double) Egy szám arc koszinuszával tér vissza.
double atan(double) Egy szám arc tangensével tér vissza.
double toDegrees(double) A paramétert fokká konvertálja.
double toRadians(double) A paramétert radiánná konvertálja.
A következő program bemutatja a fenti táblázatban ismertetett metódusok használatát:

4.4.4.    Véletlen szám készítés:
Gyakran szükségünk van véletlen számok előállítására, ezt a double random() metódussal tehetjük meg. A metódus egy véletlen számot ad [0.0;1.0[ intervallumban.

Példa:(Generáljunk egy véletlen egész számot 1-től 10-ig terjedő intervallumban.)

Figyeljük meg a bekeretezett kifejezést!
A random() metódus 0 és 1 közötti double típusú számot állít elő úgy, hogy a 0-t igen, de az 1-t soha nem veszi fel. Mi 1 és 10 közötti egész számot szeretnénk, ezért a véletlen számot meg kell szorozni 10-el és még hozzá kell adni 1-t is. Azt, hogy a végeredmény egész típusú legyen "ki kell kényszerítenünk" (int).

4.5.   Tesztkérdések
4.6.   Feladatok
4.6.1    Készíts programot, amely kiszámítja és kiírja az 5 egység sugarú kör kerületét és területét! (megoldás)

4.6.2.    Készíts programot, amely kiszámítja és kiírja a képernyőre a 30 fokos szög szögfüggvényeit! (megoldás)

4.6.3.    Készíts programot, amely 10-től 20-ig generál két véletlen egész számot! Majd kiírja a két szám összegét, valamint szorzatát.
 (megoldás)
4.6.4.    A következő sorok közül melyik fog hiba nélkül lefordulni?
    a)    byte a=256;
    b)    int i=10,
    c)    char c="a";
    d)    double d=1.33;
(megoldás)
4.6.5.    Készíts programot, ami ha megadunk két nem negatív számot sztring formátumban, akkor a kisebbik négyzetgyökét kiírja a képernyőre.(megoldás)
5. hét    Karakteres adattípusok
Tartalom:
    5.1. A Character osztály
        5.1.1. A Character osztály fontosabb konstruktorai, metódusai
    5.2. A String osztály
        5.2.1. String objektumok létrehozása
        5.2.2. Karakterlánc indexelése
        5.2.3. A String osztály fontosabb konstruktorai, metódusai
    5.3. StringBuffer osztály           
    5.4. Sztringekkel végezhető műveletek
        5.4.1. Szöveg hosszának meghatározása, adott karakter megjelenítése
        5.4.2. Manipulálás a szöveggel
        5.4.3. Összehasonlítás (egyenlőségvizsgálat)
        5.4.4. Keresés
        5.4.5. Konkatenáció (összefűzés)
        5.4.6. Bővítés
        5.4.7 Törlés
    5.5. Tesztkérdések
    5.6. Feladatok

Karaktereket definiálhatunk egyszerűen a char típus segítségével, ( pl. char a='a';) de létrehozhatunk karakter objektumokat is.
5.1.    A Character osztály
Az egyéb típusoknál ismertetett char típus helyett, van amikor szükségünk van arra, hogy a karaktert objektumként használjuk. pl. Amikor egy karakter értéket akarunk átadni egy metódusnak, ami megváltoztatja ezt az értéket. A Character típusú objektum egyetlen karakter értéket tartalmaz.
Készítsünk egy karakter objektumot! pl. Character a = new Character('a');
5.1.1. A Character osztály fontosabb konstruktorai, metódusai
Character(char) A Character osztály egyetlen konstruktora, amely létrehoz egy Character objektumot.
compareTo(Character) Összehasonlít két Character objektumban tárolt értéket. Visszaad egy egész számot, ami jelzi, hogy az objektum értéke kisebb, egyenlő, vagy nagyobb mint a paraméterben megadott érték.
equals(Object) Két karakter objektumot hasonlít össze, true értékkel tér vissza, ha a két érték egyenlő.
toString() Sztringé konvertálja az objektumot. A sztring 1 karakter hosszú lesz.
charValue() Megadja az objektum értékét egyszerű char értékként.
boolean isUpperCase(char) Meghatározza, hogy az egyszerű char érték nagybetű-e.
boolean isLowerCase(char) Meghatározza, hogy az egyszerű char érték kisbetű-e.
boolean isLetter(char) Meghatározza, hogy az egyszerű char érték ékezetes betű-e.
boolean isDigit(char) Meghatározza, hogy az egyszerű char érték számjegy-e.
boolean isSpaceChar(char) Meghatározza, hogy az egyszerű char érték szóköz-e.
A következő program bemutatja a fenti táblázatban ismertetett metódusok használatát:

A Java nyelvben három osztály áll rendelkezésünkre, amelyekkel tárolhatunk, illetve manipulálhatunk sztringeket, ezek a String, a StringBuffer és a StringBuilder. A StringBuilder osztállyal nem foglalkozunk. A String osztályban olyan sztringeket tárolunk, amelyek értéke nem fog változni. A StringBuffer osztályt akkor alkalmazzuk, ha a szövegen szeretnénk módosítani.
5.2.   A String osztály
5.2.1    String objektumok létrehozása
A String objektumok létrehozása kétféle módon történhet:
        •Készíthetjük a sztringet egy sztring konstansból, egy karaktersorozatból.
            pl. String str1 = "Ez egy szöveg";
        •Vagy mint minden más objektumot a new operátorral hozhatjuk létre.
            pl. String str2 = new String ("Ez is egy szöveg");
5.2.2.    A karakterlánc indexelése:
Figyeljük meg a következő ábrát!
0 1 2 3 4 5 6
S z ö v e g ?
Az ábrán egy "Szöveg?" objektum látható, amely egy 7 karakter hosszú szöveg (String). Az első betű az S indexe 0, a v betű indexe 3, a ? karakteré pedig a 6.
Figyeljünk arra, hogy az indexelés nullával kezdődik!

5.2.3.    A String osztály fontosabb konstruktorai, metódusai:
String() A létrehozott objektum az üres karakterláncot reprezentálja.
String(String value) A létrehozott objektum a paraméterben megadott szöveget tartalmazza.
int length() Visszaadja a szöveg hosszát.
char charAt(int index) Visszaadja az index indexű karaktert.
String toLowerCase() Visszaad egy objektumot, amely az objektum szövegének csupa kisbetűs változata.
String toUpperCase() Visszaad egy objektumot, amely az objektum szövegének csupa nagybetűs változata.
String toString() Visszaadja saját maga másolatát.
String replace(char oldChar,char newChar) A metósus visszad egy karakterlánc-objektumot, amelyben minden oldChar karaktert newChar-ra cserél.
String substring(int beginIndex) Visszaadja az objektum részláncát beginIndex-től a végéig.
String substring(int beginIndex,endIndex) Visszaadja az objektum részláncát beginIndex-től endIndex-1-ig.
boolean equals(Object anObject) Összehasonlítja az objektumot a paraméterként megadott másik objektummal.
boolean equalsIgnoreCase(String str) Összehasonlítja az objektumot a paraméterül megadott másik String objektummal. A kis- és nagybetű között nem tesz különbséget.
int compareTo (String str) Összehasonlítja az objektumot a paraméterül megkapott másik String objektummal. A visszaadott érték 0. ha a két objektum megegyezik. Ha a szöveg nagyobb mint a paraméter, akkor pozitív, ellenkező esetben negatív.
String concat (String str) Összefűzi a paraméterül megadott sztringet az objektummal.
(A + operátorral is el lehet végezni ezt a műveletet.)

5.3.   A StringBuffer osztály
A String osztállyal ellentétben a StringBuffer osztály szövege manipulálható.
A StringBuffer osztály fontosabb konstruktorai, metódusai:
StringBuffer() A létrehozott objektum az üres karakterláncot reprezentálja.
StringBuffer(int length) A létrehozott objektum az üres karakterláncot reprezentálja, kezdeti kapacitása length karakter.
StringBuffer(String str) A létrehozott objektum a paraméterben megadott szöveget tartalmazza.
int capacity() Megadja a kezdeti kapacitást, ennyi karakter fér az objektumba.
int length() Megadja a szöveg aktuális hosszát.
char charAt(int index) Visszaadja az index indexű karaktert.
StringBuffer append(<Type> value) Bővítés, a Type itt egy osztályt reprezentál.
StringBuffer append(<type> value) Bővítés, a type itt egy tetszőleges primitív típus.
StringBuffer insert( in offszet, <Type> value) Beszúrás offszet pozíciótól kezdve.
StringBuffer insert( in offszet, <type> value)
StringBuffer deleteCharAt(int index) Adott indexű karakter törlése a szövegből.
StringBuffer delete(int start, int end) Részlánc törlése a szövegből, start indextől end index-1-ig.
StringBuffer replace(int start, int end, String str) A start és end-1 közötti részlánc cseréje str-rel.
StringBuffer reverse() Megfordítja az objektum szövegét.
String substring (int start, int end) Visszaad egy start és end-1 index közötti részláncú új String objektumot.
String substring (int start) Visszaad egy start indexel kezdődő részláncú új String objektumot.

5.4.   Sztringekkel végezhető műveletek
5.4.1.    Szöveg hosszának meghatározása, adott karakterek megjelenítése:

int length()    >>    Szöveg hossza.
Példa:
String str="Laci";
int hossz=str.length();    >>    4

char charAt(int index)    >>     Adott indexű karakter.
Példa:
String str="Laci";
char c=str.charAt(0);    >>    L


5.4.2.    Manipulálás a szöveggel:

String toLowerCase()    >>    Kisbetűs átalakítás.
Példa:
String str="KICSI";
String kstr=str.toLowerCase();    >>    kicsi
String toUpperCase()    >>    Nagybetűs átalakítás.
Példa:
String str="nagy";
String nstr=str.toUpperCase();    >>    NAGY
String replace(char oldChar,char newChar)    >>    Karakterek kicserélése.
Példa:
String str1="Remek eme Mekk Mester";
String str2=str1.replace(e, a);    >>    Ramak ama Makk Mastar

String substring(int beginIndex)                >>    Részsztring készítés.
String substring(int beginIndex, int endIndex)

Példa:
String str1="Pálinka";
String str2=str1.substring(3);    >>    inka
String str3=str1.substring(0,3);  >>    Pál


5.4.3.    Összehasonlítás (egyenlőségvizsgálat):

boolean equals(Object anObject)   >>    Objektumok összehasonlítása.
int compareTo(String str)
Példa:
String str1="Laci";
String str2="Gizi";
str1.equals(str2);    >>    false
str1.compareTo(str2)  >>    5

Figyelem! Az = = operátor nem az egyenlőséget, hanem az azonosságot vizsgálja!
5.4.4.    Keresés:
int indexOf(int ch)   >>    Karakter keresés..
int indexOf(int ch, int fromIndex)

int indexOf(String str)    >>    részsztring keresés
int indexOf(String str, int fromIndex)
Példa:
String str1="Laci";
char c = 'a';
String str2="ci";
str1.indexOf(a);    >>    1
str1.indexOf(str2;0)  >>    2


5.4.5.    Konkatenáció (összefűzés):

String concat(String str)   >>    Hozzáfűzés.

Példa:
String str1="La";
String str2="ci";
str1.concat(str2);    >>    Laci

5.4.6.    Bővítés:
StringBuffer append(<Type|type> value)   >>    Bővítés a végén.

Példa:
StringBuffer szoveg = new StringBuffer("érték");
szoveg.append("12.3");    >>    érték12.3

StringBuffer insert(int offset,<Type|type> value)   >>   Bővítés adott pozíciótól.

Példa:
szoveg.insert(5, "=");    >>    érték=12.3


5.4.7.    Törlés:
StringBuffer deleteCharAt(int index)   >>   Adott indexű karakter törlése.
StringBuffer delete(int start, int end)    >>    Részlánc törlése.

Példa:
StringBuffer szoveg = new StringBuffer("Labdarugás");
szoveg.delete(5,10);    >>    Labda
szoveg.deleteCharAt(0)    >>    abda


5.5.   Tesztkérdések
5.6.   Feladatok
5.6.1.    Készíts programot, amely az "Indul a görög aludni" sztring tartalmát megfordítja és kiírja! (megoldás)

5.6.2.    Készíts programot, amely két adott sztringet megjelenít, az egyiket kisbetűs, a másikat nagybetűs formában! A második sztringben található összes 'e' karaktert kicseréli az első sztring második karakterével. (megoldás)

5.6.3.    Mi lesz a következő program outputja:

(megoldás)
5.6.4.    A következő sorok közül melyik fog hiba nélkül lefordulni?
        a)    "pá"+"linka"
        b)    3+"pá"
        c)    3+5
        d)    3+5.5
(megoldás)
5.6.5.    Adj meg egy valós számot. A számot úgy jelenítsd meg, hogy a tizedespont helyén egy tizedesvessző jelenjen meg! (megoldás)

6. hét    Elágaztató utasítások
Tartalom:
    6.1. Kétirányú elágaztató utasítás: if..else
    6.2. Többirányú elágaztató utasítás
        6.2.1. switch..case
        6.2.2. else..if
    6.3. Elágaztató utasítások egymásba ágyazása
    6.4. A billentyűzetről bevitt adatok vizsgálata
    6.5. Tesztkérdések
    6.6. Feladatok

A program készítése során adódnak olyan helyzetek, ahol a folyamatos utasítás végrehajtás menetét meg kell törnünk, feltételektől függő elágazásokat kell a programba beépítenünk. Így tudjuk megoldani azt a feladatot, hogy ez a program rész csak akkor kerüljön végrehajtásra, ha arra szükség van.
6.1.   Kétirányú elágaztató (feltételes) utasítás: if..else
Két alakjában használhatjuk: rövidalak, ha hiányzik az else ág , egyébként hosszúalakról beszélünk.
Szintaktika:
if(<feltétel>) <utasítás vagy blokk>    : rövidalak
[else <utasítás vagy blokk>]            : hosszúalak, a teljes utasítás
Működési elv:
Először kiértékelődik a feltétel.
Ha igaz, akkor végrehajtódik a feltétel utáni tevékenység és a program az if utasítást követő utasításon folytatódik.
Ha a feltétel nem igaz, akkor az else ágban megadott tevékenység hajtódik végre, majd a program az if utasítást követő utasításon folytatódik. Amennyiben nincs else ág, akkor ezt egy üres utasításnak vehetjük.
Példa:


6.2.  Többirányú elágaztató utasítás
Ha olyan feladattal állunk szemben, hogy több tevékenység közül egyet kell kiválasztanunk, akkor a többirányú elágaztató utasítást alkalmazzuk. A Javában ezt kétféle vezérlőszerkezettel tehetjük meg:switch..case és az else..if.
6.2.1    switch..case
Főleg akkor használjuk, ha egy kifejezés jól meghatározott, különböző értékeire szeretnénk bizonyos utasításokat végrehajtani.
Szintaktika:
switch(<kifejezés>){
    case <konstans kifejezés> : <utasítás vagy blokk>
    [case <konstans kifejezés> : <utasítás vagy blokk>]
    ...   
    [default:<utasítás v. {blokk}>]
}
Működési elv:
Először kiértékelődik a kifejezés.
A kifejezés értéke a felírás sorrendjében összehasonlításra kerül a case ágak értékeivel.
Ha van egyezés, akkor végrehajtódik az adott ágban megadott tevékenység, majd a program a következő ágakban megadott tevékenységeket is végrehajtja.
Ha nincs egyezés, akkor a default ágban megadott tevékenység hajtódik végre.
Példa:

Output:


Ha rögtön ki szeretnénk lépni a switch utasításból az adott tevékenység végrehajtása után, akkor külön utasítást kell alkalmaznunk (break).
Példa:

Output:


6.2.2.    else..if

Szintaktika:

if (<feltétel1>)
    <utasítás . blokk>
else if (<feltétel2>)
    <utasítás v. blokk>
...
else
    <utasítás v. blokk>
A működési elvet az alábbi példa szemlélteti:

A forráskód az előző példában (Menu1) ismertetett végeredményt szolgáltatja. A két kód futtatásának eredménye egyenértékű egymással. A programozótól függ, hogy melyiket használja az adott feladat megoldása során.

6.3.   Elágaztató utasítások egymásba ágyazása
Az elágaztató utasítások tetszőlegesen egymásba ágyazhatók. A program áttekinthetősége érdekében célszerű a forrásprogram szerkezetét jól strukturáltan elkészíteni.
Figyeljünk a "csellengő else"-re! Mit is jelent ez? Ha rövid if-utasításokat írunk, akkor az else-utasítás vajon melyik if-hez tartozik? A Java azt mondja, hogy a legutóbbi if-hez , ha csak blokkok képzésével felül nem bíráljuk ezt.
A probléma másik megoldása az, hogy mindig hosszú if-utasításokat alkalmazunk.
Nézzük végig példákon keresztül az fent említett eseteket!
(Azt vizsgáljuk, hogy az adott szám belül van-e egy tartományon ([100;1000]) és, ha ott  van, akkor páros vagy páratlan?)
Megtévesztő kód: (Strukturálatlan, hova tartozik az else?)

A kód helyesen strukturálva:

Alakítsuk át úgy, hogy az első if-hez tartozzon az else:

Blokk készítésével oldottuk meg ezt a feladatot.
Próbáljuk meg hosszú if-utasításokkal!


6.4.  A billentyűzetről bevitt adatok vizsgálata
A programok készítése során gyakran kerülünk olyan feladat elé, amikor a programnak a továbbhaladáshoz szüksége van a felhasználó beavatkozására, adatokat vár a billentyűzetről. pl. Menü rendszernél a felhasználó választásától függően fog a vezérlés a megfelelő programrészre kerülni.
Hogyan olvassuk be az adatokat a billentyűzetről? Az adatok kezelésével a 9. héten fogunk foglalkozni részletesen, most elégedjünk meg egy kis programrészlettel, aminek a segítségével megoldható a beolvasás problémája.
A kódot másoljuk be a programunkba, a kívánt helyre!
Scanner sc=new Scanner(System.in);
    System.out.println("Kérem a számot!");
    int a=sc.nextInt();
Ne feledkezzünk meg a Scanner osztály importálásáról!
Kattintsunk balgombbal a lámpácskára és válasszuk az Add import for java.util.Scanner opciót:

Példa: (A program a felhasználó választásától függő darabszámú csillagot jelenít meg.)


6.5.   Tesztkérdések
6.6.   Feladatok
6.6.1.    Készíts programot, amely bekér egy számot, majd kiírja, hogy osztható-e 2-vel vagy 3-mal! (megoldás)
6.6.2.    Készíts programot, amely bekér két számot és kiírja, hogy melyik a nagyobb illetve ha egyenlők, akkor azt. (megoldás)
6.6.3.    Készíts programot, ami generál két véletlen egész számot [0;100] intervallumban. A nagyobbik számból vonja ki a kisebbet, és írja ki a végeredményt. (megoldás)
6.6.4.    Készíts programot, ami egy számformátumban megadott érdemjegyet szövegesen jelenít meg! Az érdemjegyet a billentyűzeten kell bevinni! (pl. 1 = elégtelen; 2 = elégséges; stb.) (megoldás)
6.6.5.    Készíts programot, ami bekéri egy bankbetét összegét, valamint azt, hogy hány hónapig lesz lekötve az összeg. Majd megjeleníti, hogy mennyi lesz a betét összege a lekötés végén, ha a kamat évi 12%! (megoldás)

7. hét    Ciklusszervező utasítások
Tartalom:
    7.1. Előfeltételes ciklus: while
    7.2. Előfeltételes ciklus: for   
    7.3. Végfeltételes ciklus: do .. while
    7.4. Ciklusok egymásba ágyazása
    7.5. Alapvető algoritmusok
        7.5.1. Megszámlálás
        7.5.2. Összegzés, átlagszámítás
        7.5.3. Minimum- és maximum kiválasztás
    7.6. Tesztkérdések
    7.7. Feladatok
Ha egy bizonyos tevékenységet a programban egymásután többször végre kell hajtani, akkor ciklusokat alkalmazunk. A ciklusok végrehajtását, vagy az abból való kilépést feltételekhez kötjük.
Egy ciklus általános felépítése:
                •fej
                •mag
                • vég
Az ismétlésre vonatkozó információk vagy a fejben vagy a végben találhatók.
A magban helyezzük el azokat az utasításokat, amelyeket többször végre akarunk hajtani.
A ciklusok működése során két szélsőséges esettel is találkozhatunk:
                •Üres ciklus: A ciklusmag egyszer sem fut le.
                •Végtelen ciklus: Az ismétlődés soha nem áll le.
7.1.   Előfeltételes ciklus: while
Szintaktika:
while (feltétel)
    <utasítás v. blokk>
Működési elv:
A program a ciklusba való belépés előtt megvizsgálja a feltételt (belépési feltétel), és ha ez teljesül, akkor a ciklusmag végrehajtásra kerül, egyébként nem. Ennél a ciklus fajtánál kialakulhat üres ciklus, abban az esetben, ha a belépési feltétel soha nem teljesül.
Példa: (Írjunk ki a konzolra egymásmellé 6 db csillagot!)


7.2.   Előfeltételes ciklus: for
Szintaktika:
for (inicializálás;feltétel;növekmény)
    <utasítás v. blokk>
Működési elv:
inicializálás: Itt deklaráljuk a ciklusváltozót, és adjuk meg annak kezdeti értékét.
feltétel: Belépési feltétel, minden ciklus elején kiértékelődik, ha igaz, akkor a ciklus végrehajtásra kerül, egyébként a vezérlés a for utáni utasításra ugrik.
növekmény: Itt változtatjuk meg a ciklusváltozó értékét.
Példa:

A for fejének tagjai hagyhatók üresen is, de a pontosvesszőket ki kell tenni. pl. for(;;)...

7.3.   Végfeltételes ciklus: do..while
Szintaktika:
do
    <utasítás v. blokk>
while (feltétel);
Működési elv:
A ciklus magja egyszer mindenképpen végrehajtódik, majd a ciklus végén, egy feltételvizsgálat következik, amely eldönti, hogy bent maradunk-e a ciklusban, vagy nem. Ha a feltétel igaz, akkor a ciklusmag újból végrehajtásra kerül. Ez a folyamat addig folytatódik, amíg a feltétel hamissá nem válik (bennmaradási feltétel).
Üres ciklus a végfeltételes ciklusnál nem fordulhat elő, hiszen a ciklus magja legalább egyszer lefut.
Példa:

Az előző három ciklus mindegyike ugyanazt a feladatot oldotta meg, kirajzolt 6 db csillagot a képernyőre.

7.4.   Ciklusok egymásba ágyazása
A ciklusainkat egymásba is ágyazhatjuk.
Nézzünk meg egy egyszerű példát két ciklus egymásba ágyazására!
Példa:(Jelenítsük meg a konzolon következő alakzatot: ********************
                                                                              ********************
                                                                              ********************)
Forrásprogram:

A program elemzése:
A csillagok egy 3 soros, 20 oszlopos táblázatot alkotnak. A kirajzolást úgy tudjuk egyszerűen elképzelni, mintha a táblázat celláiba helyeznénk el a csillagokat.
A külső ciklusban megyünk végig a sorokon, a belső ciklusban pedig az oszlopokon. Először az 1. sor elemeit jelenítjük meg egymásután, majd a 2. sor elemeit, és végül a 3. sor következik. Ha egy teljes sort megjelenítettünk, akkor meg kell oldani a sorváltás problémáját. Ezt egyszerűen egy println("") utasítással is megtehetjük.
7.5. Alapvető algoritmusok
7.5.1. Megszámlálás
Ezzel az algoritmussal egy sorozat, adott tulajdonsággal rendelkező elemeit számoljuk meg.

Az algoritmus menete a következő:
1.    A számlálót nullára állítjuk.
2.    Végig lépkedünk a sorozat elemein és ha az aktuális elem tulajdonsága megegyezik az adott tulajdonsággal, akkor a számláló értékét egyel megnöveljük.
3.    Megjelenítjük a számláló értékét, ez a szám adja az adott tulajdonsággal rendelkező elemek számát.
Példa: ("Ma süt a nap." sztringben megszámoljuk az 'a' karakterek számát.)




7.5.2. Összegzés, átlagszámítás
Az olyan feladatokat, amelyekben a sorozat elemeit valamilyen módon gyűjtenünk kell (pl. göngyölítés) összegzéses feladatoknak nevezzük. Ebbe a feladatcsoportba sorolható a különbség-, illetve a szorzatképzés is.

Átlag kiszámításakor egyszerre két dolgot is végzünk - összegzünk, s közben számlálunk is. Végül a két érték hányadosát vesszük.
Példa: (Addig olvassuk be a számokat, amíg 0-t nem ütünk, majd írjuk ki a számok összegét és átlagát!)

Figyelem: Az átlag számításakor vigyázni kell a 0-val való osztásra!

7.5.3. Minimum- és maximum kiválasztás
Minimumkiválasztás esetén a sorozat legkisebb, maximumkiválasztás esetén a sorozat legnagyobb elemét kell meghatároznunk.
Az algoritmus menete a következő:
1.    A sorozat első elemét elhelyezzük egy minimum(maximum) változóba.
2.    Sorban végig lépkedünk az elemeken és ha az adott elem kisebb(nagyobb) a minimum(maximum) változóban lévőnél, akkor a változóba lévő elemet kicseréljük vele.
3.    Megjelenítjük a változóban található elemet, ez az elem lesz a sorozat minimuma(maximuma).

Példa: (A program bekér 5 db valós számot, majd megjeleníti a legkisebbet!)


7.6.    Tesztkérdések
7.7.    Feladatok
7.7.1.    Készíts programot, amely egymás alá hússzor kiírja a "Jó napot kívánok!" szöveget! (megoldás)
7.7.2.    Készíts programot, amely 1-től 10-ig kiírja egymásmellé, vesszővel elválasztva a számok négyzetét! (megoldás)
7.7.3.    Írjál programot, ami 50 db kockadobást szimulál, és kiírja a dobásokat egymás mellé, szóközzel elválasztva! (megoldás)
7.7.4.    Írjuk ki az 1-200 közötti számok közül azokat az 5-tel oszthatóakat, amelyek nem oszthatók 25-tel! (megoldás)
7.7.5.    Kérd be n értékét és készítsd el az alábbi n soros háromszöget!
minta:
1
1    2
1    2    3
.     .     .
1    2    3    n
(megoldás)

8. hét    Tömbök
Tartalom:
    8.1. Tömbök deklarálása, kezdőértékük beállítása
    8.2. Tömbelemek elérése     
    8.3. Tömb méretének meghatározása
    8.4. Objektumtömbök
    8.5. Tömbök tömbjei
    8.6. Tesztkérdések
    8.7. Feladatok

A tömb egy olyan változó, amely több azonos típusú adatot tartalmaz. A tömb hossza a létrehozáskor dől el, és attól kezdve a tömb egy állandó méretű adatszerkezet.
A tömböket egy fiókos szekrényhez lehetne hasonlítani, amelyekben az egyes fiókokban egy-egy adatot helyezünk el. A fiókokra a sorszámukkal (A tömbben elfoglalt helye.) hivatkozunk. A sorszámozást nullával kezdjük! Ha valamelyik fiók tartalmára szükségünk van, akkor megadjuk, hogy hányadik fiókról van szó és kiolvassuk a tartalmát.
Példa: (Ha szükségünk van a 100-as számra, akkor a 3-as indexű fiókot kell "kihúzni"!)
0 1 2 3 4 5 6 7 8 9
10 2 34 100 1 0 5 67 76 99

Lehetőségünk van arra is, hogy olyan tömböket hozzunk létre, amelyek tömböket tartalmaznak (tömbök tömbjei).
8.1.   Tömbök deklarálása, kezdőértékük beállítása
A tömb deklarálása a többi váltózóéhoz hasonlóan két részből áll: meg kell adni a tömb típusát és a tömb nevét.
Szintaktika:
<elemtípus>[] <tömbAzonosító>;        pl. int[] szamok;
A [] tömbképző operátort a tömbAzonosító után is tehetjük.
<elemtípus> <tömbAzonosító>[];   pl. int szamok[];
A deklarálás során nem hoztuk még létre a tömböt, egyelőre csak a referenciának (memóriacímnek) foglaltunk helyet. A tömböt a Javában külön létre kell hozzuk a new operátorral!
Szintaktika:
new elemtípus[<méret>];
pl. new int [10];//Itt egy olyan integer típusú adatelemeket tartalmazó tömböt hoztunk létre, amely 10 db elemet tartalmaz.
A deklarációt és a létrehozást egy lépésben is elvégezhetjük.
Például:
int szamok[]  = new int[10] ;
A deklarálás során (inicializáló blokkal) a tömb elemeinek kezdeti értékek is adhatók.
Szintaktika:
<elemtípus>[] <tömbAzonosító> = {<érték0>, <érték1>, ...};
pl. Készítsünk egy String típusú tömböt, amely a hét napjait tartalmazza!
String[] napok = {"Hétfő","Kedd","Szerda","Csütörtök","Péntek","Szombat", "Vasárnap"};

8.2.   Tömbelemek elérése
A tömb egyes elemeire az indexükkel hivatkozhatunk.
Szintaktika:
<tömbAzonosító>[index];
 pl. szamok[3] = 2; // A 4. fiókba (3-as indexű) betettük a 2-es számot.
8.3  Tömb méretének meghatározása
Minden tömb objektumnak van egy length konstansa, amely megadja a tömb hosszát.
(Egyszerűen azt, hogy hány adat található meg benne?)
tömbAzonosító.length
pl. (A napok tömbnél, amely a hét napjait tartalmazza.)
System.out.println(napok.length); >> 7

8.4.   Objektumtömbök
A tömbökben tárolhatunk referencia típusú elemeket is. A létrehozásuk olyan mint a primitív típusú elemeket tartalmazó tömböké.
Nézzünk meg egy egyszerű példát, ahol a tömbben három String objektumot tárolunk:


A tömb elemeinek a bejárásához használhatunk egy speciális programozói eszközt, az un. for-each ciklust.
Szintaktika:
for(<típus> <változó> : <objektum>)
        <utasítás vagy blokk>
Példa:


8.5.   Tömbök tömbjei
A tömbök tartalmazhatnak tömböket, tetszőleges mélységben egymásba ágyazva.
Szintaktika:
Deklarálás: <elemtípus>[][] ... [] <tömbAzonosító>;
Létrehozás: new <elemtípus> [méret0][méret1]...[méretn-1];
Tömb elemeinek elérése: <tömbAzonosító> [index0][index1]...[indexn-1]
Példa: (Egy tömbben elhelyezünk másik 3 tömböt.)

Ezt úgy képzelhetjük el a legegyszerűbben, mintha egy "három soros két oszlopos táblázatban" helyeznénk el az adatokat:
Egy Megérett a meggy.
kettő Csipkebokor vessző.
Három Te leszel a párom.
Írjuk ki a konzolra a tömbből a "Te leszel a párom szöveget"!

A megadott szöveg a "táblázat" 3. sorának 2. oszlopában található, az indexelése pedig a következő lesz [2] [1].
Figyelem: Ne felejtsük el, hogy az indexelés 0-val kezdődik!

8.6.   Tesztkérdések
8.7.   Feladatok
8.7.1    Írjál programot, amely a következő tartalmú tömböt hozza létre, majd ki is írja a képernyőre!
        0    1    2
        3    4    4
        0    0    0 (megoldás)
8.7.2    Készíts programot, amely egy 20 elemű tömböt feltölt 'a' karakterekkel, majd a tömb minden 2. elemét kicseréli 'b' karakterre, majd kiírja egymásmellé az elemeket, szóközzel elválasztva! (megoldás)
8.7.3    Készíts programot, amely feltölt 1-től 10-ig véletlen valós számokkal egy 6x6-os tömböt, majd megjeleníti a tömb tartalmát! Írja ki a program a számok átlagát is! (megoldás)
8.7.4.    Írjál programot, amely az 5x5-ös egységmátrixot hozza létre!
(Az egységmátrixban a főátlóbeli elemek 1-t, míg az ezen kívüli elemek 0-t tartalmaznak.)
minta:
  (megoldás)
8.7.5.    Készíts programot, amely bekér a billentyűzetről 5 db számot és elhelyezi egy megfelelő tömbben! A program írja is ki a tömb tartalmát a képernyőre, valamint jelenjen meg külön a legkisebb szám is. (megoldás)

9. hét    Input-output műveletek

Tartalom:
    9.1. Egyszerű konzol I/O műveletek
    9.2. Karakteres fájlok kezelése
        9.2.1. Karakteres fájlok olvasása
        9.2.2. Karakteres fájlok írása
    9.3. Bináris fájlok feldolgozása
    9.4. Szöveges állományok kezelése
    9.5. Állományok közvetlen elérése
    9.6. Tesztkérdések
    9.7. Feladatok

9.1. Egyszerű konzol I/O műveletek
    Minden programozási nyelv alapfeladatai közé tartozik a külvilággal való kommunikáció, amely a legtöbb esetben az adatok olvasását jelenti egy bemeneti eszközről (pl. billentyűzet), ill. az adatok írását egy kimeneti eszközre (pl. képernyő, fájl). A Java nyelv az i/o műveleteket adatfolyamokon (ún. streameken) keresztül, egységesen valósítja meg. Egy dologra kell csak figyelni, hogy bemeneti vagy kimeneti csatornát kezelünk-e. A csatornák kezelése Java osztályokon keresztül valósul meg, azonban ezek nem részei a Java alap eszközkészletének, ezért importálni kell őket a java.io csomagból.
    A konzol kezelésére a Java három adatfolyamot biztosít. Ezeket az adatfolyamokat nem kell megnyitni vagy bezárni, e műveletek automatikusan történnek.
    A standard adatfolyamok a következők:
standard bemenet: System.in
standard kimenet: System.out
standard hiba: System.err

    A konzol I/O műveletek használata esetén a java.util csomagból importálnunk kell a megfelelő osztályokat.
    Az alábbi kis egyszerű program a standard be- és kimeneti konzol használatát mutatja be.  A program egy egész számot vár a billentyűzetről, amit utána megjelenít a képernyőn:
  Forráskód: io1.java

    Az sc nevű objektum a Scanner osztály példánya lesz, amely osztály a beolvasáshoz a System.in (billentyűzet input) paramétert használja. Az egész típusú a adattag az sc példány nextInt() metódusa által megkapja a beírt számot, a standard System.out.println() metódus pedig megjeleníti a képernyőn.
    Több szám bevitele esetén a számok közé alapesetben szóközöket kell beiktatni, amely jel a Java-ban felülbírálható.  Az alábbi program az előző továbbfejlesztése. Több (akárhány!) egész számot vár - vesszővel elválasztva - a billentyűzetről, majd kiírja a darabszámukat és az összegüket:
  Forráskód: io_token.java

    Ebben az esetben a teljes input sort beolvassuk a sor nevű stringbe, majd a StringTokenizer osztály segítségével a megadott határolójel mentén adategységekre (tokenekre) feldarabolva feldolgozzuk azt. Nézzünk egy programfutási eredményt is:


9.2. Karakteres fájlok kezelése
    A Java a fájlokat is streamként kezeli, ezért most is importálni kell a java.io csomag néhány osztályát. Az i/o típusok karakteresek (a Java az UTF-8-as Unicode karakterkódolást használja) és binárisak(8 bites bájtformátum) lehetnek.
    A karakteres állományok kezelését három fő részre osztjuk:
megnyitás
műveletek
lezárás
     A megnyitás művelete során valamely stream osztály objektuma jön létre (példányosítással), amelyhez hozzárendeljük a megnyitandó állományt. A fájlkezelő műveleteket try-catch-finally kivételkezelő blokkszerkezetbe kell foglalni, mert sok probléma adódhat használatuk során (pl. nem létező állomány, betelt háttértár, stb.). A következő példaprogramok mindegyikében lesz ilyen szerkezet, de a jobb áttekinthetőség miatt e forráskódok csak a minimálisan kötelező kivételkezelést tartalmazzák. A kivételkezelésről bővebben a 14. heti tananyagban lesz szó.

9.2.1. Karakteres fájlok olvasása
    Karakteres állományok olvasására a FileReader osztály read() metódusa áll rendelkezésre. A metódus használatához implementálni kell a FileNotFoundException (a fájl nem található) kivételkezelő osztályt, és ennek ősét, az IOException (általános i/o hiba) osztályt is.
    A következő példa egy szöveges állományból egyenként beolvassa a karaktereket, majd megjeleníti őket a képernyőn. Ha nem jelölünk ki pontos elérési utat, akkor a fájlnak a Java projekt főkönyvtárában kell lennie. A fájl végét a -1-es értékkel érzékeli a read() metódus.
  Forráskód: io.java

     A forrásállomány (szoveg.txt, letöltés után nevezzük át szöveg.txt-re!) az UTF-8-as Unicode kódolású szöveg mentését is lehetővé tevő Jegyzettömb programmal készült. A 2. és 3. sorban használt kis- és nagybetűs tesztszövegben (árvíztűrő tükörfúrógép) minden magyar ékezetes betű szerepel, így könnyen ellenőrizhető a fájlkezelő metódusok betűhelyes működése.
    A forrásállomány Jegyzettömb által mutatott tartalma :


    A képernyőn megjelenő szöveg:


9.2.2. Karakteres fájlok írása
    Karakteres állományok írására a FileWriter osztály write() metódusa áll rendelkezésre. Ehhez a metódushoz az IOException (általános i/o hiba) osztályt kötelező implementálni.
    Az alábbi program egy string típusú változóban tárolt kétsoros szöveget - karakterenként feldolgozva - ír ki egy szöveges állományba. Ha nem jelölünk ki pontos elérési utat, akkor a fájl a Java projekt főkönyvtárában jön létre. Mivel könnyen lekérdezhető a string hossza, a karakterek feldolgozása nem okoz gondot.
  Forráskód: io2.java

    Nézzük a létrejött állomány (mentes.txt, eredeti neve mentés.txt) tartalmát! Szerencsére a fájlba írás karakterkódolásával semmi gond, és a Jegyzettömb is helyesen jeleníti meg:


9.3. Bináris fájlok feldolgozása
    A bináris adatokat tartalmazó állományok kezelését a FileInputStream és a FileOutputStream osztályok biztosítják. Mindkét osztályt importálni kell a java.io csomagból. Metódusaik a szokásos read(), write() és close(). Használatuk hasonló a karakteres állományoknál látottakhoz.
    Hozzunk létre egy binary.dat nevű bináris állományt! Bájtjainak értéke decimálisan 65-től 90-ig terjedjen!
  Forráskód: io_bin.java

    Bővítsük előző programunk Main metódusát! A keletkezett állományt olvassuk be, és írjuk ki a bájtjai által reprezentált karaktereket a képernyőre szóközzel elválasztva! Ne feledjük, hogy az importáló utasításokat bővíteni kell a java.io.FileInputStream osztállyal!
  Forráskód: io_bin.java

    A képernyőn a várt eredmény látható:


9.4. Szöveges állományok kezelése
    Szöveges állományok feldolgozása gyakran nem karakterenként, hanem nagyobb részenként, pl. soronként történik. Ehhez a Java ún. pufferelt fájlkezelési támogatást nyújt. Külön osztályok támogatják a byte- és string-szintű műveleteket:
Byte-szintű osztályok:
BufferedInputStream (olvasás)
BufferedOutputStream (írás)
PrintStream (írás)
String-szintű osztályok:
BufferedReader (olvasás)
PrintWriter (írás)
    Számunkra most a stringek kezelése fontosabb, ezért nézzünk rá egy egyszerű példát! Írjunk ki egy sima szöveges állományba (text.txt) néhány UTF-8-as kódolású sort, majd az állományt visszaolvasva jelenítsük meg azokat a képernyőn is!
    Írás a PrintWriter osztály println() metódusával:
  Forráskód: io_txt.java

    Olvasás a BufferedReader osztály readLine() metódusával:
  Forráskód: io_txt.java

    Figyeljük meg, hogy a BufferedReader osztály nem tud egy fájlt közvetlenül megnyitni, hanem csak a FileReader osztály egy példányát. Az eredmény meggyőző:


9.5. Állományok közvetlen elérése
    Az előző alfejezetek adatfolyam-kezelő műveletei mind soros hozzáférésűek voltak, tehát az állományok írása ill. olvasása az elejüktől a végükig sorban történt. Azonban lehetőség van arra is, hogy egy fájl tartalmához közvetlenül is hozzáférhessünk. Ezt a java.io csomag RandomAccessFile osztálya biztosítja. Ez az osztály egyszerre alkalmas olvasásra és írásra is, csupán a példányosítás során egy paraméterrel jelezni kell, hogy milyen műveletet kívánunk alkalmazni az objektumra:
csak olvasás: RandomAccessFile("input.txt", "r")
olvasás+írás: RandomAccessFile("input.txt", "rw")
    Az így megnyitott állományokon használhatók a szokásos read() és write() metódusok, valamint a közvetlen elérést támogató metódusok:
void seek(long pos): megadott pozícióra ugrás a fájl elejétől
int skipBytes(int n): aktuális pozíció mozgatása n bájttal
long getFilePointer(): aktuális pozíció lekérdezése
    Fontos tudni, hogy a read() és write() metódusok meghívása a fájlmutató (aktuális pozíció a fájlon belül - file pointer) értéket automatikusan megnöveli 1 egységgel, tehát nem szükséges manuálisan léptetni. Ezek a metódusok és a close() (fájl bezárása) is megkövetelik az IOException kivételkezelő osztály használatát.
    Hozzunk létre egy állományt (random.txt), amely az angol ABC nagybetűit tartalmazza!
  Forráskód: io_random.java

    Majd minden ötödik karaktert - a fájlban elfoglalt pozíciójukkal együtt - jelenítsük meg a képernyőn!
  Forráskód: io_random.java

    A raf.length() metódussal lehet lekérdezni a fájl méretét. Figyeljük meg, hogy a kiírás során a getFilePointer() pozíciólekérdező metódus megelőzi az olvasó metódust, így a helyes értéket adja, de mégis meg kell növelni az értékét 1-gyel, mivel a pozíciók számozása 0-tól kezdődik. Az eredmény:


    A kimenet utolsó sorát az alábbi kiegészítés állítja elő. A fájl minden ötödik karakterét cseréljük le annak kisbetűs változatára, majd jelenítsük meg a fájl összes karakterét!
  Forráskód: io_random.java

    A betűcserét végrehajtó ciklus minden ötödik betűre pozícionál, majd az ott található betű kódjához 32-t adva éri el, hogy kisbetű lesz belőle. A kiolvasás eltolja az aktuális pozíciót, ezért szükséges visszalépni egyet. A betűk képernyőn való megjelenítését megelőzi a fájl kezdőpozíciójába ugrás, majd egy sima (fájlvégjel-figyeléses) feldolgozó ciklus kiírja a karaktereket.

9.6. Tesztkérdések

9.7. Feladatok
9.7.1. Kérjünk be két egész számot a billentyűzetről, és írjuk ki a képernyőre a szorzatukat!
Megoldás

9.7.2. A FileWriter és a FileReader osztályok segítségével írjuk ki az abc.txt fáljba az angol abc kisbetűit! Utána olvassuk be a fájlt, és az abc-t - nagybetűsre alakítva - írjuk ki a képernyőre!
Megoldás

9.7.3. A PrintWriter és a BufferedReader osztályokat felhasználva írjuk ki a hét napjait soronként a napok.txt szöveges fájlba! Ezután olvassuk be a fájlt, és a napokat egy sorban, vesszővel elválasztva jelenítsük meg a képernyőn!
Megoldás

9.7.4. A RandomAccessFile osztály metódusai segítségével cseréljük le az abc.txt fájl minden 3. betűjét nagybetűsre, majd a teljes fájlt írjuk ki a képernyőre!
Megoldás




10. hét    Érettségi feladatok megoldása

Tartalom:
    10.1. Foci
    10.2. Robot
    10.3. Tesztkérdések
    10.4. Feladatok

    Az alábbiakban két emelt szintű érettségi feladatot fogunk megoldani. Az eddig tanultak elegendő nyelvi eszközt biztosítanak minden részfeladat megoldásához. Nagyban megkönnyíti a munkánkat az a fontos körülmény, hogy sem az inputállományok, sem a felhasználó által bevitt adatok helyességét ill. érvényességét nem kell ellenőrizni. Így lényegesen csökken a kódolási idő, de meg kell jegyezni, hogy a valóságban az ilyen programok használhatósága nagyban korlátozott.
    A feladatok megoldása fájlműveleteket is igényel, amelyek metódusai megkövetelik a kivételkezelést, ezért a programok main metódusának fejében a throws IOException záradékkal a kivételeket "továbbdobjuk" a Java futtató rendszere felé.

10.1. Foci
    Első érettségi feladatunk lényege a következő: egy labdarúgó-bajnokság mérkőzéseinek adatait tartalmazó fájlt kell feldolgoznunk és a megadott kérdésekre ezen adatok alapján válaszolnunk.
    Mint majd látjuk, a program sok metódusa igényli a java.io és a java.util osztályok alosztályait, amelyek alapértelmezésben nincsenek implementálva, ezért a program elején importálnunk kell őket:
   
    A feladat eredeti szövegezése: foci.pdf. A forrásállomány: meccs.txt.

1. feladat:
    Olvassuk be a meccs.txt fájlban található adatokat! Tárolásukra két tömböt fogunk használni, mivel az adatok egy része egész számokat, másik része szöveget tartalmaz. Alkalmazzuk a "tömb a tömbben" módszert, mivel adategységenként (az inputfájl egy-egy sora) 5 szám- és 2 szövegadat tárolásáról kell gondoskodnunk. A tömböket statikus osztályváltozókként definiáljuk, mivel a későbbiekben egy saját metódussal - MaxMin()- fogunk hivatkozni rájuk.

   A megoldás a mérkőzések számának beolvasásával kezdődik, majd soronként feldolgozzuk az inputfájlt. Ez a StringTokenizer osztály metódusainak segítségével (a sort a szóközök mentén feldarabolva) könnyen megvalósítható. Figyeljük meg, hogy a tömbök indexelése 0-tól kezdődik!

    A nextToken() metódus stringet ad vissza, ezért a számoknál a konvertáláshoz igénybe kell venni az Integer osztály parseInt() metódusát.

2. feladat:
    Egy forduló sorszámát bekérve írjuk ki a képernyőre az adott forduló mérkőzéseinek adatait a megadott formában.

    A billentyűzet inputhoz jól használható a Scanner osztály. A kiírás formátumának beállítása aprólékos munkát igényel, de szerencsére a System.out.println() metódus támogatja a szám- ill. szövegváltozók vegyes használatát.

3. feladat:
    Azokat a csapatokat (és a forduló sorszámát) kell kiíratni a képernyőre, amelyek megfordították a mérkőzés állását, tehát a félidőben még vesztésre állva a mérkőzést a végén megnyerték.

    Az összetett feltételvizsgálat oka az, hogy mind a hazai-, mind a vendégcsapat szempontjából meg kell vizsgálnunk a mérkőzések félidei- és végeredményét.

4. feladat:
    Egy csapat nevét kell bekérni a felhasználótól, majd (ez esetben egy csn változóban) eltárolva felhasználni a következő feladatok megoldásához.


5. feladat:
    Az adott csapat által lőtt és kapott gólokat kell összesítve megjeleníteni, tehát a lekérdezés szűrőfeltétele a csapat neve. Ne feledjük, hogy egy csapat hazaiként és vendégként is szerepelhet egy mérkőzésen, és csak a mérkőzések végeredményét kell összesíteni!

    Figyeljük meg a string matches() metódusát! Nagyon jól használható összehasonlításokhoz.

6. feladat:
    Feladatunk az adott csapatról meghatározni, hogy otthon melyik fordulóban kapott ki először, és ki volt a legyőzője. Azt is jelezni kell, ha veretlen maradt.

    A mérkőzések adatait tartalmazó tömbök feldolgozását végző while ciklus csak addig fut, amíg nem talál egy otthoni vereséget az adott csapatnál. Ezt a kikapott nevű logikai változó használatával érjük el.

7. feladat:
    Statisztikát kell készítenünk a bajnokságban előforduló végeredményekről, amelyet egy fájlban kell eltárolnunk. Fontos feltétel, hogy a fordított eredményeket egyezőknek kell tekinteni és a nagyobb számot mindig előre kell írni.
    A feladat megoldásához érdemes írni egy saját metódust, amely a végeredmények gólszámából egy olyan számot állít elő, amelynek tízes helyiértékét a nagyobb-, egyes helyiértékét pedig a kisebb gólszámok adják. Így a végeredményeket egységesítve  sokkal könnyebb a feldolgozásuk.


    A végeredmények számának tárolására a T1 tömb egy üres oszlopa szolgál. A tömb az összes végeredmény-fajtát tartalmazza, tehát külön adatstruktúrát nem szükséges létrehozni hozzájuk. Az algoritmus lényege az, hogy az egyes végeredményeket  - függetlenül attól, hogy milyen sorrendűek (pl. 2-1 vagy 1-2) - az első eredmény-előfordulás helyén tárolva számláljuk meg. A kimeneti fájl létrehozásához kiválóan alkalmas az egyszerűen használható PrintWriter osztály.

    Figyeljük meg a második - beágyazott - for ciklus felépítését, amely az eredmények eltárolását végzi! Mindig csak addig fut - a tömb elejétől kezdve a vizsgálatot -, amíg nem talál egy olyan végeredményt, mint amilyet el akar tárolni. A kiíratásnál arra kell figyelni, hogy a teljes tömböt fel kell dolgozni, mivel egy eredmény akár a tömb utolsó sorában is szerepelhet! A gólszámok sorrendhelyes megjelenítéséhez aMath osztály max() és min() függvényei hathatós segítséget nyújtanak.
    Összességében a feladatról elmondható, hogy - bár egyszerű fájlkezelő műveleteket igényel, de - néhány részfeladata magabiztos algoritmizáló képességet feltételez, és az adatok tárolásához a tömb adatstruktúra alapos ismerete feltétlenül szükséges.
    A teljes program forráskódja: Foci.java.

10.2. Robot
    Második feladatunk egy kis robot programozásáról szól. Négy irányba tud mozogni az egybetűs - égtájakat, mint irányokat jelölő - E, D, K és N parancsok hatására. Feladataink az ilyen utasításokból álló programsorok feldolgozásával kapcsolatosak.
    Most is szükségünk van az io és util osztályokra, valamint egy számérték formázott megjelenítése miatt a DecimalFormat osztályra is:

    A feladat eredeti szövegezése: robot.pdf. A forrásállomány: program.txt.

1. feladat:
    Első lépésként olvassuk be a Program.txt állományt! Első sora a programok számát tartalmazza, a többi sor pedig egy-egy programot. Utóbbiakat egy egyszerű string típusú P tömbben tároljuk.


2/a. feladat:
    Az összetett feladat egy utasítássor számának bekérésével kezdődik, majd el kell döntenünk az adott sorról, hogy egyszerűsíthető-e. Akkor egyszerűsíthető, ha közvetlenül egymás után két olyan lépés van előírva, amelynek eredményeképpen a robot egy helyben marad (pl. ED, NK). A kérdéses betűpárok megtalálásához a string contains() metódusát használjuk fel, amely igaz értéket ad, ha betűpárok bárhol előfordulnak a vizsgált stringben.


2/b. és 2/c. feladat:
    Ezt a két részfeladatot érdemes egyszerre megoldanunk, mert mindkettő ugyanazt a ciklust igényli az utasítások feldolgozása során, így futási időt takaríthatunk meg.
    A b. feladatban azt kell meghatároznunk, hogy a kiválasztott utasítássor végrehajtása után legkevesebb hány lépésben lehetne a robotot a kiindulási helyére visszajuttatni. Ehhez érdemes a lépéseket "lejátszani" úgy, hogy közben külön számoljuk a két tengelyen (észak-dél ill. kelet-nyugat) megtett lépéseket (ed és kn változók). Az egyik lépést pozitív, az ellentétes irányú párját negatív értékkel vesszük figyelembe. A végpozíciót elfoglalva az összesített lépésszámok abszolút értéke adja a megoldást.
    A c. pont arra kíváncsi, hogy hány lépés után kerülünk a kiindulási ponttól a legtávolabbra, és ekkor mennyi ez a távolság. Utóbbi meghatározásához a Pitagorasz-tételt használjuk fel, és az eredményt valós számtípusú változóban tároljuk.

    Figyeljük meg, hogy a négyzetgyökvonó- és a hatványozó függvények a Math osztály metódusai! Az eredmény kiírásánál formázott megjelenítést kell alkalmaznunk, amelyet a DecimalFormat osztály format() metódusa biztosít. A maszk # és 0 jele egy-egy számjegyet jelöl, és az utóbbi kötelező megjelenítést ír elő. Így lehet 3 tizedes pontosságú számot kiíratni.


3. feladat:
    A kis robot tevékenységei (elindulás, lépés, irányváltás) különféle mértékű energiafelhasználással járnak. Meg kell határoznunk, hogy mely programok végrehajtása igényel maximum 100 egységnyi energiafelhasználást.

    Figyeljük meg, hogy minden program rendelkezik egy fix energiaigénnyel, ami az indulásból és a megtett lépések számából adódik. Ezeken kívül már csak az irányváltásokat kell figyelni, amit két szomszédos utasítás különbözőségéből könnyen meghatározhatunk. Az utasítássor egy-egy elemét a String osztály charAt() metódusával könnyen meghatározhatjuk. Mivel mindig az aktuális utasítás kódját hasonlítjuk a sorban következőhöz, így a feldolgozó ciklus csak az utolsó előtti elemig fut!

4. feladat:
    Új formátumúra kell alakítanunk és egy fájlba kiírnunk az utasítássorokat. A konverzió lényege az, hogy az egymás után ismétlődő parancsokat azok számával jelölve rövidítsünk az utasítássoron. Pl. az EEEDKNNNN sorból állítsuk elő a 3EDK4N (hivatalos nevén futáshossz-tömörítésű) utasítássort. Az egyedüli utasításokat változatlanul kell leírni.

    A kimeneti fájl létrehozására a PrintWriter osztály most is kézenfekvő megoldás. Az átkódolás menete viszont már nem olyan egyszerű! Hozzunk létre minden utasítássorból egy "technikai sort", amely egy * karakterrel való kibővítéssel jön létre. Ez ahhoz kell, hogy a következő - a vizsgálatot a 2. karaktertől indító! - ciklus az adott karaktert az előzőhöz hasonlítva megszámlálhassa (az usz változóban) az egymás után következő azonos utasításkaraktereket.

5. feladat:
     A cél egy új formátumú utasítás visszaalakítása a régi formátumra. A visszakódolandó utasítássort a felhasználótól kérjük be, amelyet az uts változóban helyezünk el. Figyelnünk kell arra is, hogy az ismétlődések száma maximum 200 lehet, azaz akár 3 számjegyből is állhat! Ez a körülmény alapvetően meghatározza az átalakító algoritmus felépítését, ugyanis az ismétlődésszámot adó karaktereket is gyűjtenünk kell (ism_kar változó).

    Figyeljük meg, hogy az utasítássor elemeinek "darabolásához" a charAt() helyett a substring() metódust használjuk, ugyanis az utóbbinak van egy olyan matches() metódusa, amely segítségével nagyon tömör kóddal eldönthetjük, hogy az adott karakter utasításkód-e. A maszkban szereplő | jel a logikai vagy megfelelője. A szöveg-szám konverzióhoz most is az Integer osztály parseInt() metódusát használjuk. Abban az esetben, ha az ismétlődések száma nulla, akkor gondoskodnunk kell arról, hogy 1 legyen, mivel a kiíró programrész ciklusának legalább egyszer le kell futnia az utasításkarakter megjelenítéséhez. A 200-as határ vizsgálatához gyors, kényelmes és elegáns megoldást kínál a Math osztály min() függvénye.
    A teljes program forráskódja: Robot.java.

10.3. Tesztkérdések

10.4. Feladatok
10.4.1. Jelenítsük meg a képernyőn vesszővel elválasztva a Fibonacci számok első 20 elemét ciklussal és a 21-30. elemét rekurzióval! (A Fibonacci-számok első két eleme a 0 és az 1, a következő elemek pedig az előző elemek összege, tehát 0, 1, 1, 2, 3, 5, 8, ...)
Megoldás

10.4.2. Készítsük el a Vigenere táblát! Ez a 26*26-os tábla az angol abc betűit tartalmazza a következő elrendezésben:

Megoldás

10.4.3. Kérjünk be a felhasználótól egy magyar nyelvű (ékezetes betűket is tartalmazó) szöveget! A beolvasott szöveget kódoljuk át az alábbiak szerint, majd írjuk ki a képernyőre:
a magyar ékezetes betűket "ékezetmentesíteni" kell (pl. á - a, ű - u)
csak az angol abc 26 betűje és a számjegyek szerepelhetnek a kódolt szövegben, szóköz vagy írásjelek nem
minden átalakított betű nagybetűs legyen
Megoldás

10.4.4. A szavak.txt szöveges fájl első sora tartalmazza a fájlban lévő szavak számát. Olvassuk be az összes szót, majd írjuk ki a képernyőre a legrövidebb ill. a leghosszabb szavak listáját! Készítsünk statisztikát a szavak hosszúságának gyakoriságáról!
Megoldás


11. hét    Az objektum-orientált paradigma

Tartalom:
    11.1. Osztály és objektum, konstruktor
    11.2. Üzenet, interfész, bezárás és láthatóság
    11.3. Öröklődés és polimorfizmus
    11.4. Osztály és objektum létrehozása
    11.5. Tesztkérdések
    11.6. Feladatok

11.1. Osztály és objektum, konstruktor
    A Java nyelv alapját az objektum-orientált paradigma (módszer, alapelv, elmélet) képezi. Ez azt jelenti, hogy a korábbi programozási nyelvek által használt strukturális, moduláris programozási módszert a Java nyelv esetében felváltotta egy új szemléletmód, a megoldandó problémák objektum-orientált módon való megközelítése. E módszer központi elemei az objektumok, amelyek segítségével a megoldandó problémát leírjuk, modellezzük. Egy Java program lényegét az objektumok egymás közötti együttműködése, kommunikációja alkotja.
Nézzük, mi is lehet objektum? Pl. egy autó vagy egy ember.
Minden ilyen objektum két fő jellemzővel rendelkezik:
tulajdonságokkal (attribútum, adattag, változó) - pl. az autó színe, aktuális sebességfokozata, vagy az ember neve, testmagassága, aktuális tevékenysége
viselkedési jellemzőkkel (metódus, módszer) - pl. az autó sebességet vált, fékez, ill. az ember beszél, dolgozik
A Java nyelv e két jellemzőt egységesen kezeli:

    Az azonos adattagokkal és metódusokkal rendelkező objektumokat egy közös ún. osztályba soroljuk. Az objektumok mindig egy ilyen osztály tagjai, példányai. Pl. az Autók nevű osztály egy példánya lehet a HHT-376 frsz.-ú Opel Astra, vagy Kis István tanuló az Ember osztálynak. Egy objektum létrehozását példányosításnak is nevezzük, amelyhez a "tervrajzot" az osztály adja.
    Egy objektumpéldány létrehozását (inicializálását) az adott osztály ún. konstruktora végzi el. Ennek során az újonnan létrejövő objektum adattagjai kezdőértéket kapnak. A konstruktort a new operátorral hívjuk meg, amely memóriaterületet foglal le az újonnan létrehozandó objektumpéldány számára.
    Minden osztálynak van legalább egy konstruktora (neve ugyanaz, mint az osztályé), amelyet ha mégsem hozunk létre, akkor a Java rendszer megteszi ezt helyettünk. Ez a konstruktor viszont paraméter nélküli lesz, így a létrejövő objektumnak nem adhatunk közvetlenül kezdőértéket. Egy osztálynak több konstruktora is lehet, amelyek azonban a paramétereik száma ill. típusa alapján megkülönböztethetőknek kell lenniük.
    Az adattagok (változók) és a metódusok is lehetnek osztály- vagy példányszintűek. Pl. az autók színe különbözik, tehát példányváltozókban tároljuk őket. De ha minden autó 5 sebességes, akkor ezt a jellemzőt elég osztályszinten definiálni. Ilyen speciális osztályszintű változó lehet az osztály éppen aktuális objektumpéldányainak száma is.
Azt, hogy egy objektumpéldány egy adott osztálynak tagja-e, az instanceof - logikai értéket adó - operátorral kérdezhetjük le:
(autó1 instanceof Autó)

11.2. Üzenet, interfész, bezárás és láthatóság
    Egy Java program objektumai üzenetküldéssel kommunikálnak egymással, amely során az egyik egy konkrét feladat elvégzésére kéri a másikat. Ez a megszólított objektum egy - a kezdeményező által látható, elérhető - metódusának meghívását jelenti. Egy objektum azon metódusainak összességét, amelyeken keresztül meghívható, az objektum interfészének nevezzük. Minden objektumnak van interfésze, egyébként nem lenne értelme a létezésének.
    Az objektumok tervrajzát adó osztályok definíciójánál gondoskodhatunk arról, hogy a majdan létrejövő objektumpéldányok mely adattagjai legyenek láthatók, ill. mely metódusai és konstruktorailegyenek meghívhatók más objektumok által, valamint melyek legyenek csak az adott objektum által hozzáférhetők. Ezt az eszközrendszert nevezzük bezárásnak.
A Java nyelvben a bezárási szinteket ún. láthatósági módosítókkal állíthatjuk be. Fajtái:
publikus (public)
védett (protected)
privát (private)
módosító nélküli (alapértelmezett, csomagszintű láthatóság)
Az alábbi táblázat mutatja a módosítók hatását (● látható, ● nem látható)
Elérési szintek (láthatóság)
Módosító Osztály Csomag Leszármazott Összes osztály
public
protected
módosító nélküli
private
    Az első oszlop (Osztály) azt mutatja, hogy maga az osztály elérheti-e az adott módosítóval megjelölt adattagjait metódusait. Természetesen minden esetben igen. A második oszlop azt jelzi, az eredeti osztállyal azonos csomagban lévő más osztályok (függetlenül a szülői kapcsolatoktól) elérhetik-e a tagokat. A harmadik oszlop mutatja, hogy az adott osztály leszármazottai (függetlenül attól, hogy mely csomagban vannak) látják-e tagokat. A negyedik oszlopban az összes többi osztály számára biztosított elérhetőség látható.
    Az interfész és a bezárás eszközével biztosítható az objektumok integritása, vagyis adattagjaik ellenőrzött körülmények közötti megváltoztathatósága.

11.3. Öröklődés és polimorfizmus
    Egy osztály legegyszerűbben adattagjainak és metódusainak felsorolásával hozható létre. Azonban az objektum-orientált paradigma lehetőséget ad egy másik, hatékonyabb módszerre is, az öröklődésre. Az öröklődés az újrafelhasználhatóságot szem előtt tartva arra ad lehetőséget, hogy már meglévő (szülő-, ős-) osztályból kiindulva hozzunk létre új (gyermek-, leszármazott-, al-) osztályt. Az öröklés két osztály között fennálló olyan kapcsolat, amely során a leszármazott osztály rendelkezik a szülő osztály összes tulajdonságával (adattagjait és metódusait sajátjaként kezeli), s ezeket újabbakkal egészítheti ki. Az így létrehozott osztály is lehet más osztályok őse, így ezek az osztályok egy öröklési hierarchiába szerveződnek. Attól függően, hogy egy osztálynak egy- vagy több őse van, beszélünk egyszeres- ill. többszörös öröklődésről. A Java az egyszeres öröklődést támogatja.
    A Java-ban az osztályhierarchia legfelső eleme az Object osztály, amelyből minden más osztály (közvetve vagy közvetlenül) származik.
    Egy alosztály az örökölt metódusokat újraimplementálhatja. Ilyenkor az adott metódus ugyanolyan néven, de más, módosított (alosztályra specifikált) tartalommal kerül megvalósításra. Az ilyen metódusokat polimorfnak nevezzük.
    Polimorfizmusról beszélünk akkor is, amikor egy osztályon belül több, azonos nevű metódus létezik. Minden ilyen metódus implementációja különbözik egymástól, amelyet a paramétereik sorrendje vagy típusa biztosít. Ekkor beszélünk egy metódus többalakúságáról.

11.4. Osztály és objektum létrehozása
    Definiáljunk egy egyszerű, általánosan elérhető Autó nevű osztályt, amelynek legyen három megfelelő típusú - minden más osztály elől rejtett - adattagja a rendszám, a teljesítmény és az automata váltó meglétének tárolására, valamint egy osztályszintű példányszámlálója:

 
    Példánkban az osztály láthatóságának módosítója a public kulcsszó, az adattagok elrejtését pedig a private biztosítja. A static minősítő állítja be a példányszám változót ún. osztályváltozónak.
    Hozzunk létre egy olyan konstruktort, amely segítségével már az inicializáláskor kezdőértéket adhatunk az adattagoknak, ill. példányosításkor az automatikus számlálás is történjen meg! Ezt az osztálydeklaráció alábbi kiegészítésével érhetjük el:


    Miután van egy "működőképes" osztályunk, példányosítsuk! Ezt az Autó osztály main metódusában kezdeményezhetjük.


    Az osztálydeklaráció részleteivel a következő fejezetekben ismerkedünk meg.

11.5. Tesztkérdések

11.6. Feladatok
11.6.1. Hozzunk létre egy Dolgozó nevű osztályt a következő tulajdonságok reprezentálására:
név (szöveg típus)
születési_év (egész szám típus)
munkakör (szöveg típus)
fizetés (egész szám típus)
adójóváírás (logikai típus)
Megoldás

11.6.2. Hozzunk létre az osztályunkhoz egy olyan paraméteres konstruktort, amely segítségével a példányosítás során minden adattagnak kezdőértéket adhatunk!
Megoldás

11.6.3. Példányosítsuk az előző osztályunkat! Hozzuk létre az alábbi objektumokat, majd a megadott kódrészletet beszúrva írassuk ki őket a képernyőre!
Kovács Péter, 1966, igazgató, 500000, nem
Nagy Árpád, 1954, portás, 100000, igen
Kiss P. Eszter, 1980, főelőadó, 250000, nem
Beszúrandó kódrészlet:

Megoldás

11.6.4. Készítsünk a pályakezdő dolgozóknak olyan konstruktort, ahol a fizetés a minimálbérrel egyezik meg (2010-ben ez 73.500 Ft), és az adójóváírás alanyi jogon járjon! Ezt a konstruktort felhasználva hozzuk létre és írassuk ki a következő tulajdonságokkal rendelkező objektumot: Soós Elemér, 1990, gyakornok.
Megoldás


12. hét    Osztály és csomag

Tartalom:
    12.1. Osztály létrehozása
    12.2. Adattagok
    12.3. Inicializáló blokkok
    12.4. Konstruktorok, példányosítás
    12.5. Metódusok
    12.6. Csomag
    12.7. Tesztkérdések
    12.8. Feladatok

12.1. Osztály létrehozása
    A Java nyelven való programozás az adattagokkal és metódusokkal rendelkező objektumok programozását jelenti. Nem beszélhetünk klasszikus értelemben vett eljárásokról és függvényekről, csak objektumok együttműködéséről, amely a közöttük lévő kommunikációval valósul meg.
    Objektumot egy osztály példányosításával hozhatunk létre. Ha nem áll rendelkezésünkre megfelelő osztály, akkor nekünk kell definiálni egyet. Azaz először a "tervrajzot" kell elkészíteni, majd az alapján lehet objektumokat létrehozni.
    Az osztálydefiníció általános szintaxisa a következő:
Osztály fej:
[módosítók] class <osztály_neve> [extends <szülő_osztály_neve>] [implements <interfészek_neve>]
Osztály törzs:
{
    [adattag deklarációk];
    [inicializáló blokkok];
    [konstruktor deklarációk];
    [metódus deklarációk];
}

    Az osztály fejrészének módosítói nemcsak hozzáférési szinteket takarhatnak, hanem opcionálisan egyéb attribútumokat is:
Osztály-fejrész módosítók:
    [hozzáférési szint]: public | üres (csomagszintű)
    [abstract]: nem példányosítható osztály, amely öröklődés kiindulópontjaként használható;
                legalább egy absztrakt metódust tartalmazó osztály kötelező minősítője
    [final]: végleges osztály, metódusai nem módosíthatók, az öröklődés okafogyott

    Az extends (leszármazott osztály létrehozása) és az implements (interfészek osztályhoz fűzése) kulcsszavak a későbbi fejezetek témáját képezik.

12.2. Adattagok
    Egy objektum tulajdonságait (aktuális állapotát) az adattagjainak értékei reprezentálják. Egy adattagnak mindig van azonosítója (neve), valamint típusa, amely lehet primitív típus (pl. egész szám, string, logikai), vagy akár osztálytípus is. Az adattagok a típusuknak megfelelő értékek tárolására szolgálnak, de értéküket az objektum életciklusa során megváltoztathatják (kivéve a konstansokat).
    Az adattagok lehetnek példányszintűek, azaz minden objektumpéldányban egyedileg létezők, valamint osztályszintűek, amelyek egy osztályon belül csak egyszer léteznek, és magához az osztályhoz kapcsolódnak. Utóbbi az adattag-definíciót bevezető static kulcsszóval deklarálható.
    Egy példányszintű adattag mindig egy objektumhoz tartozik. Ha a deklarációs részben nem adunk kezdőértéket egy adattagnak, a Java automatikusan feltölti a típusának megfelelő "nullaszerű" kezdőértékkel: pl. boolean - false, számok - 0, char - nullás kódú karakter, osztály típusú adattagok - null referencia.
    Az adattag neve lehet minden megengedett azonosító, amelyet szokás szerint kisbetűvel kezdünk. Két adattagnak nem lehet azonos neve egy osztályon belül.
Adattagok deklarációja:
    [módosítók] <típus> <adattag_neve> [=<kezdőérték>][, ...];

    Az adattagok deklarációja az osztálytörzsben, bármilyen konstruktor- ill. metódusdeklaráción kívül történik. A módosítók itt sem kizárólag hozzáférési szinteket takarhatnak, hanem más eszközöket is:
Adattag-deklarációs módosítók:
    [hozzáférési szint]: public | protected | üres (csomagszintű) | private
    [static]: osztályváltozó deklarálása
    [final]: az adattag értéke végleges, konstans

    Az alábbi példában definiálunk egy kezdőérték nélküli adattagokkal rendelkező Bankbetét nevű osztályt:


    Lássuk ugyanezt az osztályt két kezdőértékadással rendelkező adattaggal definiálva:


    A tömörebb kódok elérése miatt megengedett, hogy egy adattag-deklaráción belül több azonos típusú adattagot is megadjunk, megjelölve a típust, majd az egymástól vesszővel elválasztott neveket felsorolva:


A példaprogram forráskódja: Bankbetet.rar.

12.3. Inicializáló blokkok
    Az osztály adattagjainak kezdőértékét osztály- ill. példány-inicializáló blokkban is beállíthatjuk. Az inicializáló blokkok speciális, fej nélküli metódusok, melyeket csak a blokk-képző kapcsos zárójelpárok határolnak, és return utasítást sem tartalmaznak. Az osztály-inicializáló blokkot a blokk előtti static kulcsszóval kell jelölni. Fontos tudni, hogy az inicializáló blokk csak egyszer fut le: típusától függően az osztály létrehozásakor, ill. a példányosítások alkalmával egyszer-egyszer példányonként.

12.4. Konstruktorok, példányosítás
    Egy osztály példányosítása mindig valamelyik konstruktorának meghívásával történik. A konstruktor egy konkrét objektum életciklusa alatt pontosan egyszer fut le, létrehozva ezzel az objektumot, s beállítva az adattagjainak kezdeti értékét. A konstruktor lefutása után az objektum kész az üzenetek fogadására, feladatának elvégzésére.
    A konstruktor neve kötött (mindig megegyezik az őt hordozó osztály nevével), így egy osztálynak csak akkor lehet több konstruktora (konstruktor túlterhelés), ha azok eltérő formális paraméterlistával rendelkeznek. A konstruktor egy speciális, típus nélküli metódusként fogható fel, amelynek nincs visszatérési értéke. Más megfogalmazásban a konstruktor egy - az osztály típusával visszatérő - névtelen metódus.
    Egy osztályhoz mindig tartoznia kell legalább egy konstruktornak, hiszen nélküle az osztály nem példányosítható, vagyis nem hozhatók létre az osztály típusának megfelelő objektumpéldányok. Ha nem adunk meg konstruktort, akkor a Java fordító mindig létrehoz egy alapértelmezett, paraméter nélküli konstruktort. Ennek meghívása olyan példányt hoz létre, amelynek adattagjai "nullaszerű" értékekkel rendelkeznek: a numerikus típusok nulla, a karakteres típusok "null", a logikai típusok false értéket vesznek fel. Ha azonban készítünk valamilyen konstruktort, akkor a paraméter nélküli konstruktor "elvész". Így ha mégis szükségünk van rá, definiálnunk kell!
    Csak olyan paraméterlistát adhatunk át egy konstruktornak, amelynek megfelelő konstruktort készítettünk, egyébként a fordító hibát jelez.
Konstruktor deklarációja:
    [módosítók] <osztály_neve>([<típus> <adattag_neve>[, ...]]) {
        [this.]<adattag_neve> = <adattag_neve>[, ...];
    }

    A metódusokhoz hasonlóan ha egy konstruktorban olyan változó- vagy paraméternevet alkalmazunk, amely egyben az osztály egy adattagjának is az azonosítója, akkor a this kulcsszóval minősítve hivatkozhatunk az adattagra, míg minősítés nélkül a változóra ill. a paraméterre. Figyelem! A this minősítő ezen alkalmazása nem tévesztendő össze a this() alakú konstruktorhívással!

Nézzük az alábbi konstruktorfajtákat!


    Az első konstruktor a paraméterek alapján hozza létre az objektumpéldányt, a második esetben nincs paraméterátadás, mégis minden adattag kezdőértéket kap. Az ilyen üres paraméterlistájú konstruktorban a this minősítő felesleges az adattagok elé, mivel ilyenkor nincsenek őket eltakaró lokális nevek vagy paraméterek. A harmadik esetben csak egy paraméterrel hívunk meg egy újabb konstruktorfajtát, a többi paramétert maga a konstruktor állítja be a this([<aktuális paraméterlista>]) - osztályon belüli konstruktorhívást kezdeményező - kulcsszó használatával.
    Egy konstruktor meghívása a new kulcsszóval történhet:
Példányosítás:

<osztály_neve> <objektumpéldány_neve>;
<objektumpéldány_neve> = new <osztály_neve>([aktuális paraméterlista]);
vagy
<osztály_neve> <objektumpéldány_neve> = new <osztály_neve>([aktuális paraméterlista]);

    A háromféle konstruktor meghívásának módja:


    Lássuk a konstruktorhívások eredményeképpen létrejövő objektumok adattagjainak tartalmát is (az osztály toString() metódusának megfelelő módosítása után):


    Egy konstruktorból az osztály egy másik konstruktorát, ill. a közvetlen ősosztály egy konstruktorát a this() ill. a super() kulcsszó alkalmazásával érhetjük el.

12.5. Metódusok
    Az osztályokhoz tartozó objektumok viselkedését (vagyis az objektumokhoz küldhető üzeneteket) az osztály definíciójában felsorolt metódusok határozzák meg. A metódus egy olyan programrutin, amely egy objektum egy konkrét feladatának algoritmusát valósítja meg.
    A Java nyelvben a metódusoknak két nagy csoportját különböztethetjük meg a visszatérési értéküknek megfelelően. Az egyik a visszatérési értékkel nem rendelkező eljárások, míg a másik az ezzel rendelkező függvények csoportja. Függvények esetén meg kell adni a visszatérési érték típusát, míg a másik csoport esetén a void kulcsszó helyettesíti azt.
    A metódusdefiníció általános szintaxisa a következő:
Metódus fej:
[módosítók] <típus> <metódus_neve>([formális paraméterlista]) [throws <kivételnévlista>]
Metódus törzs:
{
    [lokális változó-deklarációk];
    [utasítások];
    [return[<kifejezés>]];
}

    A metódus fejrészének módosítói nemcsak hozzáférési szinteket takarhatnak, hanem opcionálisan egyéb attribútumokat is:
Metódus-fejrész módosítók:
    [hozzáférési szint]: public | protected | üres (csomagszintű) | private
    [abstract]: öröklődés céljából készült, üres metódus: nincs metódusblokk (kapcsos zárójelpár),
                kifejtésére egy leszármazott osztályban kerül sor, a metódusfejet pontosvessző zárja
    [final]: végleges metódus, a leszármazott osztályokban a metódus nem módosítható
    [static]: osztálymetódus, csak statikus osztályszintű adattagra és metódusra hivatkozhat

    Ha a static kulcsszó nem szerepel a fejrész módosítói között, akkor példánymetódusról van szó, amely példánymetódus példányszintű adattagokra és más példánymetódusokra (összefoglaló néven példánytagokra), valamint nyilvános (public) osztálytagokra (azaz osztályszintű adattagokra és metódusokra) hivatkozhat.
    A <típus> a metódus visszatérési értékének típusát határozza meg. Az eljárások visszatérési típusa void, a függvényeké pedig bármilyen primitív típus, vagy hivatkozási típus lehet.
    A formális paraméterlistát egy típusokból és szintaktikailag lokális változónak minősülő adattagokból álló párosok alkotják. Egy metódushíváskor az aktuális- és a formális paraméterlisták elemeinek páronként meg kell egyezniük, azaz értékadás szerint kompatibilisnek és páronként megfelelő sorrendűeknek kell lenniük. A Java-ban csak érték szerinti paraméterátadás létezik.
    A throws (kivételek továbbküldése) kulcsszó egy későbbi fejezet témája lesz.
    Egy metódust a neve és a paraméterlistája azonosít egyértelműen, tehát egy osztályon belül megadható két azonos nevű metódus, ha azok paraméterlistája (szignatúrája) vagy a listában szereplő paraméterek típusaiban, vagy azok sorrendjében, esetleg mindkettőben eltérnek. Hivatkozáskor a futtató környezet a megadott paraméterek típusából és sorrendjéből el tudja dönteni, hogy a két azonos nevű metódus körül melyiket kell végrehajtania. Az így létrehozott szerkezetet a polimorfizmus egyik formájának tekinthetjük (metódusnevek túlterhelése - overload).
    Ha egy metódusban olyan változó-, vagy paraméternevet alkalmazunk, amely egyben az osztály egy adattagjának is az azonosítója, akkor a this kulcsszóval minősítve hivatkozhatunk az adattagra, míg minősítés nélkül a változóra ill. a paraméterre.
    A metódusok visszatérési értékének típusa a metódus deklarációjakor adható meg. A metóduson belül a return - feltétel nélküli vezérlésátadó - utasítással lehet a visszaadott értéket előállítani. A void-ként deklarált metódusok nem adnak vissza értéket, ezért return utasítást sem szükséges tartalmazniuk. Viszont minden olyan metódusnak, amely nem void-ként lett deklarálva, kötelezően tartalmaznia kell a return utasítást. Sőt,  a Java fordító azt is kikényszeríti, hogy return utasítással végződjön minden lehetséges végrehajtási ág. A visszaadott érték adattípusának meg kell egyeznie a metódus deklarált visszatérési értékével. Ezért nem lehetséges pl. egész számot visszaadni olyan metódusból, amelynek visszatérési értéke logikai típusú.
    Az alábbi két metódus egyike eljárás, amely eldönti, hogy pozitív összeg-e a bankbetét, a másik pedig egy függvény (a paraméterként kapott egész számmal megnöveli az adó mértékét):


    A két metódus meghívása és futásuk eredménye:



    Speciális metódus a main metódus, amelyet célszerű az osztályon belül utolsóként deklarálni. Egy alkalmazás végrehajtása során a Java futtatórendszere először mindig meghívja az alkalmazás valamelyik osztályának main metódusát, és ez a metódus fogja az összes többit meghívni.
public static void main(String[] args) {

}

A public módosító biztosítja, hogy a metódus a programon belül bárhonnan elérhető legyen, a static jelzi, hogy osztálymetódusról van szó, és a void kulcsszóból láthatjuk, hogy a metódusnak nincs visszatérési értéke. A main metódusnak egy string-tömb típusú paramétere van, amely a parancssori paramétereket tartalmazza.

12.6. Csomag
    A csomag logikailag összefüggő osztály- és interfészdefiníciók gyűjteménye. Hierarchikus felépítésével rendszerezhetjük típusainknak, külön névtereket létrehozva számukra. A csomag elnevezése a package <csomagnév> utasítás segítségével történhet, amelyet a fordítási egység legelső sora kell, hogy legyen.
    Ha olyan osztályokat is szeretnénk sokszor használni, amelyek más csomagokban vannak, akkor azokat (az állandó csomagnév hivatkozást elkerülendő) importálni érdemes. Formái:
  teljes csomag:             import <csomagnév>.*;
  csomagon belüli csomag:    import <csomagnév>.<belső_csomagnév>.*;
  csomag egy osztálya:       import <csomagnév>.<Osztálynév>;

    Az importáló utasítások kötelezően a csomagdeklarációs sor után következnek. Egy utasításban csak egy osztály (vagy a .*-gal egy teljes csomag) importálható. A Java fordító minden csomaghoz automatikusan hozzáfordítja az alapvető osztályokat (pl. System, String) tartalmazó java.lang csomagot, így ezt nem szükséges külön importálni. Az importálás művelete nem rekurzív, tehát egy teljes csomag importálásakor nem lesznek elérhetők az alcsomagok osztályainak definíciói.

12.7. Tesztkérdések

12.8. Feladatok
12.8.1. Bővítsük tovább az előző fejezet Dolgozó osztályát Dolgozó2 néven! Hozzunk létre egy - csak ebből az osztályból látható - osztályváltozót, amely a dolgozók számát tárolja! Gondoskodjunk arról is, hogy példány létrejöttekor automatikusan növekedjen az értéke! Ellenőrizzük, hogy eddig hány dolgozó van!
Megoldás

12.8.2. Készítsünk - más osztályból nem látható - metódusokat a fizetés emeléséhez! Az alábbi típusú fizetésemelések lehetségesek:
1. típus: rendkívüli - fix 10.000 Ft-os emelés
2. típus: százalékos - emelés a meglévő fizetés százalékában
3. típus: jogszabály szerinti - emelés a minimálbér 10%-ával
4. típus: általános - adott összegű fizetésemelés
    A minimálbér összegét definiáljuk végleges osztályváltozóként, és ennek megfelelően módosítsuk a "minimálbéres" konstruktort! A dolgozókat (d1, ... d4) rendre rendkívüli, 20%-os, jogszabály szerinti, ill.  5.000 Ft-os általános fizetésemelésben részesítsük, majd jelenítsük meg képernyőn a nevüket és az új fizetésüket! Mennyi lett az új átlagfizetés?
Megoldás

12.8.3. Hozzuk létre az osztály paraméter nélküli konstruktorát, amely segítségével példányosítsunk egy újabb dolgozót! Adattagjai milyen értékeket vettek fel? Írjuk felül őket a d4-es dolgozó adataival, kivéve a nevet és a születési évet, amely Molnár Attila (szül. 1985) legyen! Írjunk egy példánymetódust a nettó fizetés kiszámítására! A levonások összesen 45%-ot tesznek ki. Mennyi a nettó bére az új dolgozónak?
Megoldás

12.8.4. Írjuk meg a példányváltozók lekérdező és beállító metódusait! Hozzunk létre osztály- és példány-inicializáló blokkokat, amelyekben jelezzük, hogy a program futása közben milyen inicializálás történik! Készítsünk egy osztálymetódust, amellyel a minimálárat adott százalékkal megnövelhetjük!
Megoldás


13. hét    Öröklődés

Tartalom:
    13.1. Az öröklődés
    13.2. Adattagok elrejtése
    13.3. Metódusok felülírása és elrejtése
    13.4. A super() kulcsszó használata
    13.5. Az Object osztály toString()és equals() metódusa
        13.5.1. A toString() metódus
        13.5.2. Az equals() metódus
    13.6. A compareTo() metódus
    13.7. Végleges osztályok és metódusok
    13.8. Tesztkérdések
    13.9. Feladatok

13.1. Az öröklődés
    A 11. leckében már volt szó az öröklődés elméleti alapjairól. Ezen eszköz segítségével létező ősosztályból származtathatunk tetszőleges számú leszármazott osztályt, annak továbbfejlesztése, kibővítése céljából. Az utódosztály további osztályok őse lehet, így egész osztályhierarchiák építhetők fel. A Java-ban minden osztálynak szigorúan csak egy közvetlen szülőosztálya van. Fontos tudni, hogy egy leszármazott osztály minden olyan üzenetre tud reagálni, amelyre az őse is tudna. Az utódosztály örökli összes ősének minden olyan adattagját és metódusát, amely nem private minősítésű.
    Az öröklődéssel egy - már létező - osztály adattagjait (tulajdonságait) és metódusait (viselkedésmódját) bővíthetjük, módosíthatjuk:
új adattag hozzáadásával
új metódus hozzáadásával
létező adattag elfedésével
létező metódus felülírásával

    Alapértelmezésben egy újonnan létrehozott osztálynak az Object nevű osztály lesz az őse, amely a Java osztályhierarchiájának csúcsán áll, és minden Java-beli osztály közös őse. Ezt kihasználva olyan általános programokat írhatunk, amelyek nem kötik ki, hogy milyen osztályú objektumokra van szükségük. Pl. implementálhatunk egy általános felhasználású verem adatszerkezetet, amely bármilyen objektumot tud kezelni. Az Object osztály az egyetlen külön nem importálandó csomag, a java.lang csomag része.
    Ha létrehozandó osztályunk számára nem megfelelő (pl. túl általános) az Object osztály, akkor az extends kulcsszót használva más - specifikusabb - ősosztályból is örököltethetjük az új osztályunkat.
Az öröklődés deklarációja:
[módosítók] class <utódosztály_neve> extends <ősosztály_neve> [implements <interfészek_neve>];

13.2. Adattagok elrejtése
    Ha egy osztály adattagja ugyanazt a nevet viseli, mint a szülőosztálya, akkor elrejti azt (még akkor is, ha különböző típusúak). Ekkor a szülőosztály adattagjára nem hivatkozhatunk egyszerűen a nevével, ezért általában nem javasolt az adattagok elrejtése.

13.3. Metódusok felülírása és elrejtése
    Ha egy leszármazott osztály metódusának ugyanaz a szignatúrája (azaz neve, paramétereinek száma és típusa), valamint visszatérési értéke, mint az ősosztály metódusának, akkor a leszármazott osztály felülírja az ősosztály metódusát. Ez a képesség lehetővé teszi, hogy egy elég közeli viselkedésű osztályból öröklődve - annak viselkedését szükség szerint megváltoztatva - új, leszármazott osztály jöhessen létre. Például az Object osztály tartalmaz egy toString() nevű metódust, amely visszaadja az objektumpéldány szöveges reprezentációját. Ezt a metódust minden osztály megörökli. Az Object ezen metódusának végrehajtása azonban nem túl hasznos a leszármazott osztályok számára, ezért a metódus felülírása célszerű, hogy használhatóbb információt nyújthasson az objektum saját magáról. Erről bővebben e lecke további részében lesz szó.
    A felülíró metódus láthatósága lehet bővebb, mint a felülírt metódusé, de szűkebb nem. Mivel egy leszármazott osztály objektuma bárhol használható, ahol egy ősosztálybeli objektum, ezért a leszármazott egyik tagjának láthatósága sem szűkülhet, hiszen akkor az ilyen használat lehetetlen lenne.
    Egy leszármazott osztály nem tudja felülírni az olyan metódusokat, amelyek az ősosztályában final (végleges) minősítéssel definiáltak. Azonban felül kell írni azokat a metódusokat, amelyeket a felsőbb osztályban abstract-nak nyilvánítottak, vagy magának a leszármazott osztálynak is absztraktnak kell lennie.
    Ha egy leszármazott osztály egy osztálymetódust ugyanazzal az aláírással (szignatúrával) definiál, mint a felsőbb osztálybeli metódus, akkor a leszármazott osztály metódusa elrejti (elfedi) a szülőosztálybelit. Fontos megkülönböztetni a felülírást az elrejtéstől! Az alábbi példaprogram jól szemlélteti a különbséget:
    Adott egy Állat ősosztály, melynek osztály- és példánymetódusa is van:


    Származtassunk belőle egy Macska utódosztályt, amelyben az o_elrejt() osztálymetódust elrejtjük, és a p_felülír() példánymetódust pedig felülírjuk.


    Ebben az osztályban a main metódus létrehoz egy Macska példányt Tóni néven, majd ezt a példányt típuskonverzióval átteszi egy Állat példányba állat (kisbetűvel!) néven. Utóbbi példányra hívjuk meg mindkét metódust! Az eredmény:


    Az o_elrejt() metódus a szülőosztályból került meghívásra, míg a p_felülír() a leszármazottból.
    Osztálymetódushoz a futtatórendszer azt a metódust hívja meg, amely a hivatkozás szerkesztési idejű típusában van definiálva. A példában az állat példány szerkesztési idejű típusa az Állat. Így a futtatórendszer az Állat-ban definiált, rejtett metódust hívja meg. A példánymetódusnál a futtatórendszer a hivatkozás futásidejű típusában meghatározott metódust hívja meg. A példában az állat példány futásidejű típusa a Macska, vagyis a futtatórendszer a Macska osztályban definiált felülíró metódust hívja meg.
    Fontos még tudni, hogy egy példánymetódus nem tud felülírni egy osztálymetódust, és egy osztálymetódus nem tud elrejteni egy példánymetódust.
A példaprogram forráskódja: Allatok.rar.

13.4. A super() kulcsszó használata
    Az öröklődés során csak az adattagok és a metódusok kerülnek át a leszármazott osztályba, a konstruktorok nem. Mégis van lehetőség a leszármazott osztály konstruktorából az ősosztály egy konstruktorát meghívni. Ezt a super() kulcsszóval tehetjük meg. A super() egy hivatkozás az ősosztályra, működése hasonló a this() kulcsszóhoz. Segítségével az ősosztály egy konstruktorára vagy egy felüldefiniált metódusára hivatkozhatunk. Ha nem írunk konstruktort, akkor a fordító automatikusan beilleszt egy paraméter nélkülit, amelynek első sora a super() konstruktorhivatkozás. Ezért ha az ősosztályunk nem rendelkezik paraméter nélküli konstruktorral, hibaüzenetet kapunk. Ilyen esetben írnunk kell egy konstruktort, amelyben meg kell adnunk, hogy melyik őskonstruktort szeretnénk használni, s milyen paraméterekkel.
    Az előző lecke Bankbetét osztályából örököltetjük a KamatosBetét osztályt, majd az új osztályt bővítjük egy új adattaggal, amely a kamatösszeget tárolja:


    Figyeljük meg a this minősítő használatát is! A sima kamat azonosító a konstruktor lokális változóját jelenti, viszont a this.kamat az új osztály adattagját hivatkozza.
A példaprogram forráskódja: Bankbetet.rar.

13.5. Az Object osztály toString()és equals() metódusa
    Van az Object osztálynak két olyan alapvető metódusa, amelyeket a leszármazott osztályok példányain sokszor alkalmazunk. Érdemes és hasznos minden új osztály definíciója során felülírni őket, hogy a toString() megfelelő értékeket reprezentálhasson, ill. a saját igényeinknek megfelelő módon tudjunk az equals() segítségével objektumokat összehasonlítani, hogy egyenlők-e.

13.5.1. A toString() metódus
    Gyakori eset, hogy tájékoztatást kívánunk kapni egy objektum pillanatnyi állapotáról, amelyet az adattagjai reprezentálnak. Erre a Java-ban a toString() névtelen metódus szolgál. Azonban ez a metódus alapesetben nem azt jeleníti meg, amit várnánk. Nézzük, mi lesz a System.out.println(b1) utasítás eredménye:

    Amit látunk, az nem az objektumpéldány adattagjainak tartalma, hanem az azonosítója (OID - Object ID), amely az alábbi felépítésű: <csomagnév>.<osztálynév>@<objektumazonosító>. Minden objektumpéldánynak külön azonosítója van. Definiáljuk felül a nem statikus toString() metódust úgy, hogy a mi elvárásunknak megfelelő kimenetet produkáljon!
Az Object osztály toString() metódusának felüldefiniálása:
    @Override
    public String toString() {
        return <objektumjellemzőket leíró karakterlánc>
    }

    Az alábbiakban látható egy lehetséges megoldás a Bankbetét osztály példányainak szöveges formában való megjelenítésére. Figyeljük meg a System.getProperty("line.separator") soremelő metódust, amely biztosítja az adattagok külön sorba tördelését!


13.5.2. Az equals() metódus
    Két - azonos osztályhoz tartozó - objektum akkor egyenlő, ha az adattagjaik által reprezentált állapotuk megegyezik. Ezt összehasonlító operátorral nem tudjuk megállapítani, ugyanis a (<objektumnév1> == <objektumnév2>) logikai kifejezés az érintett objektumok mutatóját hasonlítja össze, ami természetesen csak akkor lesz azonos, ha egy objektumot önmagához hasonlítunk. Az equals() metódus viszont képes úgy összehasonlítani két objektumot, hogy az összehasonlítás alapját képező adattagok körét mi határozhatjuk meg a metódus felüldefiniálásával.
Az Object osztály equals() metódusának felüldefiniálása:
    @Override
    public boolean equals(Object obj) {
        if (obj == null || !(obj instanceof <Osztálynév>)
            return false;
        if (obj == this) return true;
        return <adattag_összehasonlító_logikai_kifejezések>
    }

    Figyeljük meg a metódus törzsének első utasítását, amely azonnal kiszűri az üres és az "osztályidegen" objektumokat, ill. a második utasítás felismeri azt, hogy az objektumot önmagához hasonlítjuk.
    Az alábbi példában azokat a Bankbetét objektumokat tekintjük egyenlőnek, amelyek tulajdonosának neve megegyezik:


13.6. A compareTo() metódus
    Ha azt szeretnénk elérni, hogy egy osztály példányai valamely adattagjuk alapján összehasonlíthatók legyenek, akkor a compareTo() metódust kell ehhez az osztályba implementálni. A metódus összehasonlítja az aktuális objektumot az átvett objektummal, és a visszatérési értéke attól függően, hogy az aktuális objektum kisebb, egyenlő, vagy nagyobb az átvettnél, rendre negatív egész, nulla ill. pozitív egész érték lesz.
    A compareTo() metódust akkor érdemes - és kötelezően kell is - implementálni egy osztályba, ha célunk az osztály objektumainak sorba rendezése valamely adattagjuk alapján. Ilyenkor az osztálydefiníció fejrészét az implements Comparable utasítással kell kiegészíteni.
    A következő példában kiegészítjük a KamatBetét osztály definícióját úgy, hogy példányai kamatösszegük alapján összehasonlíthatók legyenek:


13.7. Végleges osztályok és metódusok
    A final kulcsszóval deklarált adattagok értéke inicializálásuk után már nem módosíthatók, és ezt nem teheti meg a leszármaztatott osztály sem. Ez egy fontos szempont a rendszer biztonsága és az objektum-orientált tervezés szempontjából. Ugyanez a helyzet az osztály metódusaival is. Ha nem akarjuk, hogy egy származtatott osztályban felüldefiniáljanak egy metódust, "véglegesíteni" kell. Az Object ősosztálynak is vannak final típusú metódusai, de nem mindegyik az, lásd toString(), equals().
    Ha magát az osztályt a final kulcsszóval deklaráljuk, akkor belőle leszármaztatott osztályt egyáltalán nem tudunk létrehozni.

13.8. Tesztkérdések

13.9. Feladatok
13.9.1. Készítsünk megfelelő osztályhierarchiát a hasáb és a gömb felszínének és térfogatának reprezentálására. Közös ősosztályuk neve legyen Test! A testek jellemző adatai (élek, sugár - cm-ben megadva) egész típusúak legyenek, a számított értékek pedig double típusúak!
Megoldás

13.9.2. Írjuk felül a két leszármazott osztály toString() metódusát úgy, hogy a példányaik adattagjai és a két metódusuk eredménye az alábbi formában jelenjenek meg (figyeljünk a Gömb osztálynál az 1 tizedes kerekítésre!):
Hasáb (élei: 5, 10, 15 cm)
 - felszíne  550 cm2
 - térfogata 750 cm3
Gömb (sugara: 10 cm)
 - felszíne  1256,6 cm2
 - térfogata 3141,6 cm3
Megoldás

13.9.3. Definiáljuk felül a Hasáb osztály equals() metódusát úgy, hogy két hasáb csak akkor legyen egyenlő, ha éleik hossza - függetlenül azok sorrendjétől - megegyezik!
Megoldás

13.9.4. Definiáljuk felül a Gömb osztály equals() metódusát úgy, hogy két gömb csak akkor legyen egyenlő, ha sugaruk megegyezik. Ellenőrizzük a metódus működését! Egészítsük ki ennek az osztálynak a definícióját úgy, hogy példányaik - sugaruk nagysága alapján - összehasonlíthatók legyenek!
Megoldás


14. hét    Kivételkezelés

Tartalom:
    14.1. A Java kivételkezelése
    14.2. A try blokk
    14.3. A catch blokk
    14.4. A finally blokk
    14.5. A throws használata
    14.6. Saját kivételek létrehozása a throw utasítással
    14.7. Tesztkérdések
    14.8. Feladatok

14.1. A Java kivételkezelése
    A Java kivételkezelésének célja a programfutás során keletkezett hibák kiszűrése és megfelelő kezelése. Az ilyen hibákat a Java platformon Exception-nek (kivételnek) nevezik. Két fő csoportjuk van: a futási időben és a nem futási időben keletkezett kivételek. Futásidejű kivételek az aritmetikai (pl. nullával való osztás), az indexeléssel kapcsolatos (pl. tömb nem létező eleméhez való hozzáférés), és a referenciával kapcsolatos (pl. objektumokra való hivatkozás) kivételek. Ezeket a kivételeket nem kötelező implementálni, de erősen ajánlott. Nem futásidejű kivételek a Java rendszerén kívül keletkeznek. Ilyenek az I/O műveletek során keletkező hibák (pl. a fájl nem található). Utóbbiakat kötelező lekezelni.
A felmerülő hibák sokféleségének kezelését a Java az objektum-orientált paradigma lehetőségeinek felhasználásával oldja meg: a kivételeket osztályok (ill. objektumaik) reprezentálják. Minden beépített - vagy általunk létrehozott - kivétel közös ősosztálya a Throwable osztály.
    Amikor egy metódus futása során valamilyen hiba lép fel (pl. nullával való osztás, veremtúlcsordulás, indexhatár túllépése, vagy a háttértároló megtelik, stb.), akkor egy kivételobjektum (egy kivételosztály példánya) jön létre. Ez az objektum olyan információkat tartalmaz a kivétel fajtájáról és a program aktuális állapotáról, amelyeket a kivétel lekezelésekor felhasználhatunk. A kivételobjektum létrehozását és a futtatórendszer által történő lekezelését kivételdobásnak hívjuk. Ezeket ellenőrzött kivételeknek is nevezzük. Az ellenőrzött kivételeket kötelező lekezelni, amit a fordító már fordítási időben ellenőriz is.
    Nézzünk egy egyszerű példát a nullával való osztás kivételkezelésére! Az alábbi program alaphelyzetben semmiféle ellenőrzést nem végez az osztó értékére vonatkozóan:


    A program futtatása ennek megfelelően 0 osztónál hibát jelez:


    Hagyományos megoldásként az osztás művelete előtt ellenőrizzük az osztó értékét!


    Ez a megoldás bonyolultabb ellenőrzések esetén az if feltételek garmadáját vonhatja magával, ami nagymértékben rontja a kód olvashatóságát és az esetleges programjavítás lehetőségét.

14.2. A try blokk
    Kivétel mindig egy metódus törzsében keletkezhet. Ha ezeket a hibákat mind ugyanitt kezelnénk le, a programkód áttekinthetősége jelentősen romlana, és nem is lehet minden hibára előre felkészülni. Ezt szem előtt tartva olyan megoldás született, amelyben a hibás, kivételes programállapotot eredményezhető sorokat összefogva, s hozzá egy úgynevezett kivételkezelőt megadva a probléma elegánsan megoldható. Ekkor az adott blokkban fellépő kivételeket egységesen, egy helyen kezelhetjük, jól elválasztva egymástól a program fő feladatát végző, illetve a hibák lekezeléséért felelős kódrészt. Ennek megvalósítására a try - catch - finally blokkszerkezet használható. Sorrendjük szigorúan kötött!
    A try blokk utasításokat zár közre, amelyeket futási időben végig felügyelete alatt tart. Lehetőleg minél kevesebb utasítást tegyünk egy ilyen blokkba, mert kivétel keletkezése esetén csak a kivétel keletkezési helyéig hajtódnak végre a blokkbeli utasítások.
A try - catch - finally kivételkezelő kódblokk felépítése:
try {
    <utasítások>
}
catch (<kivételtípus_1> <változónév_1>) {
    <utasítások>
}
[catch (<kivételtípus_2> <változónév_2>) {
    <utasítások>
}]
[finally {
    <utasítások>
}]

Néhány fontosabb kivételosztály:
Exception (általános hiba, ez az osztály minden más kivételosztályt magába foglal)
IOException (általános I/O hiba)
FileNotFoundException (a fájl nem található)
EOFException (olvasás a fájl vége után)
IndexOutOfBoundsException (indextúlcsordulás)
NumberFormatException (számformátum hiba)
ArithmeticException (aritmetikai hiba)
IllegalArgumentException (érvénytelen argumentum)
InputMismatchException (az input adat nem megfelelő típusú)

14.3. A catch blokk
    A catch blokkok a try blokkban keletkező - típusuknak megfelelő - kivételeket kezelik le. Minden try blokkhoz megadható tetszőleges számú (ha nincs finally blokk, akkor legalább egy) catch ág, amelyek az esetlegesen fellépő hibák feldolgozását végzik. Semmilyen programkód nem lehet a két blokk között! A catch ágak sorrendje sem mindegy, mert az első olyan catch blokk elkapja a kivételt, amelynek típusa megegyezik a kiváltott kivétellel, vagy őse annak. Ezért érdemes a specifikus kivételtípusoktól az általánosabb típusok felé haladva felépíteni a catch blokkokat. A hierarchia tetején álló Exception osztály nem előzhet meg más (leszármazott) kivételosztályokat, mert azok sosem hajtódnak végre. A fordító ilyen sorrend esetén hibát jelez.
    Ha valahol kivétel keletkezik, akkor a futtató rendszer megpróbál olyan catch ágat találni, amely képes annak kezelésére. Az az ág képes erre, amelynek paramétere megegyező típusú a kiváltott kivétellel (vagy annak ősével), valamint amelynek a hatáskörében a kivétel keletkezett.
    A catch ág egy szigorúan egyparaméteres metódusként fogható fel, amely paraméterként megkapja a fellépő kivételt, és ezt tetszőlegesen felhasználhatja a hibakezelés során. A kivételobjektumot nem kötelező felhasználni, mert sokszor a típusa is elég ahhoz, hogy a programot a hibás állapotból működőképes mederbe tereljük.
    Ha a catch ágak egyike sem tudja elkapni a kivételt, akkor a beágyazó kivételkezelő blokkban folytatódik a keresés. Ha egyáltalán nincs megfelelő catch blokk, a program befejeződik.

14.4. A finally blokk
    A finally ág akkor is lefut, ha volt kivétel, akkor is, ha nem. Ebben a tetszőlegesen felhasználható blokkban kezdeményezhetjük pl. a nyitott fájlok bezárását, amit  - függetlenül attól, hogy a megelőző tryblokkban volt-e kivétel, vagy sem - mindig illik megtennünk. Ezt az ágat nem kötelező létrehozni, kivéve, ha nincs egyetlen catch ág sem. A kivétel lekezelése után a program végrehajtása a kivételkezelő kódblokk utáni utasításon folytatódik.
    A kivételkezelő blokkok megismerése után alakítsuk át példaprogramunkat! Az osztás művelete kerüljön egy try blokkba, a hibát egy catch blokkban aritmetikai hibaként kezeljük le, valamint a finallyblokkban jelezzük az osztás sikerességét!


    A futás eredménye nulla osztó esetén:


    A vörös színben megjelenő "/ by zero" üzenet a kivételkezelő osztály hibaüzenete. Ebben a példában a finally ágra nincs is igazán szükség, így ezt elhagyva és a hibaüzenetet átírva egyszerűsíthető a program.


A kimenet is barátságosabb:


A fenti program forráskódja: Osztás.java.
.
14.5. A throws használata
    Ha egy metódus végrehajtása közben kivétel keletkezik, és ezt nem akarjuk, vagy nem tudjuk helyben - az adott metóduson belül - lekezelni, akkor tovább kell küldenünk egy magasabb szintre, az adott metódust hívó metódus felé. Ez mindaddig folytatódhat, amíg el nem érjük azt a szintet (metódust), amely már elegendő információval rendelkezik a megfelelő intézkedések elvégzéséhez. Ezt a metódus fejlécében a throws kulcsszóval tehetjük meg, utána felsorolva azokat a kivételosztályokat (vagy egy ősüket), amelyeket nem kívánunk (vagy nem tudunk) helyben lekezelni. Legkésőbb a program mainmetódusában az ilyen kivételeket le kell kezelni.

14.6. Saját kivételek létrehozása a throw utasítással
    A Java kivételkezelése nyitott, ami azt jelenti, hogy bárki létrehozhat saját névvel és funkcionalitással ellátott kivételosztályokat, amelyeket célszerű az Exception osztályból származtatni. Az új kivételosztályok nevében célszerű az "Exception" szót is szerepeltetni, hogy utaljon annak szerepére.
Saját kivételobjektum létrehozása:
    throw new <Saját_Kivételosztály_név> ("Saját hibaüzenet");

    Az alábbi program egy 3 db egész szám tárolására szolgáló verem adatszerkezetet modellez. Megvalósítjuk a verembe helyezést és a veremből való kivételt úgy, hogy ezen műveletek hibájának lekezelésére saját kivételosztályt használunk, és a hiba okát is megjelenítjük.
    Első lépésként a saját kivételosztályunkat definiáljuk, amely hibaüzenet átvételére is alkalmas.


    Majd következik a verem implementálása. A verem fontos jellemzője a mérete és a veremmutató. A betesz() metódus a paraméterként megadott számot a verem - mutató által jelzett - tetejére helyezi, a kivesz() - paraméter nélküli - metódus pedig a verem tetején levő számot "emeli ki". A szám helyének "kinullázása" nem kötelező, mert a verem telítettségét a mutató állása jelzi, nem a tartalma.


    Próbáljunk háromnál több elemet elhelyezni a veremben, majd ezután a megtelt veremből háromnál többet kivenni!


    Az eredmény kiírása kissé rapszodikus sorrendben történik, mivel a kivételek kezelése külön programszálon fut, így nem a várt időpillanatban írják ki a hibaüzenetüket. Ezért a hibát kiváltó művelet előtt alkalmazzunk egy 2 mp-es késleltetést, amelyet a vár() nevű saját készítésű metódussal állítunk elő. Az msec osztályváltozó tárolja a késleltetés idejét milliszekundumban.


    Az eredmény:


    Jól látható, hogy a 4. szám elhelyezése és az üres veremből való 4. kivétel is hibát okozott. Figyeljük meg a verem működését is! Az utoljára bekerült elem elsőként lett kivéve (LIFO adatszerkezet: Last In - First Out, utoljára be - elsőként ki).
    A fenti program forráskódja: Verem.rar.

    Térjünk vissza egy rövid kiegészítés erejéig a 9. heti tananyag I/O műveleteire! Az ott alkalmazott forráskódok a jobb áttekinthetőség miatt nem tartalmazták a fájl bezárását megvalósító close() metódus biztonságos kivételkezelését, pedig ez a művelet is okozhat kivételt (pl. időközben megszűnt a kapcsolat a fájllal), így ezt az utasítást is érdemes try-catch szerkezetbe foglalni a következők szerint:


    Figyeljük meg, hogy a close() utasítást "védő" try-catch szerkezet a fájlkezelő műveletek finally ágában helyezkedik el, tehát minden körülmények között lefut. Viszont a 9. fejezetben szereplő példák mindegyikében hiába volt a close() utasítás a try blokk által védett, ha előtte bekövetkezett egy kivétel (pl. a fájlba írás során), akkor soha nem került rá a vezérlés, tehát a fájl nyitva maradhatott.

14.7. Tesztkérdések

14.8. Feladatok
14.8.1. Olvassunk be egy számot a billentyűzetről és írjuk ki a négyzetgyökét! A kritikus műveleteket tegyük try - catch blokkokba, és negatív szám bevitele esetén "Negatív számból nem lehet négyzetgyököt vonni!" hibaüzenet jelenjen meg! A helyes eredmény 3 tizedes pontosságú legyen!
Megoldás

14.8.2. Egészítsük ki a 9. fejezet io_token.java programját úgy, hogy hibás inputadatok bevitele esetén is működjön, és csak az egész számokat adja össze! A hibás adatok NumberFormatException kivételt váltanak ki. Elválasztójel a szóköz legyen! Pl. a 23 44,4 12 k 10 bemenő adatokból kiszűrhető egész számok összege 23+12+10=45 jelenjen meg a képernyőn! A végeredmény mellett a hibás adatok is kerüljenek kiírásra!

Megoldás

14.8.3. Készítsünk programot, amely a vissza.txt szövegfájlból beolvassa a leghosszabb magyar szót, majd mind előre, mind hátrafelé olvasva kiírja képernyőre! A fájlműveleteket lássuk el megfelelő kivételkezeléssel (FileNotFoundException, IOException)!
Megoldás

14.8.4. Írjunk programot egy 3 db egész szám tárolására szolgáló sor adatszerkezet modellezésére. Típusa "fix kezdetű" legyen, azaz a sor első eleme mindig a sor első tárhelyén  helyezkedjen el! Implementáljuk a sorba való behelyezést és a sorból való kivételt úgy, hogy ezen műveletek hibájának lekezelésére saját kivételosztályt használjunk, és a hiba okát is jelenítsük meg!
Megoldás

15. hét    Objektum-orientált feladat megoldása

Tartalom:
    15.1. Számítógép
    15.2. Tesztkérdések
    15.3. Feladatok

15.1. Számítógép
    Az alábbiakban egy olyan összetett feladatot fogunk megoldani, amely a Java nyelv igazi erősségét, az objektumközpontú programozást helyezi előtérbe.
    Adott az alábbi osztály:


    1. feladat: Definiáljunk egy olyan konstruktort az osztályhoz, amellyel az adattagoknak kezdőérték adható!
    A megoldásban segít a NetBeans fejlesztőrendszer. A szerkesztőterület helyi menüjének "Insert code" menüpontjából kezdeményezhetünk konstruktor-generálást, kijelölve azokat az adattagokat, amelyeknek kezdőértéket kívánunk adni.

 .
    Figyeljük meg, hogy az adattagok nevei önmagukban mint paraméterek jelennek meg, az osztály "igazi" adattagjaira a this kulcsszóval hivatkozhatunk!

    2. feladat: Írjuk meg az adattagok lekérdező és beállító metódusait!
    Ismét használható a helyi menü, ahol a metódusokat a Getter (lekérdező) és a Setter (beállító) menüpontok generálják le.

A létrejövő kódrészletek:


    Figyeljük meg, hogy az automatikus generálás az adattagokat mindkét metódusnál ABC sorrendbe állította, amely utasítások természetesen visszaállíthatók az osztálydefiníció szerinti sorrendjükbe.

    3. feladat: Definiáljuk felül az osztályunk toString() metódusát úgy, hogy az adattagjait soronként és a következő formátumban adja vissza:
    <processzor> <sebesség> GHz CPU, <ram> MB RAM, <hdd> GB HDD
    (pl. "AMD 2.4 GHz CPU, 1024 MB RAM, 500 GB HDD")
    Az Object osztályból örökölt toString() metódus átdefiniálását szintén kezdeményezhetjük a helyi menü metódus-felülíró (Override Method) menüpontjában, viszont a kapott kódot a kívánalmaknak megfelelően át kell alakítani:


    4. feladat: Definiáljuk felül az equals() metódust úgy, hogy két számítógép akkor legyen egyenlő, ha a processzoruk neve megegyezik, és a sebesség- és kapacitás-paramétereik páronként maximum 10%-kal térnek el egymástól!
    Ennek a metódusnak is generáljuk a vázát, majd a Math osztály abs() metódusát felhasználva - és a kódot jelentősen átírva - előállítjuk az összetett feltételt. Az automatikusan generálódó hashCode()metódus átdefiniálására most nincs szükség, akár törölhető is.

    Figyeljük meg, hogy null (üres) és nem számítógép objektum esetén nincs átdefiniálás!

    5. feladat: Egészítsük ki a Számítógép osztály definícióját úgy, hogy az objektumai processzoruk sebessége alapján összehasonlíthatók legyenek! Implementáljuk a Comparable interfészt is!
    A  feladat megoldásához a compareTo() metódust kell felüldefiniálni, hogy a megadott szempont szerint tudjuk az osztálypéldányokat összehasonlítani.

A Comparable interfész implementálását az osztály fejében jelezni kell. Definíciója csak egyetlenegy metódust tartalmaz.


    6. feladat: Származtassunk a Számítógép osztályból egy Notebook osztályt! Az új osztály objektumai a számítógép tulajdonságain kívül egy új - valós értékű - üzemidő adattaggal is rendelkeznek. Készítsünk az új adattaghoz lekérdező metódust, valamint az osztályhoz egy konstruktort, amellyel mindegyik adattagjának kezdőérték adható!
    Az új osztályt az extends kulcsszóval származtathatjuk a szülőosztályból. A konstruktor és az új adattag lekérdező metódusának előállítása a generátor használatával egyszerű. Figyeljük meg a super()metódus használatát! Segítségével a szülőosztály adattagjaira hivatkozhatunk, míg a this a származtatott osztály új adattagját hivatkozza.


    7. feladat: Egészítsük ki a Notebook osztályt egy olyan konstruktorral is, amely a RAM méretét 2048 MB-ra állítja be, a többi adattag értékét pedig paraméterek határozzák meg!
    A Notebook osztály új konstruktorában a ram adattag nem szerepel paraméterként, mert konkrét értéket kap, amit a super() metódus meghívásakor állítunk be.


    8. feladat: Definiáljuk felül a Számítógép osztálytól örökölt toString() metódust úgy, hogy a notebook a számítógéptől örökölt adattagjai után az üzemidőt is jelenítse meg egy tizedes pontossággal (pl. ..., 3,5 óra üzemidő)!
    A korábban már megismert java.text.DecimalFormat osztályt importálva a feladat megoldása nem okoz gondot.

    9. feladat: Készítsünk egy main nevű osztályt, amely a főprogramot tartalmazza. Hozzunk létre két-két Számítógép típusú objektumot az alábbi adatokkal, majd írassuk ki őket a képernyőre!
Számítógép szg1: AMD, 3.2 GHz, 4096 MB, 400 GB
Számítógép szg2: Intel, 2.6 GHz, 2048 MB, 500 GB

    A két objektumpéldány adattagjainak megjelenése a toString() metódus átdefiniálásának megfelelő formátumú:

    10. feladat: Hozzunk létre két Notebook objektumot is! Az első minden adattagját paraméterként kapja, a második viszont 2048 MB-os memóriával jöjjön létre. Adatok:
Notebook nb1: AMD Turion X2, 1.8 GHz, 3072 MB, 250 GB, 3.55 óra
Notebook nb2: Intel Atom, 1.6 GHz, 120 GB, 2.2 óra

Figyeljük meg, hogy a két objektumpéldányt más-más konstruktor hozta létre!

    A teljes program forráskódja: szamitogep.rar.

15.2. Tesztkérdések

15.3. Feladatok
15.3.1. Egészítsük ki a Számítógép osztályt egy olyan metódussal, amely a következő feltételek alapján eldönti egy objektumról, hogy korszerű-e! Korszerű, ha a processzor sebessége minimum 1.6 GHz-es, a memória legalább 2048 MB-os, valamint a merevlemez nagyobb, mint 160 GB. Ezek a számítógépek korszerűek?
Számítógép szg3: AMD, 2.8 GHz, 3072 MB, 500 GB
Számítógép szg4: Intel, 2.6 GHz, 1024 MB, 320 GB
Megoldás

15.3.2. Származtassunk a Notebook osztályból egy Pda osztályt! Az új osztály objektumai a notebook tulajdonságain kívül egy új - egész értékű - súly adattaggal is rendelkeznek, amely a pda súlyát tárolja grammban kifejezve. Készítsünk az új adattaghoz lekérdező és beállító metódust, valamint az osztályhoz egy konstruktort, amellyel mindegyik adattagjának kezdőérték adható!
Megoldás

15.3.3. Definiáljuk felül a Pda osztály Notebook osztálytól örökölt toString() metódusát úgy, hogy az örököltek mellett a súly adattagot is jelenítse meg, valamint a hdd adattag neve "HDD" helyett "háttértár" legyen!  Az alábbi pda példányt hozzuk létre, és jelenítsük meg a képernyőn!
Pda p1: Samsung, 0.4 GHz, 512 MB, 64 GB, 3 óra, 125 g
Megoldás

15.3.4. Módosítsuk a Számítógép osztály korszerű() metódusát úgy, hogy az alábbi feltételek teljesülése esetén a Notebook és a Pda osztály példányait is - a kategóriájuknak megfelelő paraméterekhez viszonyítva - minősíteni tudjuk! Jelenítsük meg a képernyőn a már létező nb1, nb2 és p1 példányok minősítését!
Korszerűek, ha teljesítik az alábbi paramétereket:
  CPU sebesség (GHz) RAM (MB) Háttértár (GB) Üzemidő (óra) Súly (g)
notebook >1 >=1024 >=120 >=3
pda >0.3 >=128 >=16 >=2.5 <150
Megoldás