O B J E K T U M O R I E N TÁ LT P R O G R A M O Z Á S P É L D ATÁ R

(1)

O B J E K T U M O R I E N T Á L T P R O G R A M O Z Á S

P É L D A T Á R

I N F O R M A T I K U S F E L S Ő O K T A T Á S I S Z A K K É P Z É S I S Z A K O S O K N A K

(2)

Lektorálta: Tóth Attila

Jelen tananyag a Szegedi Tudományegyetemen készült az Európai Unió támogatásával. Projekt azonosító: EFOP- 3.4.3-16-2016-00014

A feladatgyűjtemény a Tufte-Style Book latex sablon segítségével készült: http://www.latextemplates.com/

template/tufte- style- book

(3)

1 Vezérlési szerkezetek 7

2 Metódusok 25

3 Rekurzív metódusok 37

4 Egyszerű objektumok 41

5 Objektumok metódusai 53

6 Csomagok és láthatóságok 63

7 Öröklődés 93

(4)

(5)

A példatár az Objektumorientált programozás című tantárgy szemináriumának anyagához kapcsolódó gyakorló feladatokat és azok megoldását tartalmazza. A tantárgy előfeltétele a programozás alapjainak ismerete, így feltételezzük, hogy a hallgatók ekkor már tisztában vannak a legalapvetőbb programozási módszerekkel, ismerik a változók, adattípusok, kife- jezések, azonosítók, vezérlési szerkezetek és metódusok fogalmát. Ugyancsak feltételezzük alapvető összetettebb adatstruktúrák, mint például a tömb ismeretét. A programozás techni- káinak elsajátításához fontos az algoritmikus gondolkodás megtanulása. Véleményünk szerint ez elsősorban úgy lehetséges, hogy sok feladat megoldásán keresztül fejlesztjük ezt a képes- ségünket. Ehhez kívánunk segítséget nyújtani ezzel a feladatgyűjteménnyel. A feladatokat témák szerint csoportosítottuk. Az első részben a vezérlési szerkezetek, majd a metódusok használatához kapcsolódó feladatok találhatók. Ezek megoldásához még nem szükséges az objektumorientált technikák használata, így azok számára is hasznos lehet, akik csak a prog- ramozás alapjaival ismerkednek. A következő fejezetek már az objektumorientált módsze- rekhez kapcsolódnak, követve az egyszerűbbtől a bonyolultabbak felé történő haladás elvét.

Először egyszerűbb objektumok megvalósítását igénylő feladatok, majd az objektumok me- tódusaihoz kapcslódó példák is találhatók. A példatár második részében már komplexebb feladatok vannak, amelyek egymáshoz szorosan kapcsolódó kisebb részfeladatokból állnak és általában a teljes megoldás egy összetettebb program. Ezek a feladatok általában az objek- tumorientált programozás fejlettebb technológiáinak - mint például az öröklődés - ismeretét is igénylik. Minden feladat után megtalálható a megoldás Java nyelven megírt kód formájá- ban, így a hallgatók közvetlen módon ellenőrizhetik saját megoldásukat. Reményeink szerint a példatár segítséget nyújt a hallgatóknak a programozási ismereteik elmélyítésében. A prog- ramozási ismeretek alapvető kompetenciái közül a példatár különösen fejlesztheti az alkal- mazásfejlesztés és tesztelés módszertanának elsajátítását, a legalapvetőbb feladat-megoldási elvek, módszerek, a fő szoftverfejlesztési paradigmák, alapvető programozási módszertanok használatának technikáit. Fejlesztheti az informatikai feladatok megoldásához szükséges együttműködésre, egyéni és team munkában való hatékony munkavégzésre való képességet.

A következőkben részletezzük, hogy az egyes fejezetek hogyan járulnak hozzá a tantárggyal kapcsolatosan megfogalmazott kompetenciák fejlesztéséhez. Az első fejezet a vezérlési sze- rekezetekkel kapcsolatos feladatokat tartalmazza. Ezek a feladatok hozzásegítik a hallgatót, hogy rendelkezzen az információrendszerekkel, adatbázisokkal és programozással kapcsolatos alapismeretekkel. Így képes lesz vállalati, üzleti folyamatokhoz kapcsolódó egyszerű tervezési, programozási feladatok elvégzésére. Megsmeri a legfontosabb vezérlőszerkezeteket, így a sze- lekciókat és az iterációkat, a megoldásokban szelekciós és iterációs utasításokat alkalmaz. A

(6)

2

feladatok hozzásegítik ezek pontos megvalósításához, így képes lesz ezek önálló használatára.

A második fejezet fő témája a metódusok, amelyeket nevezhetünk elemi informatikai rend- szerkomponenseknek is. Az itt szereplő feladatokat megoldva a hallgató megismeri az infor- matika alapvető technikáit, az informatikai rendszerkomponensek szerepét, feladatát és mű- ködését. Így képes és nyitott lesz az új informatikai technológiák, programnyelvek és módsze- rek megismerésére. Gyakorolhatja az önálló és csapatmunkát is, megismeri ezek korlátait. A feladatok megoldása által a hallgató megismeri a metódusokat, a metódusok felépítését, azok lokális változóinak szerepét, ezeket alkalmazni tudja, a pontos és önálló munkára való képes- sége fejlődik. A harmadik fejezet speciálisan a rekurzív metódusokkal foglalkozik. A feladatok segítségével a hallgató megismeri a rekurziót, a megoldások során rekurzív metódusokat alkalmaz, igyekszik ezeket pontosan használni és be kell tartania a rekurzív metódushívás szabályait. A negyedik fejezet az egyszerű objektumokra vezető feladatokat tartalmaz.Ezen feladatok által a hallgató megismeri a fejlesztési módszertanok szerepét, és egy fontos mód- szertant használ. Képes lesz objektumorientált programok implementációjára legalább egy programnyelven és fejlesztési környezetben. Ezáltal képes lesz szakmai együttműködésben rendszertervezési, -fejlesztési részfeladatok elvégzésére, dokumentálására. Így munkájáért fe- lelősséget kell vállalnia önálló feladatvégzésnél és csoportmunkában egyaránt. A feladatok megoldásával a hallgató tisztában lesz az osztályok valamint az objektumok használatával, készítésével (referenciatípus fogalma, objektum létrehozása, deklarálása). Munkája során egyszerűbb osztályokat és objektumokat készít, objektumokat deklarál, törekszik ezek pre- cíz használatára, a megoldások segítségével munkáját önállóan tudja ellenőrizni. Az ötödik fejezet az objektumok metódusaihoz kapcsolódó feladatokból áll. Ezek megoldásával a hall- gató megismeri a felhasználói követelmények feltárásának és elemzésének alapvető technikáit, módszereit. Képes lesz szakmai vélemény kialakítására a szoftverfejlesztéshez szükséges tech- nológiák, hardver és szoftver eszközök kiválasztása során.Ezáltal nyitott lesz a képesítésével, szakterületével kapcsolatos szakmai, technológiai, fejlesztési eredmények megismerésére, befo- gadására, és törekszik saját tudásának megosztására. Önálló lesz a munkájához kapcsolódó előírások betartásában és a vonatkozó dokumentumok elkészítésében. A feladatokon keresz- tül a hallgató megismeri az osztály fogalmát, felépítését, deklarációit, valamint az osztálytag és példánytag fogalmát. A megoldás során osztály- és példánytagokat tartalmazó osztályokat hoz létre. Ezáltal nyitott lesz az objektumok különböző módszerekkel történő létrehozására, az objektumok különböző célú alkalmazására. Képes lesz a program hibáinak megtalálásá- ra és az önálló javításra. A hatodik fejezet a csomagokkal és a láthatóságokkal foglalkozó feladatokat tartalmaz.A hallgató így megismeri a fejlesztői és felhasználói dokumentációk készítésének alapvető módszertani eszközeit. Képes lesz alapvető szoftverfejlesztési techno- lógiák alkalmazására, valamint fejlesztői és felhasználói dokumentációk készítésére. Ezáltal megérti az élethosszig tartó tanulás jelentőségét, törekszik ennek megvalósítására, a folyama- tos szakmai képzésre és általános önképzésre. Tudatában lesz az általa használt és működ- tetett informatikai eszközparkok értékének és jelentőségének, azokért személyes felelősséget vállal.A hallgató a feladatok segítségével megsmeri az azonosító, hi-vatkozási kör, takarás, alapértelmezés szerinti kezdeti érték, this objektumreferencia, konstruktor valamint az ini- cializálók fogalmát. A fejlesztőrendszerben objektumokat inicializál, konstruktorokat hoz létre, objektumokat a referenciájukkal kezel. Elkötelezett lesz az objektumok és referenciáik pontos használata iránt. Önállóan végez elemi objektumokkal kapcsolatos műveleteket, para-

(7)

méterátadás t és ezeket önállóan, pontosan kódolja. A hetedik fejezet feladatai az öröklődés témájához tartoznak. A hallgató ezek által tisztában lesz az öröklődés, a típuskonverziók, az utódosztály adatai és kapcsolatai, a metódus felülírása, a dinamikus és statikus kötés, a konstruktorláncolás technikájával, valamint a polimorfizmus, absztrakt metódus, absztrakt osztály, láthatóság, interfészek és belső osztályok fogalmával. Megismeri az alapvető kivételkezelés eljárásokat (továbbadás, elkapás, lekezelés), valamint az állománykezelést, a folyamokat (bájtfolyam, karakterfolyam, adatfolyam, objektumfolyam). Megismeri továbbá a legfontosabb osztályokat, interfészeket, kollekciókat. Munkája során megérti és használja az osztályok örököltetését, a típuskonverzió technikáját. Felismeri a dinamikus és statikus kö- tést. Alkalmazza a konstruktorok láncolását. Igyekszik meghatározni az objektumok adatait, szem előtt tartja, hogy az öröklődés milyen esetekben alkalmazható. Önállóan meg tudja határozni az egyes objektumok konstruktorait. Felismeri a polimorfizmust, absztrakt osz- tályt és metódust készít, képes lesz interfészt implementálni. Törekszik a pontos kódolásra a polimorfizmus és az interfészek használata során. Figyelembe veszi a különböző lehetősége- ket, elkötelezett az interfészek használata iránt.Betartja az absztrakt osztály használatának szabályait. Korrigálja saját hibáit. Képes lesz alapvető kivételkezelő eljárások elkészítésére, saját kivételek létrehozására. Jártas lesz az állománykezeléssel kapcsolatos feladatok meg- oldásában. Képes lesz objektumokat szerializálni. Jártas lesz a leggyakrabban alkalmazott osztályok használatában. Érdeklődik a valós élet problémái iránt, belátja az objektumori- entált programozás hasznosságát. Kíváncsi lesz az állománykezeléssel kapcsolatos feladatok megoldására, nyitott a különböző megoldási módszerekre. Belátja, hogy milyen feladatoknál milyen osztályokat, kollekciókat érdemes használni. Végül önállóan készít objektumorientált programokat, képes lesz az önellenőrzésre és a hibák önálló javítására. Önállóan alkalmazza a kollekciókat az objektumorientált programokban.

A tantárggyal a következő konkrét tanulási eredmények alakíthatóak ki:

Tudás Képesség Attitűd Autonómia/

felelősség Ismeri a legfonto-

sabb vezérlőszer- kezeteket, így a szelekciókat és az iterációkat.

Szelekciós és iterá- ciós utasításokat alkalmaz az elkészí- tett kódban.

Törekszik a szelek- ciók és iterációk pontos megvalósítá- sára.

Képes önállóan szelekciós és ite- rációs utasítások használatára.

Ismeri a metóduso- kat, a metódusok felépítését, azok lokális változóinak szerepét, valamint a rekurziót.

Rekurzív metóduso-

kat alkalmaz. Igyekszik a rekurzív metódusok pontos használatára.

Betartja a rekur- zív metódushívás szabályait.

(8)

4

felelősség Legyen tisztában az

osztályok valamint az objektumok használatával, ké- szítésével (referen- ciatípus, objektum létrehozása, dekla- rálása)

Egyszerűbb osz- tályokat és objektumokat készít, objektumokat deklarál.

Törekszik az objektumok és az osztályok precíz használatára.

A példatár segít- ségével önállóan ellenőrzi a munká- ját.

Ismeri az osztály fogalmát, felépíté- sét, deklarációit, valamint az osztály- tag és példánytag fogalmát.

Osztály- és pél- dánytagokat tartal- mazó osztályokat hoz létre.

Nyitott az objektumok különböző módszerekkel tör- ténő létrehozására, az objektumok különböző célú alkalmazására.

Önállóan megta- lálja és javítja a program hibáit.

Ismeri az azonosító, hivatkozási kör, takarás, alapér- telmezés szerinti kezdeti érték, this objektumreferencia, konstruktor valamint az iniciali- zálók fogalmát.

Fejlesztőrendszerben objektumokat ini- cializál, konstruktorokat létrehoz, objektumokat a referenciájukkal kezel.

Elkötelezett az objektumok és re- ferenciáik pontos használata iránt.

Önállóan végez elemi objektumokkal kapcsolatos műveleteket, pa- raméterátadást és ezeket önállóan, pontosan kódolja.

Tisztában van az öröklődés, a tí- puskonverziók, az utódosztály adatai és kapcsolatai, a metódus felülírá- sa, a dinamikus és statikus kötés, valamint a konst- ruktorláncolás technikájával.

Megérti és hasz- nálja az osztályok örököltetését, a típuskonverzió technikáját. Felis- meri a dinamikus és statikus kö- tést. Alkalmazza a konstruktorok láncolását.

Törekszik az objektumok adatainak pontos meghatá- rozására. Szem előtt tartja, hogy az öröklődés milyen esetekben alkalmazható.

Önállóan megha- tározza az egyes objektumok konstruktorait.

(9)

felelősség Tisztában van a

polimorfizmus, absztrakt metó- dus, absztrakt osztály, látható- ság, interfészek és belső osztályok fogalmával.

Felismeri a polimorfizmust. Absztrakt osztályt és metó- dust készít. Képes interfészt imple- mentálni.

Törekszik a pontos kódolásra a polimorfizmus és az interfészek használata során.

Figyelembe veszi a különböző lehetősé- geket, elkötelezett az interfészek hasz- nálata iránt.

Betartja az absztrakt osztály haszná- latának szabályait.

Korrigálja saját hibáit.

Ismeri az alapve- tő kivételkezelés eljárásokat (to- vábbadás, elkapás, lekezelés).

Képes alapvető kivételkezelő eljá- rások elkészítésére, saját kivételek létrehozására.

Érdeklődik a va- lós élet problémái iránt, belátja az objektumorien- tált programozás hasznosságát.

Önállóan készít objektumorientált programokat.

Ismeri az állomány- kezelést, a folyamokat (bájtfolyam, karakterfolyam, adatfolyam, objektumfolyam).

Jártas az állo- mánykezeléssel kapcsolatos feladatok megoldásában.

Objektumokat szerializál.

Kíváncsi az állo- mánykezeléssel kapcsolatos feladatok megoldására.

Nyitott a külön- böző megoldási módszerekre.

Önállóan ellenőr- zi, és amennyiben szükséges, javítja a munkáját.

Ismeri a legfontosabb osztályokat, interfészeket (pl. java.util vagy java.io csomag elemei).

Jártas a leggyakrabban alkalmazott osztályok, kollekci- ók használatában (pl. java.util vagy

java.io csomag osz- tályai és kollekciói).

Belátja, hogy milyen feladatoknál milyen osztályo- kat, kollekciókat érdemes használni.

Önállóan alkalmazza a kollekciókat az objektumorientált programokban.

(10)

(11)

1. A program olvasson be tetszőleges egész számot parancssori argumentumból, és határozza meg azok minimumát. Szóljon, ha ehhez nincs elég (legalább 2) bemenet.

1 p u b l i c c l a s s F e l a d a t 1 _ 1 {

2 p u b l i c s t a t i c void m a i n ( S t r i n g [] a r g s ) {

3 i f( a r g s . length <2) {

4 S y s t e m . out . p r i n t l n (" N i n c s e l e g b e m e n e t ! ") ;

5 S y s t e m . e x i t (0) ;

6 }

7 i n t min = I n t e g e r . M A X _ V A L U E ;

8 f o r(i n t i =0; i < a r g s . l e n g t h ; i ++) {

9 i n t act = I n t e g e r . p a r s e I n t ( a r g s [ i ]) ;

10 i f( act < min ) {

11 min = act ;

12 }

13 }

14 S y s t e m . out . p r i n t l n (" A l e g k i s e b b s z a m : "+ min ) ;

15 }

16 }

Feladat_1_1 megoldása.

2. A program olvasson be tetszőleges egész számot parancssori argumentumból, és határozza meg azok maximumát. Szóljon, ha ehhez nincs elég (legalább 2) bemenet.

3 i f( a r g s . length <2) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t max = I n t e g e r . M I N _ V A L U E ;

(12)

8 objektumorientált programozás példatár

10 i f( act > max ) {

11 max = act ;

12 }

13 }

14 S y s t e m . out . p r i n t l n (" A l e g n a g y o b b s z a m : "+ max ) ;

15 }

16 }

3. A program olvasson be tetszőleges egész számot parancssori argumentumból, és határozza meg azok összegét. Szóljon, ha ehhez nincs elég (legalább 2) bemenet.

3 i f( a r g s . length <2) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t sum =0;

10 sum += act ;

11 }

12 S y s t e m . out . p r i n t l n (" A s z a m o k o s s z e g e : "+ sum ) ;

13 }

14 }

4. A program olvasson be tetszőleges egész számot parancssori argumentumból, és határozza meg azok átlagát. Szóljon, ha ehhez nincs elég (legalább 2) bemenet.

3 i f( a r g s . length <2) {

5 S y s t e m . e x i t (0) ;

6 }

7 double sum =0;

9 double act = D o u b l e . p a r s e D o u b l e ( a r g s [ i ]) ;

(13)

10 sum += act ;

11 }

12 double a v e r a g e = sum / a r g s . l e n g t h ;

13 S y s t e m . out . p r i n t l n (" A s z a m o k a t l a g a : "+ a v e r a g e ) ;

14 }

15 }

5. A program olvasson be tetszőleges egész számot parancssori argumentumból, és határozza meg a beolvasott pozitív számok minimumát, valamint a negatív számok maximumát.

Szóljon, ha ehhez nincs elég (legalább 2) bemenet.

3 i f( a r g s . length <2) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t p o s m i n = I n t e g e r . M A X _ V A L U E ;

8 i n t n e g m a x = I n t e g e r . M I N _ V A L U E ;

11 i f( act > = 0 ) {

12 i f( act < p o s m i n ) {

13 p o s m i n = act ;

14 }

15 }e l s e{

16 i f( act > n e g m a x ) {

17 n e g m a x = act ;

18 }

19 }

20 }

21 S y s t e m . out . p r i n t l n (" A p o z i t i v s z a m o k m i n i m u m a : "+ p o s m i n ) ;

22 S y s t e m . out . p r i n t l n (" A n e g a t i v s z a m o k m a x i m u m a : "+ n e g m a x ) ;

23 }

24 }

6. A program olvasson be tetszőleges egész számot parancssori argumentumból, és számolja meg, hogy összesen hány pozitív számot olvasott be. Szóljon, ha nem kap bemeneti para- métereket.

(14)

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t c o u n t =0;

10 i f( act > = 0 ) {

11 c o u n t ++;

12 }

13 }

14 S y s t e m . out . p r i n t l n (" A p o z i t i v s z a m o k d a r a b s z a m a : "+ c o u n t ) ;

15 }

16 }

7. A program olvasson be tetszőleges egész számot parancssori argumentumból, és számolja meg, hogy összesen hány negatív számot olvasott be. Szóljon, ha nem kap bemeneti para- métereket.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t c o u n t =0;

10 i f( act <0) {

11 c o u n t ++;

12 }

13 }

14 S y s t e m . out . p r i n t l n (" A n e g a t i v s z a m o k d a r a b s z a m a : "+ c o u n t ) ;

15 }

16 }

(15)

8. A program olvasson be tetszőleges egész számot parancssori argumentumból, és számolja meg, hogy összesen hány nullát olvasott be. Szóljon, ha nem kap bemeneti paramétereket.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t c o u n t =0;

10 i f( act = = 0 ) {

11 c o u n t ++;

12 }

13 }

14 S y s t e m . out . p r i n t l n (" A n u l l a k d a r a b s z a m a : "+ c o u n t ) ;

15 }

16 }

9. A program olvasson be tetszőleges egész számot parancssori argumentumból, és írja ki, hogy a páratlan, vagy a páros számok összege a nagyobb.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t e v e n s u m =0;

8 i n t o d d s u m =0;

11 i f( act % 2 = = 0 ) {

12 e v e n s u m += act ;

13 }e l s e{

14 o d d s u m += act ;

15 }

16 }

17 i f( evensum > o d d s u m ) {

18 S y s t e m . out . p r i n t l n (" A p a r o s s z a m o k o s s z e g e a n a g y o b b . ") ;

(16)

19 }e l s e i f( oddsum > e v e n s u m ) {

20 S y s t e m . out . p r i n t l n (" A p a r a t l a n s z a m o k o s s z e g e a n a g y o b b . ") ;

21 }e l s e{

22 S y s t e m . out . p r i n t l n (" A p a r o s es a p a r a t l a n s z a m o k o s s z e g e e g y e n l o . ") ;

23 }

24 }

25 }

10. A program olvasson be két egész számot (x és y) parancssori argumentumból. Írja ki az x és y között található összes egész számot (x -> y felé haladva), valamint szóljon, ha a bemenet nem megfelelő formátumú (itt több problémát is vizsgálni kell).

1 p u b l i c c l a s s F e l a d a t 1 _ 1 0 {

3 i f( a r g s . l e n g t h ! = 2 ) {

4 S y s t e m . out . p r i n t l n (" Nem m e g f e l e l o s z a m u b e m e n e t . ") ;

5 S y s t e m . e x i t (0) ;

6 }

7 i n t x = I n t e g e r . p a r s e I n t ( a r g s [ 0 ] ) ;

8 i n t y = I n t e g e r . p a r s e I n t ( a r g s [ 1 ] ) ;

9 i f( y <= x ) {

10 S y s t e m . out . p r i n t l n (" A m a s o d i k s z a m n a k n a g y o b b n a k k e l l l e n n i e . ") ;

11 S y s t e m . e x i t (0) ;

12 }

13 S y s t e m . out . p r i n t ( x +" es "+ y +" k o z o t t i s z a m o k : ") ;

14 f o r(i n t i = x +1; i < y ; i ++) {

15 S y s t e m . out . p r i n t ( i +" ") ;

16 }

17 }

18 }

11. Számtani sorozat (egész számokból) első n elemének kiszámolása tömb segítségével. A program a sorozat kezdőelemét, a differenciát, illetve n értékét parancssori argumentumból olvassa, valamint szóljon, ha nem megfelelő a bemeneti paraméterek száma.

3 i f( a r g s . l e n g t h != 3) {

(17)

5 S y s t e m . e x i t (0) ;

6 }

7 i n t f i r s t = I n t e g e r . p a r s e I n t ( a r g s [ 0 ] ) ;

8 i n t d i f f = I n t e g e r . p a r s e I n t ( a r g s [ 1 ] ) ;

9 i n t n = I n t e g e r . p a r s e I n t ( a r g s [ 2 ] ) ;

10 i n t[] p r o g r e s s i o n = new i n t[ n ];

11 p r o g r e s s i o n [ 0 ] = f i r s t ;

12 f o r(i n t i =1; i < p r o g r e s s i o n . l e n g t h ; i ++) {

13 p r o g r e s s i o n [ i ]= p r o g r e s s i o n [ i - 1 ] + d i f f ;

14 }

15 S y s t e m . out . p r i n t (" A s o r o z a t e l e m e i : ") ;

17 S y s t e m . out . p r i n t ( p r o g r e s s i o n [ i ]+" ") ;

18 }

19 }

20 }

12. Mértani sorozat (egész számokból) első n elemének kiszámolása tömb segítségével. A program a sorozat kezdőelemét, a kvócienst, illetve n értékét parancssori argumentumból olvassa, valamint szóljon, ha nem megfelelő a bemeneti paraméterek száma.

3 i f( a r g s . l e n g t h != 3) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t f i r s t = I n t e g e r . p a r s e I n t ( a r g s [ 0 ] ) ;

8 i n t r = I n t e g e r . p a r s e I n t ( a r g s [ 1 ] ) ;

10 i n t[] p r o g r e s s i o n = new i n t[ n ];

11 p r o g r e s s i o n [ 0 ] = f i r s t ;

13 p r o g r e s s i o n [ i ]= p r o g r e s s i o n [ i - 1 ] * r ;

14 }

15 S y s t e m . out . p r i n t (" A s o r o z a t e l e m e i : ") ;

17 S y s t e m . out . p r i n t ( p r o g r e s s i o n [ i ]+" ") ;

18 }

(18)

19 }

20 }

13. Fibonacci sorozat első n elemének kiszámítása tömb segítségével. n értékét a program parancssori argumentumként kérje, és szóljon, ha nem pontosan egy paramétert kapott.

3 i f( a r g s . l e n g t h ! = 1 ) {

4 S y s t e m . out . p r i n t l n (" Nem m e g f e l e l o s z a m u p a r a m e t e r ! ") ;

5 S y s t e m . e x i t (0) ;

6 }

8 i n t[] f i b o =new i n t[ n ];

9 f i b o [ 0 ] = 1 ;

10 f i b o [ 1 ] = 1 ;

11 f o r(i n t i =2; i < f i b o . l e n g t h ; i ++) {

12 f i b o [ i ]= f i b o [ i - 1 ] + f i b o [ i - 2 ] ;

13 }

14 S y s t e m . out . p r i n t (" A F i b o n a c c i s o r o z a t e l e m e i : ") ;

15 f o r(i n t i =0; i < f i b o . l e n g t h ; i ++) {

16 S y s t e m . out . p r i n t ( f i b o [ i ]+" ") ;

17 }

18 }

19 }

14. Tetszőleges számú szó beolvasása parancssori argumentumból. A program számolja meg, hogy milyen hosszúságú szóból mennyi van, ezeket az értékeket tárolja tömbben (pl. 1 hosszú szó 3 db, 2 hosszú szó 0 db, 3 hosszú szó 4 db, stb.). A kapott értékeket írja ki, valamint szóljon, ha nincs megadva bemeneti szó.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t m a x l e n g t h =0;

9 i f( a r g s [ i ]. l e n g t h () > m a x l e n g t h ) {

(19)

10 m a x l e n g t h = a r g s [ i ]. l e n g t h () ;

11 }

12 }

13 i n t[] s i z e d i s t =new i n t[ m a x l e n g t h + 1 ] ;

15 s i z e d i s t [ a r g s [ i ]. l e n g t h () ] + + ;

16 }

17 f o r(i n t i =1; i < s i z e d i s t . l e n g t h ; i ++) {

18 S y s t e m . out . p r i n t l n ( i +" h o s s z u s z a v a k s z a m a : "+ s i z e d i s t [ i ]) ;

19 }

20 }

21 }

15. A program olvasson be 3 számot parancssori argumentumból. Szóljon, ha nincs elég beme- ne. Döntse el, hogy a számok lehetnek -e egy háromszög oldalhosszai. Ha igen, számolja ki annak keürletét és területét. A terület kiszámítására alkalmazza Heron képletét:

T =^q(s∗(s−a)∗(s−b)∗(s−c))_{, ahol} s a kerület fele.

3 i f( a r g s . l e n g t h ! = 3 ) {

5 S y s t e m . e x i t (0) ;

6 }

7 double a = D o u b l e . p a r s e D o u b l e ( a r g s [ 0 ] ) ;

8 double b = D o u b l e . p a r s e D o u b l e ( a r g s [ 1 ] ) ;

9 double c = D o u b l e . p a r s e D o u b l e ( a r g s [ 2 ] ) ;

10 double s = ( a + b + c ) /2;

11 i f( a + b > c && a + c > b && b + c > a ) {

12 double a r e a = M a t h . s q r t ( s *( s - a ) *( s - b ) *( s - c ) ) ;

13 S y s t e m . out . p r i n t l n (" A h a r o m s z o g t e r u l e t e : "+ a r e a ) ;

14 }e l s e{

15 S y s t e m . out . p r i n t l n (" A k a p o t t s z a m o k nem l e h e t n e k egy h a r o m s z o g o l d a l a i . ") ;

16 }

17 }

18 }

16. A program olvasson be egy n egész számot parancssori argumentumból. Szóljon, ha nincs bemenet. Dobjon egy hatoldalú kockával n alkalommal (véletlenszerű értékeket), és ment-

(20)

se tömbbe, hogy az egyes értékeket hányszor dobta ki. Ezután írja ki, hogy az különböző értékek az dobások hány százalékában fordultak elő.

3 i f( a r g s . l e n g t h ! = 1 ) {

5 S y s t e m . e x i t (0) ;

6 }

8 i n t[] r e s u l t s = new i n t[ 6 ] ;

9 f o r(i n t i =0; i < n ; i ++) {

10 i n t r a n d o m =(i n t) ( M a t h . r a n d o m () * 6 + 1 ) ;

11 r e s u l t s [ random - 1 ] + + ;

12 }

13 f o r(i n t i =0; i < r e s u l t s . l e n g t h ; i ++) {

14 S y s t e m . out . p r i n t l n (( r e s u l t s [ i ]/(double) n * 1 0 0 ) +" % ") ;

15 }

16 }

17 }

17. A program olvasson be legalább 2 számot parancssori argumentumból, és szóljon, ha nincs elég bemenet. Vizsgálja meg, hogy a kapott számok sorrendje nővekvő, csökkenő, vagy egyik sem, és ezt írja ki.

3 i f( a r g s . length <2) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t c o u n t e r =0;

9 i f( I n t e g e r . p a r s e I n t ( a r g s [ i - 1 ] ) < I n t e g e r . p a r s e I n t ( a r g s [ i ]) ) {

10 c o u n t e r ++;

11 }e l s e i f ( I n t e g e r . p a r s e I n t ( a r g s [ i - 1 ] ) > I n t e g e r . p a r s e I n t ( a r g s [ i ]) ) {

12 counter - -;

13 }

14 }

15 i f( c o u n t e r ==( a r g s . length -1) ) {

(21)

16 S y s t e m . out . p r i n t l n (" A s o r o z a t n o v e k v o ") ;

17 }e l s e i f( c o u n t e r == -( a r g s . length -1) ) {

18 S y s t e m . out . p r i n t l n (" A s o r o z a t c s o k k e n o ") ;

19 }e l s e{

20 S y s t e m . out . p r i n t l n (" E g y i k sem ") ;

21 }

22 }

23 }

18. Beérkező rendelések összértékét szeretnénk meghatározni. Ehhez parancssorról a rendelé- sek sorszámait kapjuk meg, ami tetszőleges darab egész szám formájában jön. Négy külön- böző rendelésünk van, az 1-es 1000 Ft, 2-es 5000 Ft, 3-as 7000 Ft és a 4-es 9000 Ft. Egy rendelés sorszáma többször is szerepelhet. Adjuk össze az érkező sorszámoknak megfelelő értékeket, és az összeget írjuk ki. Ha olyan szám szerepel, ami nem rendes sorszám (nem 1,2,3,4), akkor minden esetben írjuk ki konzolra, hogy "Nem megfelelo sorszam". A program szóljon, ha nincs legalább 1 bemenet.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t sum =0;

9 i n t a c t u a l = I n t e g e r . p a r s e I n t ( a r g s [ i ]) ;

10 switch( a c t u a l ) {

11 c a s e 1: sum + = 1 0 0 0 ; break;

12 c a s e 2: sum + = 5 0 0 0 ; break;

13 c a s e 3: sum + = 7 0 0 0 ; break;

14 c a s e 4: sum + = 9 0 0 0 ; break;

15 d e f a u l t: S y s t e m . out . p r i n t l n (" Nem m e g f e l e l o s o r s z a m ") ;

16 }

17 }

18 S y s t e m . out . p r i n t l n (" A r e n d e l e s e k o s s z e r t e k e : "+ sum ) ;

19 }

20 }

19. Készítsünk programot, ami kiszámolja egy szabályos sokszög kerületét. A program két bemenetet vár parancssori argumentumból: a sokszög oldalainak a számát, valamint az

(22)

oldalhosszat. A probléma csak az, hogy a programozási nyelvünkben "elromlott" a szorzás, így ezt a műveletet nem használhatjuk a feladat megoldása során. A program szóljon, ha nem 2 bemenetet kapott.

3 i f( a r g s . l e n g t h ! = 2 ) {

5 S y s t e m . e x i t (0) ;

6 }

8 i n t l e n g t h = I n t e g e r . p a r s e I n t ( a r g s [ 1 ] ) ;

9 i n t r e s u l t =0;

10 f o r(i n t i =0; i < n ; i ++) {

11 r e s u l t = r e s u l t + l e n g t h ;

12 }

13 S y s t e m . out . p r i n t l n (" A s o k s z o g k e r u l e t e : "+ r e s u l t ) ;

14 }

15 }

20. Egy könyv olvasása közben kíváncsiak leszünk, hogy melyik lehet a benne található leghosszabb szó, ezért készítünk egy programot, ami eldönti ezt nekünk. A program a könyv- ben található szavakat kapja bemenetnek parancssori argumentumból (tetszőleges mennyi- ségű szó). Írjuk ki, hogy melyik a bemenetben található leghosszabb szó (ha több leg- hosszabbat is találunk, akkor bármelyiket kiírhatjuk). A program szóljon, ha nem kapott bemenetet.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t m a x l e n g t h =0;

8 S t r i n g m a x s t r i n g = new S t r i n g () ;

10 i f( a r g s [ i ]. l e n g t h () > m a x l e n g t h ) {

11 m a x s t r i n g = a r g s [ i ];

12 m a x l e n g t h = a r g s [ i ]. l e n g t h () ;

13 }

14 }

(23)

15 S y s t e m . out . p r i n t l n (" A l e g h o s s z a b b szo : "+ m a x s t r i n g ) ;

16 }

17 }

21. Matek ZH-ra készülés közben elromlott a számológépünk, ezért elhatározzuk, hogy írunk egy programot, ami helyettesíteni fogja. A számológépünk mindig két értéken végez el műveletet, ezért a program pontosan 3 bemenetet kapjon parancssori argumentumból: az első számot, az operátort, valamin a második számot (pl. 3 + 1). Írjuk ki, hogy mi lesz a megadott kifejezés eredménye. A program szóljon, ha nem 3 bemenetet kapott. (tipp:

szorzásnál * helyett más karaktert használjunk bemenetnek, pl. x)

3 i f( a r g s . l e n g t h ! = 3 ) {

5 S y s t e m . e x i t (0) ;

6 }

7 double f i r s t = D o u b l e . p a r s e D o u b l e ( a r g s [ 0 ] ) ;

8 S t r i n g o p e r a t o r = a r g s [ 1 ] ;

9 double s e c o n d = D o u b l e . p a r s e D o u b l e ( a r g s [ 2 ] ) ;

10 double r e s u l t =0;

11 switch( o p e r a t o r ) {

12 c a s e " + ": r e s u l t = f i r s t + s e c o n d ; break;

13 c a s e " - ": r e s u l t = first - s e c o n d ; break;

14 c a s e " / ": r e s u l t = f i r s t / s e c o n d ; break;

15 c a s e " x ": r e s u l t = f i r s t * s e c o n d ; break;

16 d e f a u l t: S y s t e m . out . p r i n t l n (" N i n c s i l y e n m u v e l e t ") ;

17 }

18 S y s t e m . out . p r i n t l n (" Az e r e d m e n y : "+ r e s u l t ) ;

19 }

20 }

22. Az előző feladatban elkészített számológépünk nagyon jól működik, de rövidesen rájövünk, hogy hosszabb kifejezéseket is ki szeretnénk számolni. Írunk tehát egy új programot, ami az alábbi felépítésű bemenetet kapja: műveletek száma (n), kezdőérték, majd n*{operátor, operátorhoz tartozó érték}. (pl. 3 1 + 2 x 2 - 1 3 művelet, 1 a kezdőérték, és először +2-t végezzük el, majd *2-t, majd -1-t). A program számolja ki az így kapott műveletsor-

rend eredményét. A műveleteket abban a sorrendben hajtsa végre, ahogy a bemenetben szerepelnek. A program szóljon, ha nem megfelelő a bemenet.

(24)

3 i f( a r g s . length <3) {

5 S y s t e m . e x i t (0) ;

6 }

8 i f( a r g s . l e n g t h != n * 2 + 2 ) {

9 S y s t e m . out . p r i n t l n (" Nem m e g f e l e l o f o r m a t u m u b e m e n e t ! ") ;

10 S y s t e m . e x i t (0) ;

11 }

12 double r e s u l t = D o u b l e . p a r s e D o u b l e ( a r g s [ 1 ] ) ;

13 f o r(i n t i =2; i <2* n +1; i + = 2 ) {

14 S t r i n g o p e r a t o r = a r g s [ i ];

15 double n u m b e r = I n t e g e r . p a r s e I n t ( a r g s [ i + 1 ] ) ;

16 switch( o p e r a t o r ) {

17 c a s e " + ": r e s u l t = r e s u l t + n u m b e r ; break;

18 c a s e " - ": r e s u l t = result - n u m b e r ; break;

19 c a s e " / ": r e s u l t = r e s u l t / n u m b e r ; break;

20 c a s e " x ": r e s u l t = r e s u l t * n u m b e r ; break;

21 d e f a u l t: S y s t e m . out . p r i n t l n (" N i n c s i l y e n m u v e l e t ") ;

22 }

23 }

24 S y s t e m . out . p r i n t l n (" Az e r e d m e n y : "+ r e s u l t ) ;

25 }

26 }

23. Jancsi és Juliska az erdőben sétálva minden kereszteződésnél morzsákat szór el. Jancsi az első kereszteződésben 3 szemet, Juliska a második kereszteződésben 2 szemet. Minden további kereszteződésben annyi szemet szórnak el, mint az előző kettőben összesen. A sé- tájuk az n-edik kereszteződésben ér véget, ugyanis itt egy életnagyságú mézeskalács házzal találják szemben magukat, de mielőtt bemennek, még itt is elszórnak valamennyi morzsát.

Mennyi morzsát szórtak el a ház előtt? A kereszteződések számát (n értékét) parancssori argumentumból kapjuk bemenetnek. A program írja ki az utolsó kereszteződésben elszórt morzsa mennyiségét. A program szóljon, ha nem kapott bemenetet.

3 i f( a r g s . length <1) {

(25)

5 S y s t e m . e x i t (0) ;

6 }

8 i n t[] a r r a y =new i n t[ n ];

9 a r r a y [ 0 ] = 3 ;

10 a r r a y [ 1 ] = 2 ;

11 f o r(i n t i =2; i < a r r a y . l e n g t h ; i ++) {

12 a r r a y [ i ]= a r r a y [ i - 1 ] + a r r a y [ i - 2 ] ;

13 }

14 S y s t e m . out . p r i n t l n (" Az u t o l s o k e r e s z t e z o d e s b e n l e v o m o r z s a k s z a m a : "+ a r r a y [ n - 1 ] ) ;

15 }

16 }

24. Kisboltunkba egy szállítmány dinnye érkezik, amit átvétel előtt leellenőrzünk, lemérjük mindegyiket. A dinnyék súlyai lesznek a program bemenete, ezeket parancssori argumen- tumból olvassuk be (tetszőleges darab egész szám). Tudjuk, hogy ha egy dinnye súlya páros szám, és osztható 3-al is, akkor biztos rohadt lesz, ezeket nem szeretnénk átvenni. A program állapítsa meg a súlyok alapján, hogy hány problémás dinnye található a szállít- mányban. A program szóljon, ha nem kapott bemenetet.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t c o u n t =0;

9 i n t a c t u a l = I n t e g e r . p a r s e I n t ( a r g s [ i ]) ;

10 i f( a c t u a l % 2 = = 0 && a c t u a l % 3 = = 0 ) {

11 c o u n t ++;

12 }

13 }

14 S y s t e m . out . p r i n t l n (" A r o h a d t d i n n y e k s z a m a : "+ c o u n t ) ;

15 }

16 }

25. Készítsünk programot, ami megadott háromszögek közül kiválasztja, hogy melyiknek a legnagyobb a kerülete. A program parancssori argumentumból kapja a bemenetét az

(26)

alábbi módon: először a háromszögek darabszáma (n), utána hármasával az oldalhosszak (n*{oldal1 oldal2 oldal3}) következnek (pl. 2 1 2 3 3 3 4 2 háromszög, az egyik oldalai 1,2,3, a másik oldalai 3,3,4). Állapítsuk meg, hogy hanyadik háromszögnek a legnagyobb a kerülete. A program szóljon, ha nem megfelelő a bemenet.

3 i f( a r g s . length <3) {

5 S y s t e m . e x i t (0) ;

6 }

8 i f( a r g s . l e n g t h != n * 3 + 1 ) {

9 S y s t e m . out . p r i n t l n (" Nem m e g f e l e l o f o r m a t u m u b e m e n e t ! ") ;

10 S y s t e m . e x i t (0) ;

11 }

12 i n t c o u n t e r =1;

13 i n t m a x i t e m =1;

14 i n t max =0;

15 f o r(i n t i =1; i < n * 3 + 1 ; i + = 3 ) {

16 i n t act = I n t e g e r . p a r s e I n t ( a r g s [ i ]) + I n t e g e r . p a r s e I n t ( a r g s [ i + 1 ] ) + I n t e g e r . p a r s e I n t ( a r g s [ i + 2 ] ) ;

17 i f( act > max ) {

18 m a x i t e m = c o u n t e r ;

19 max = act ;

20 }

21 c o u n t e r ++;

22 }

23 S y s t e m . out . p r i n t l n (" A l e g n a g y o b b h a r o m s z o g s o r s z a m a : "+ m a x i t e m )

;

24 }

25 }

26. Reklámozni szeretnénk a legújabb termékünket, és készítünk egy programot, ami elektro- nikus hirdetőtáblaként megteszi ezt nekünk. A hirdetőtábla egymás után szövegeket fog kiírni a képernyőre: vagy a termék nevét, vagy a termék árát. A program 3 bemenetet kap parancssori argumentumból: az első a termék neve, a második a termék ára, a harmadik pedig egy szám, hogy összesen hány sort szeretnénk kiírni a táblára. Alapesetben a hirdetőtábla mindig a termék nevét írja ki, de minden 5. kiírás a termék árát fogja kiírni ehelyett. A program szóljon, ha nem 3 bemenetet kap.

(27)

3 i f( a r g s . l e n g t h ! = 3 ) {

5 S y s t e m . e x i t (0) ;

6 }

7 S t r i n g n a m e = a r g s [ 0 ] ;

8 i n t p r i c e = I n t e g e r . p a r s e I n t ( a r g s [ 1 ] ) ;

10 f o r(i n t i =1; i <= n ; i ++) {

11 i f( i % 5 = = 0 ) {

12 S y s t e m . out . p r i n t l n ( p r i c e ) ;

13 }e l s e{

14 S y s t e m . out . p r i n t l n ( n a m e ) ;

15 }

16 }

17 }

18 }

(28)

(29)

1. Készíts programot, amely a parancssori argumentumból tetszőleges darab egész számot olvas be. Szóljon, ha nincs legalább 1 bemenet, és lépjen ki. A programnak legyen egy me- tódusa, ami egy int tömböt vár paraméternek, és visszaadja a tömbben található számok összegét. Ezt a visszaadott értéket írja ki.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

7 i n t[] a r r a y =new i n t[ a r g s . l e n g t h ];

9 a r r a y [ i ]= I n t e g e r . p a r s e I n t ( a r g s [ i ]) ;

10 }

11 i n t r e s u l t = sum ( a r r a y ) ;

12 S y s t e m . out . p r i n t l n (" A t o m b b e n t a l a l h a t o s z a m o k o s s z e g e : "+

r e s u l t ) ;

13 }

14 p u b l i c s t a t i c i n t sum (i n t[] a r r a y ) {

15 i n t r e s u l t =0;

17 r e s u l t += a r r a y [ i ];

18 }

19 return r e s u l t ;

20 }

21 }

2. Készíts programot, amely a parancssori argumentumból tetszőleges darab egész számot

(30)

olvas be. Szóljon, ha nincs legalább 1 bemenet, és lépjen ki. A programnak legyen egy me- tódusa, ami egy int tömböt vár paraméternek, és visszaadja a tömbben található számok átlagát. Ezt a visszaadott értéket írja ki.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

10 }

11 double r e s u l t = m e a n ( a r r a y ) ;

12 S y s t e m . out . p r i n t l n (" A t o m b b e n t a l a l h a t o s z a m o k a t l a g a : "+ r e s u l t ) ;

13 }

14 p u b l i c s t a t i c double m e a n (i n t[] a r r a y ) {

15 double r e s u l t =0;

17 r e s u l t += a r r a y [ i ];

18 }

19 return r e s u l t / a r r a y . l e n g t h ;

20 }

21 }

3. Készíts programot, amely a parancssori argumentumból tetszőleges darab egész számot olvas be. Szóljon, ha nincs legalább 1 bemenet, és lépjen ki. A programnak legyen egy me- tódusa, ami egy int tömböt vár paraméternek, és visszaadja a tömbben található legkisebb elem értékét. Ezt a visszaadott értéket írja ki.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

(31)

10 }

11 i n t r e s u l t = min ( a r r a y ) ;

12 S y s t e m . out . p r i n t l n (" A t o m b b e n t a l a l h a t o l e g k i s e b b e l e m : "+

r e s u l t ) ;

13 }

14 p u b l i c s t a t i c i n t min (i n t[] a r r a y ) {

17 i f( a r r a y [ i ] < min ) {

18 min = a r r a y [ i ];

19 }

20 }

21 return min ;

22 }

23 }

4. Készíts programot, amely a parancssori argumentumból tetszőleges darab egész számot olvas be. Szóljon, ha nincs legalább 1 bemenet, és lépjen ki. A programnak legyen egy metódusa, ami egy int tömböt vár paraméternek, és visszaadja a tömbben található legnagyobb elem értékét. Ezt a visszaadott értéket írja ki.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

10 }

11 i n t r e s u l t = max ( a r r a y ) ;

12 S y s t e m . out . p r i n t l n (" A t o m b b e n t a l a l h a t o l e g n a g y o b b e l e m : "+ r e s u l t ) ;

13 }

14 p u b l i c s t a t i c i n t max (i n t[] a r r a y ) {

17 i f( a r r a y [ i ] > max ) {

18 max = a r r a y [ i ];

19 }

(32)

20 }

21 return max ;

22 }

23 }

5. Készíts programot, amely a parancssori argumentumból tetszőleges darab egész számot olvas be. Szóljon, ha nincs legalább 1 bemenet, és lépjen ki. A programnak legyen két metódusa: mindkettő egy-egy int tömböt vár paraméternek, és visszaadja a tömbben ta- lálható legkisebb, illetve legnagyobb elem értékét. A visszaadott értékekről döntse el, hogy a legnagyobb elem osztható -e a legkisebb elemmel, és írjon ki igen/nem szöveget ettől függően.

3 i f( a r g s . length <1) {

5 S y s t e m . e x i t (0) ;

6 }

10 }

11 i n t max = max ( a r r a y ) ;

12 i n t min = min ( a r r a y ) ;

13 i f( max % min = = 0 ) {

14 S y s t e m . out . p r i n t l n (" i g e n ") ;

15 }e l s e{

16 S y s t e m . out . p r i n t l n (" nem ") ;

17 }

18 }

19 p u b l i c s t a t i c i n t max (i n t[] a r r a y ) {

22 i f( a r r a y [ i ] > max ) {

23 max = a r r a y [ i ];

24 }

25 }

26 return max ;

27 }

28 p u b l i c s t a t i c i n t min (i n t[] a r r a y ) {