programozási technológiák

Programozási technológiákProgramozási technológiák

2009/10 őszi félév2009/10 őszi félév

1. Az OOP főbb jellemzői1. Az OOP főbb jellemzői

Órák, követelményÓrák, követelmény

Ea: 09.04 8-12 016Ea: 09.04 8-12 016 Gyak A:09.05 12-16 014;12.05 12-16 014Gyak A:09.05 12-16 014;12.05 12-16 014 Gyak B:09.11 13-17 014;11.14 11-15 014Gyak B:09.11 13-17 014;11.14 11-15 014

Programírás gépnél, Neptunban hirdetve, Programírás gépnél, Neptunban hirdetve, csak szintaktikailag helyes program kerül csak szintaktikailag helyes program kerül értékelésre, időtartama 30 perc. OOP értékelésre, időtartama 30 perc. OOP elveket be kell tartani. Segédeszköz: help, elveket be kell tartani. Segédeszköz: help, javadocjavadoc

Objektum, osztályObjektum, osztály

ObjektumObjektum: Információkat tárol, és kérésre : Információkat tárol, és kérésre feladatokat hajt végre. Logikailag összetartozó feladatokat hajt végre. Logikailag összetartozó adatok és rajtuk dolgozó algoritmusok adatok és rajtuk dolgozó algoritmusok összessége:összessége: adatokadatok metódusokmetódusok

Az objektumot üzenetek (kérelmek) által lehet Az objektumot üzenetek (kérelmek) által lehet megkérni a feladatok elvégzésére. (Ez egy megkérni a feladatok elvégzésére. (Ez egy metódus végrehajtását jelenti.)metódus végrehajtását jelenti.)

Osztály (Osztály (class): ): Objektumtípus, amely alapján Objektumtípus, amely alapján példá-nyokat, azaz objektumokat hozhatunk létre.példá-nyokat, azaz objektumokat hozhatunk létre.

Előnyök, célokElőnyök, célok

A szoftverfejlesztés során az együtt A szoftverfejlesztés során az együtt változó részek elkülöníthetőkváltozó részek elkülöníthetők

Projektek közötti Projektek közötti újrahasznosíthatóság növeléseújrahasznosíthatóság növelése

Konstruktor, példánytag, Konstruktor, példánytag, osztálytagosztálytag

Az objektumot létre kell hozni, és inicializálni Az objektumot létre kell hozni, és inicializálni kell. Az inicializálást végző metódust kell. Az inicializálást végző metódust konstruktornakkonstruktornak nevezzük. nevezzük.

További fogalmak: További fogalmak: példányváltozópéldányváltozó, , példánymetóduspéldánymetódus, , osztályváltozóosztályváltozó (közös változó), (közös változó), osztálymetódusosztálymetódus (objektum létrehozása nélkül is (objektum létrehozása nélkül is

tud dolgozni, csak az osztályváltozókat tud dolgozni, csak az osztályváltozókat manipulálhatja)manipulálhatja)

OOP jellemzőkOOP jellemzők

BezárásBezárás, az információ elrejtése: az , az információ elrejtése: az adatokat csak interfészeken (metódusok) adatokat csak interfészeken (metódusok) keresztül lehet elérni.keresztül lehet elérni.

ÖröklődésÖröklődés: az utód osztály örökli az ős : az utód osztály örökli az ős adatait, metódusait, valamint tartalmazhat adatait, metódusait, valamint tartalmazhat újakat, és felülírhat régi metódusokat.újakat, és felülírhat régi metódusokat.

Polimorfizmus Polimorfizmus – többalakúság: ugyanarra – többalakúság: ugyanarra az üzenetre (kérelemre), azaz metódus az üzenetre (kérelemre), azaz metódus hívásra, különböző objektumok hívásra, különböző objektumok különbözőképpen reagál-hatnak.különbözőképpen reagál-hatnak.

LáthatóságLáthatóság

Az osztály deklarálásakor Az osztály deklarálásakor megadhatjuk, hogy mely adatokat megadhatjuk, hogy mely adatokat lehet az objektumon kívülről elérnilehet az objektumon kívülről elérni Nyilvános (Nyilvános (publicpublic): kívülről elérhető): kívülről elérhető Védett (Védett (protectedprotected): hozzáférés csak ): hozzáférés csak

saját és az örökös metódusok számárasaját és az örökös metódusok számára Privát (Privát (privateprivate): hozzáférés csak saját ): hozzáférés csak saját

metó-dusok számárametó-dusok számára

2. A Java nyelv 2. A Java nyelv

OO nyelvekOO nyelvek

Simula-67Simula-67 Smalltalk (70’ eleje, XEROX)Smalltalk (70’ eleje, XEROX) Hibrid nyelvek: C++, Turbo PascalHibrid nyelvek: C++, Turbo Pascal Java: ’91-96, SUN MicroSystemJava: ’91-96, SUN MicroSystem

A Java főbb jellemzői A Java főbb jellemzői

C++-- kevesebb nyelvi eszköz, szigorúbb, C++-- kevesebb nyelvi eszköz, szigorúbb, kötöttebb, kevesebb hibalehetőségkötöttebb, kevesebb hibalehetőség

Hordozható kód: egy virtuális gépen (JVM, Hordozható kód: egy virtuális gépen (JVM, Java Virtual Machine) futó ún. bájtkód. Java Virtual Machine) futó ún. bájtkód. Nincsenek implementációfüggő elemek. Nincsenek implementációfüggő elemek.

Rohamos fejlődés kulcsa a JVM beépítése a Rohamos fejlődés kulcsa a JVM beépítése a Web böngészőkbe.Web böngészőkbe.

Fejleszthető: Fejleszthető: Alkalmazás (application)Alkalmazás (application) AppletApplet ServletServlet JSP (Java Server Pages)JSP (Java Server Pages)

JDK (Java Development Kit) JDK (Java Development Kit) Fejlesztői és futtató környezet Fejlesztői és futtató környezet

(java.sun.com) Részei:(java.sun.com) Részei: API (Application Programming Interface) – API (Application Programming Interface) –

osztály-könyvtár (a Java egyik ereje a rengeteg osztály-könyvtár (a Java egyik ereje a rengeteg kész osztály)kész osztály)

FordítóFordító ÉrtelmezőÉrtelmező AppletnézőAppletnéző Help, stbHelp, stb

Újabb neve: pl. J2SE (Java 2 Platform, Újabb neve: pl. J2SE (Java 2 Platform, Standard Edition)Standard Edition)

Csomag: logikailag összetartozó osztályok. Csomag: logikailag összetartozó osztályok. Csomag struktúra – könyvtár struktúra.Csomag struktúra – könyvtár struktúra.

A A Hello nevű osztály publikus, más nevű osztály publikus, más csomagokból is látni lehet.csomagokból is látni lehet.

A A main metódus a program belépési pontja. metódus a program belépési pontja. PublikusPublikus A A static kulcsszó azt jelenti, hogy ez kulcsszó azt jelenti, hogy ez

osztálymetódusosztálymetódus void: nincs visszatérési értéke, azaz eljárás: nincs visszatérési értéke, azaz eljárás String[] args: a parancssor paraméterek: a parancssor paraméterek

A A System egy osztály, amelyben található egy egy osztály, amelyben található egy outout objektum, melynek a objektum, melynek a println egy egy metódusa.metódusa.

public class Hello{ public static void main(String[] args){ System.out.println("Hello World!"); }}

Kiírás, beolvasásKiírás, beolvasásimport extra.*;//importálni kell azon osztályokat, csomagokat, //amelyekre hivatkozunk...int egysegar, mennyiseg, ar; //4 b. egész típusegysegar=Console.readInt("Egységár: ");mennyiseg=Console.readInt("Mennyiség: ");ar=egysegar*mennyiseg;System.out.println("Ön " + mennyiseg + " l benzint tankolt összesen " + ar + "Ft értékben");

//a System osztály a java.lang csomagban van //benne, amit nem kell importálnunk

Kiírás, beolvasásKiírás, beolvasás

A Console osztály metódusai (függvényei):A Console osztály metódusai (függvényei): int readInt() int readInt(String str) Hasonlóan: Hasonlóan: readLong, readDouble, readChar, readLine

A A print és és println metódusoknak egyetlen metódusoknak egyetlen paramé-terük lehet, de az többféle típusú. Ha paramé-terük lehet, de az többféle típusú. Ha egyszerre több dolgot is ki szeretnénk íratni, egyszerre több dolgot is ki szeretnénk íratni, akkor ezeket össze kell adnunk. A Java akkor ezeket össze kell adnunk. A Java automatikusan szöveggé konvertál. automatikusan szöveggé konvertál.

Pl. Pl. print("a+b=" + a + b) Pl. Pl. print("a+b=" + (a + b))

A program alkotóelemeiA program alkotóelemei AzonosítóbanAzonosítóban betűk, számjegyek, a _ jel és a valuta betűk, számjegyek, a _ jel és a valuta

szimbólumok szerepelhetnek. Számjeggyel nem kezdődhet. szimbólumok szerepelhetnek. Számjeggyel nem kezdődhet. Akár ékezetes betűt is tartalmazhat (unikód), de ezt inkább Akár ékezetes betűt is tartalmazhat (unikód), de ezt inkább kerüljük.kerüljük.

KulcsszóKulcsszó LiterálLiterál: állandó, amely beépül a program kódjába. Lehet:: állandó, amely beépül a program kódjába. Lehet:

egész (automatikusan int típusú, lehet hexad., decimális, egész (automatikusan int típusú, lehet hexad., decimális, oktális), oktális),

valós (pl: valós (pl: 2.3 2. .3 6e23), ), logikai (logikai (true, false), ), karakter (pl. karakter (pl. '?', , '\u1ac5' ), ), szöveg (pl. szöveg (pl. "valami"), ), null..

Vezérlő szekvenciákVezérlő szekvenciák: : \n \t \" \' \\pl. pl. println("Egy idézet: \"Talpra magyar!\"")

Java típusokJava típusok

Primitív típusok: (numerikus vagy logikai)Primitív típusok: (numerikus vagy logikai) bytebyte 1 b.1 b. -128 .. 127-128 .. 127 shortshort 2 b.2 b. -32768 .. 32767-32768 .. 32767 intint 4 b.4 b. kb -2*10kb -2*1099 .. 2*10 .. 2*1099

longlong 8 b.8 b. kb. -10kb. -101919 .. 10 .. 101919

floatfloat 4 b.4 b. doubledouble 8 b.8 b. charchar 2 b.2 b. booleanboolean

Referencia típus: olyan mutató, mely egy Referencia típus: olyan mutató, mely egy objektum hivatkozását tartalmazza.objektum hivatkozását tartalmazza.

Numerikus típusok

A char is numerikus típusA char is numerikus típus

char c; int a; c=65; System.out.println(c); c='A'+1; System.out.println(c); a=c+1; System.out.println(a);

floatfloat 4 bájt4 bájt Kb. Kb. 1.4E-45 … 3.4E+381.4E-45 … 3.4E+38 6-7 jegy pontosság6-7 jegy pontosság

doubledouble 8 bájt8 bájt Kb. Kb. 5E-324 … 1.8E+3085E-324 … 1.8E+308 14-15 jegy pontosság14-15 jegy pontosság

Változó deklarálás Változó deklarálás

Deklaráló utasításDeklaráló utasítás Adható kezdőérték is (inicializálás). Adható kezdőérték is (inicializálás). Pl:Pl: int a, b;

double x, y = 2.4;

Forrásprogram szerkezeteForrásprogram szerkezete

A forrásállomány (fordítási egység) A forrásállomány (fordítási egység) egy vagy több osztályból állhat. egy vagy több osztályból állhat.

A forrásállomány neve a A forrásállomány neve a main metódust tartalmazó egyetlen metódust tartalmazó egyetlen publikus osztály neve lesz.publikus osztály neve lesz.

Fordításkor több class kiterjesztésű Fordításkor több class kiterjesztésű állo-mány keletkezhet.állo-mány keletkezhet.

import java.utils.*;import extra.*;//Egy vagy több osztály deklarálása, a sorrend mindegy

class C1{ ...}

class C2{ ...}...public class Prog{ ... public static void main(String[] args){ ... } ...}

OperátorokOperátorok

Unáris postfix és prefix operátorokUnáris postfix és prefix operátorok [ ] tömbképzőtömbképző . minősítőminősítő ( ) metódus képzőmetódus képző ~, ! bitenkénti, ill. logikai bitenkénti, ill. logikai

tagadás00tagadás00 new példányosítópéldányosító (típus)kifejezés típuskényszerítőtípuskényszerítő +, - előjelelőjel ++, -- léptető, pl. i++ vagy ++i léptető, pl. i++ vagy ++i

mindkettő növeli i értékét, de az első értéke i mindkettő növeli i értékét, de az első értéke i eredeti, míg a második i megnövelt értéke lesz.eredeti, míg a második i megnövelt értéke lesz.

++, --++, --

int a = 0, b, c;b = ++a;a = 0;c = a++;

c = ++b + a++;c = a+++++b;c = a++ + ++b;

Multiplikatív operátorokMultiplikatív operátorok

*, / % maradékos osztás maradékos osztás Ha az operandusok egészek, akkor az Ha az operandusok egészek, akkor az

eredmény is egész, ha legalább az egyik eredmény is egész, ha legalább az egyik operandus valós, akkor az eredmény is operandus valós, akkor az eredmény is valós.valós.

Pl.Pl. int ossz = 2 + 3;double atlag = ossz / 2;

Megj. A maradékképzés valós számokra is alkalmazható

Additív operátorokAdditív operátorok+, -

Relációs operátorok (az eredmény boolean típusú Relációs operátorok (az eredmény boolean típusú lesz)lesz)<, <=, >, >=,==, !=

Logikai operátorokLogikai operátorok ! nemnem &, && ésés (teljes, ill. rövid kiértékelésű) |, || vagyvagy ^ kizáró vagykizáró vagy

Bitenkénti operátorokBitenkénti operátorok ~ komplementáláskomplementálás &, |, ^ <<,>>,>>> léptetések (léptetések (>>>>>>: minden esetben 0 lép be): minden esetben 0 lép be)

Feltételes operátorokFeltételes operátorok(feltétel) ? kifejezés1: kifejezés2 pl. pl. kamat = (fiz>200000)?10:0;

Értékadó operátorokÉrtékadó operátorok=, +=, -=, *=, /=, %= …

Az összetett értékadás szintaktikája: Az összetett értékadás szintaktikája: változóváltozó operátor operátor = = kifejezés kifejezés a += b szemantikája: szemantikája: változóváltozó = ( = (típustípus) ) változóváltozó operátor kifejezésoperátor kifejezés a = a + bahol ahol típustípus a változó típusa, amelyet a változó típusa, amelyet rákényszerí-tünk a jobboldalra.rákényszerí-tünk a jobboldalra.

Értékadó operátorokÉrtékadó operátorok

Vigyázzunk az összetett ill. a „hagyományos Vigyázzunk az összetett ill. a „hagyományos értékadó utasítások nem minden esetben értékadó utasítások nem minden esetben teljesen egyformák!teljesen egyformák!int a=10;a+=5;megegyezik az megegyezik az a=a+5 ut.-al, mindkét oldal int ut.-al, mindkét oldal inta+=1.5;nem egyezik meg az nem egyezik meg az a=a+1.5 ut.-al, mely ut.-al, mely szintaktikai hibás, hiszen a jobb oldal doubleszintaktikai hibás, hiszen a jobb oldal double

Lehetséges a többszörös értékadás, pl: Lehetséges a többszörös értékadás, pl: a=b=5;

KiértékelésKiértékelés

Egy kifejezés kiértékelési sorrendjétEgy kifejezés kiértékelési sorrendjét meg-határozzák:meg-határozzák: zárójelzárójel prioritásprioritás asszociativitás (balról – jobbra vagy asszociativitás (balról – jobbra vagy

jobbról – balra szabály)jobbról – balra szabály)

Java utasításokJava utasítások

deklaráló; pl. deklaráló; pl. int a; értékadó; pl. értékadó; pl. a = b * 2; postfix és prefix növelő és csökkentő; pl. postfix és prefix növelő és csökkentő; pl. a++;

metódushívás, pl. metódushívás, pl. System.out.println("Hahó!");

példányosítás, pl. példányosítás, pl. auto = new Auto("ABC123");

Programvezérlő, pl. elágazások, ciklusokProgramvezérlő, pl. elágazások, ciklusok üres: üres: ;

Java utasításokJava utasítások

Minden utasítást pontosvessző zár le.Minden utasítást pontosvessző zár le. Blokk (vagy összetett utasítás): Blokk (vagy összetett utasítás): { ... }

TípuskonverziókTípuskonverziók

A Java erősen típusos nyelvA Java erősen típusos nyelv Típuskonverzió lehetTípuskonverzió lehet

automatikus (implicit)automatikus (implicit) kényszerített (explicit): kényszerített (explicit): ((típustípus))kifejezéskifejezéstype casttype cast

illetveilletve szűkítőszűkítő bővítőbővítő

Primitív típusok esetén egy szűkebb adattípus Primitív típusok esetén egy szűkebb adattípus értéke konvertálható egy bővebb adattípus értékébe értéke konvertálható egy bővebb adattípus értékébe információ-vesztés nélkül. információ-vesztés nélkül.

Ez általában automatikus.Ez általában automatikus.

int i;double d;byte b;short s;

b + s //implicit bővítő konverzió (int)

d = i; //implicit bővítő konverzió

i = d; //szintaktikai hiba

i = (int)d; //explicit szűkítő konv.

Numerikus operátorok Numerikus operátorok típuskonverzióitípuskonverziói

Automatikus konverziók a következő Automatikus konverziók a következő szabályok szerint:szabályok szerint: Unáris operátorok: ha az operandus Unáris operátorok: ha az operandus intint-nél -nél

szűkebb, akkor szűkebb, akkor intint-é konvertál, egyébként -é konvertál, egyébként nem konvertálnem konvertál

Bináris operátorok: mindkét operandust a kettő Bináris operátorok: mindkét operandust a kettő közül bővebb, de minimum közül bővebb, de minimum intint-é konvertálja-é konvertálja

(Az egész literál automatikusan int, a valós literál (Az egész literál automatikusan int, a valós literál automatikusan double)automatikusan double)

Értékadó utasításÉrtékadó utasítás

változó = kifejezés; A kifejezés típusának értékadás szerint A kifejezés típusának értékadás szerint

kompatíbilisnek kell lenni a változó típusával:kompatíbilisnek kell lenni a változó típusával: azonos típusokazonos típusok a jobb oldal szűkebb, akkor implicit bővítő a jobb oldal szűkebb, akkor implicit bővítő

konverziókonverzió a bal oldal a bal oldal byte, short vagy vagy char, a jobb oldal , a jobb oldal int, és a fordító el tudja dönteni, hogy a jobboldal , és a fordító el tudja dönteni, hogy a jobboldal belefér a baloldalba, akkor implicit szűkítő belefér a baloldalba, akkor implicit szűkítő konverzió. konverzió. pl. pl. byte b = 100; (az egész literál automatikusan (az egész literál automatikusan int típusú). típusú).

minden más esetben fordítási hiba keletkezikminden más esetben fordítási hiba keletkezik

MetódushívásMetódushívás Osztály.metódus(paraméterek)

pl. pl. y=Math.sin(x); Objektum.metódus(paraméterek)

pl. pl. hossz=szoveg.length(); Saját osztályból elég csak a metódus neve: Saját osztályból elég csak a metódus neve: metódus(paraméterek)

Egy metódus lehet eljárás- vagy függvényszerű. Egy metódus lehet eljárás- vagy függvényszerű. Túlterhelés (overloading): lehet több azonos nevű Túlterhelés (overloading): lehet több azonos nevű

metódus, melyek a paraméterezésben és/vagy a metódus, melyek a paraméterezésben és/vagy a visszatérési érték típusában térhetnek el visszatérési érték típusában térhetnek el egymástól.egymástól.

Pl. Pl. float max(float a, float b) illetve illetve int max(int a, int b)

A java.lang.Math osztályA java.lang.Math osztály

Java API (Application Programming Java API (Application Programming Interface): rengeteg csomag, osztályInterface): rengeteg csomag, osztály

Nem kell importálni.Nem kell importálni. Konstansok: Konstansok: E, PI Függvények: Függvények: abs, asin, sin, cos, atan, tan, exp, log, max, min, pow, sqrt, toDegrees, toRadians, random, round…

Java API dokumentum Java API dokumentum részletrészlet

static int static int min(int a, int b)           Returns the smaller of two int values.           Returns the smaller of two int values.

static longstatic long min(long a, long b)           Returns the smaller of two long           Returns the smaller of two long values. values.

static doublestatic double pow(double a, double b)           Returns of value of the first argument           Returns of value of the first argument raised to the power of the second argument. raised to the power of the second argument.

static doublestatic double random()           Returns a double value with a positive           Returns a double value with a positive sign, greater than or equal to 0.0 and less sign, greater than or equal to 0.0 and less than 1.0. than 1.0.

min

public static int min(int a, int b)

Returns the smaller of two int values. That is, the result the argument closer to the value of Integer.MIN_VALUE. If the arguments have the same value, the result is that same value.

Parameters: a - an argument. b - another argument.

Returns: the smaller of a and b.

See Also: Long.MIN_VALUE

Szelekciók - Szelekciók - if utasítás utasítás if(feltétel) utasítás1;else utasítás2;

feltétel: logikai kifejezés: logikai kifejezés az az else ág elhagyható ág elhagyható a feltétel után nincs pontosvesszőa feltétel után nincs pontosvessző az utasítás esetén viszont van pontosvesszőaz utasítás esetén viszont van pontosvessző minden feltétel zárójelbenminden feltétel zárójelben egy ágban több utasítás: blokk {...}egy ágban több utasítás: blokk {...} egymásba ágyazásegymásba ágyazás

if(a>b) c=a;else c=b;

Szelekciók - Szelekciók - switch utasítás utasítás switch(kifejezés){ case érték1: utasítások;

break; case érték2: utasítások;

break; ... default: utasítások;}

akkor alkalmazható, ha egy kifejezés jól akkor alkalmazható, ha egy kifejezés jól meghatározott, különálló értékeire szeretnénk meghatározott, különálló értékeire szeretnénk bizonyos utasításokat végrehajtanibizonyos utasításokat végrehajtani

kifejezés: byte, short, int vagy char: byte, short, int vagy char a a break hatására a hatására a switch blokk végére kerül a blokk végére kerül a

vezérlés, e nélkül a következő vezérlés, e nélkül a következő case ágra kerülne ágra kerülne a vezérlésa vezérlés

egy egy case kulcsszóhoz csak egy érték tartozhat kulcsszóhoz csak egy érték tartozhat

switch(pont){ case 1: case 2: case 3: System.out.println("Elégtelen");

System.out.println("Készüljön tovább!");break;

case 4: System.out.println("Elégséges");break;

case 5: System.out.println("Közepes");break;

case 6: System.out.println("Jó");break;

default: System.out.println("Jeles");}

Szelekciók - Szelekciók - switch utasítás utasítás

Iterációk - Iterációk - while utasítás utasítás

while(feltétel) utasítás;

Amíg a feltétel igaz, újból végrehajtja az utasítást, Amíg a feltétel igaz, újból végrehajtja az utasítást, ha hamis, akkor a ciklust követő utasításra lép.ha hamis, akkor a ciklust követő utasításra lép.

Több utasítás esetén: blokk { ... }Több utasítás esetén: blokk { ... }

Példa:Példa: Bankba tesszük a pénzünket kamatozni, és Bankba tesszük a pénzünket kamatozni, és

addig tartjuk bent, amíg milliomosok nem addig tartjuk bent, amíg milliomosok nem leszünk. A program számolja ki, hogy hány évet leszünk. A program számolja ki, hogy hány évet kell várnunk.kell várnunk.

import extra.*;public class Milliomos1{ public static void main(String[]args){ final double KAMAT=8.5; //konstans int ev=0; int penz=Console.readInt("Összeg: "); while(penz<1000000){ penz*=1+KAMAT/100; //Ft-ra kerekít ev++; } System.out.println(ev+ " ev mulva leszunk milliomosok!"); }}

Iterációk - Iterációk - while utasítás utasítás

Iterációk - do...while Iterációk - do...while utasításutasítás

do utasítás; while(feltétel)

Amíg a feltétel igaz, újból végrehajtja az utasítást, Amíg a feltétel igaz, újból végrehajtja az utasítást, haha hamis, akkor a ciklust követő utasításra lép. hamis, akkor a ciklust követő utasításra lép. Több utasítás esetén: blokk { ... }Több utasítás esetén: blokk { ... }

Példa:Példa: Bankba tesszük a pénzünket kamatozni, és Bankba tesszük a pénzünket kamatozni, és addig tartjuk bent, amíg milliomosok nem leszünk. A addig tartjuk bent, amíg milliomosok nem leszünk. A program számolja ki, hogy hány évet kell várnunk.program számolja ki, hogy hány évet kell várnunk.

Iterációk - do...while Iterációk - do...while utasításutasítás

import extra.*;public class Milliomos2{ public static void main(String[]args){ final double KAMAT=8.5; //konstans int ev=0; int penz=Console.readInt("Összeg: "); do{ penz*=1+KAMAT/100; //Ft-ra kerekít ev++; }while(penz<1000000); System.out.println(ev+ " ev mulva leszunk milliomosok!"); }}

Iterációk - for utasítás Iterációk - for utasítás for(inicializálás; feltétel; léptetés) utasítás;

inicializálás: egy vagy több utasítás vesszővel : egy vagy több utasítás vesszővel elválasztva, mely(ek) egyszer hajtódik végre a elválasztva, mely(ek) egyszer hajtódik végre a ciklusmagba való első belépés előtt. Pl. ciklusmagba való első belépés előtt. Pl. ciklusváltozó deklarálása, inicializálása. A ciklusváltozó deklarálása, inicializálása. A ciklusváltozó típusa tetszőleges.ciklusváltozó típusa tetszőleges.

feltétel: amíg igaz, újból végrehajtja az utasítást, : amíg igaz, újból végrehajtja az utasítást, ha hamis, akkor a ciklust követő utasításra lép.ha hamis, akkor a ciklust követő utasításra lép.

léptetés: egy vagy több utasítás vesszővel : egy vagy több utasítás vesszővel elválasztva, mely(ek) a ciklusmag minden egyes elválasztva, mely(ek) a ciklusmag minden egyes lefutása után automatikusan végrehajtódik. lefutása után automatikusan végrehajtódik. Általában a ciklusváltozót szokás itt növelni vagy Általában a ciklusváltozót szokás itt növelni vagy csökkenteni.csökkenteni.

Iterációk - for utasításIterációk - for utasítás

A A while ciklus egy speciális esetének tekinthető: ciklus egy speciális esetének tekinthető:

for(inicializálás; feltétel; léptetés) utasítás;

inicializálás;while(feltétel){ utasítás; léptetés}

Iterációk - for utasításIterációk - for utasításpéldákpéldák

for(int i=1; i<=10; i++) System.out.print("*");

for(int i=1; i<=10; i++){ for(int j=1; j<=10; j++) System.out.print("*"); System.out.println();}

for(char c='A'; c<='Z'; c++) System.out.print(c+" ");

//(c+' ') esetén a kódokat írja ki

for(char n='A',k='a'; n<='Z'; n++,k++) System.out.print(n+" "+k+" ");

for(double d=500000; d<=1000000; d*=1.1) System.out.println(d);

Kiugrás a ciklusbólKiugrás a ciklusból

Break utasítás: az aktuális utasítás: az aktuális utasításblokk-ból (pl. ciklusból) való utasításblokk-ból (pl. ciklusból) való azonnali kiugrást eredményezi.azonnali kiugrást eredményezi.

Continue utasítás: hatására a utasítás: hatására a vezérlés az utasításblokk (ciklus) vezérlés az utasításblokk (ciklus) végére kerül.végére kerül.

Metódusok írásaMetódusok írása A metódus fej szintaktikája:A metódus fej szintaktikája:

[módosítók] visszatérésitípus metódusneve( [paraméterlista] )

Néhány példa:Néhány példa: public static int min(int a, int b) public void vonalhuz() public void vonalhuz(int hossz) long fakt(byte n)//csomag szintű láthatóság

Módosítók lehetnek: Módosítók lehetnek: public, private, protected: láthatóság: láthatóság static: osztálymetódus: osztálymetódus stb.stb.

Függvény, eljárásFüggvény, eljárás

A metódusoknak két fajtáját A metódusoknak két fajtáját különböztetjük meg:különböztetjük meg: Eljárás–szerű metódus: visszatérési Eljárás–szerű metódus: visszatérési

értékének típusa értékének típusa void, azaz üres típus, , azaz üres típus, nem tér vissza értékkelnem tér vissza értékkel

Függvény–szerű metódus: visszatérési Függvény–szerű metódus: visszatérési értéké-nek típusa valamilyen értéké-nek típusa valamilyen voidtól tól különböző típus, azaz igazi értékkel tér különböző típus, azaz igazi értékkel tér visszavissza

A függvény eljárásként is hívható.A függvény eljárásként is hívható.

Metódusok jellemzőiMetódusok jellemzői

TúlterhelésTúlterhelés (overloading): lehet két egyforma (overloading): lehet két egyforma nevű, de különböző paraméterezésű metódus. nevű, de különböző paraméterezésű metódus. pl. pl. vonalhuz() ill. ill. vonalhuz(int hossz) vagy vagy min(int a, int b) ill. ill. min(double a, double b)

ParaméterátadásParaméterátadás: érték szerinti. Az aktuális : érték szerinti. Az aktuális paraméter típusának értékadás szerint paraméter típusának értékadás szerint kompatíbilisnek kell lennie a formális kompatíbilisnek kell lennie a formális paraméterrel.paraméterrel.

Visszatérés a metódusból: függvény esetén Visszatérés a metódusból: függvény esetén return után kötelezően meg kell adnunk egy után kötelezően meg kell adnunk egy értéket.értéket.

Metódusok jellemzőiMetódusok jellemzői

Az osztály metódusainak deklarálási sor-Az osztály metódusainak deklarálási sor-rendje tetszőleges. A rendje tetszőleges. A main-t elsőnek vagy -t elsőnek vagy utolsónak célszerű megadni. utolsónak célszerű megadni.

A metódusok nem ágyazhatóak egymásba.A metódusok nem ágyazhatóak egymásba. Lehet rekurzív metódusokat is definiálni.Lehet rekurzív metódusokat is definiálni. A metódusban –mint egyébként is bármely A metódusban –mint egyébként is bármely

blokkban– definiálhatunk lokális változót.blokkban– definiálhatunk lokális változót.

public class Metodusok{

static void vonalhuz(int hossz){ for (int i=1; i<=hossz; i++) System.out.print("-"); System.out.println(); } static void vonalhuz(){ vonalhuz(50); } static int abs(int n){ if (n>=0) return n; else return -n; }

static int jegySzam(int n){ int jszam=0; do{ n/=10; jszam++; }while(n!=0); return jszam; } public static void main(String[] args){ int a=-10; int b=12345678; vonalhuz(); System.out.println(a+" abszolut erteke: "+abs(a)); vonalhuz(40); System.out.println(b+" jegyeinek szama: "+jegySzam(b)); vonalhuz(); } }

Osztály készítéseOsztály készítése

OO programOO program

fut vezérlő objektum

objektum1

üzenet3

üzenet1

objektum2

objektum3

üzenet2üzenet1

Egy objektumorientált program egymással kommunikáló objektumok összessége, melyben minden objektumnak megvan a feladatköre

Példa - Ember osztály és példányaiPélda - Ember osztály és példányai

pozíció(x,y)iránySzög

megy(táv)elmegy(x,y)fordul(szög)

Ember

katiandor

zsófi

Az OOP fontosabb Az OOP fontosabb definícióinak összefoglalásadefinícióinak összefoglalása Példánydeklaráció (példánytag): Példánydeklaráció (példánytag):

A példányonként (objektumonként) helyet foglaló A példányonként (objektumonként) helyet foglaló változók a változók a példányváltozókpéldányváltozók (példányadatok). (példányadatok).

Azon metódusokat, melyek példányadatokon Azon metódusokat, melyek példányadatokon dolgoznak, dolgoznak, példánymetódusoknakpéldánymetódusoknak nevezzük. nevezzük.

Osztálydeklaráció (osztálytag) (Osztálydeklaráció (osztálytag) (static) ) Az Az osztályváltozóosztályváltozó az osztály saját változója, az az osztály saját változója, az

egyes példányokban nem szerepel, valamilyen egyes példányokban nem szerepel, valamilyen közös adatot tárol. közös adatot tárol.

Az Az osztálymetódusosztálymetódus az osztály saját metódusa, az osztály saját metódusa, amely csak osztályváltozókon dolgozik.amely csak osztályváltozókon dolgozik.

LáthatóságLáthatóság

PrivátPrivát ( (private): csak az osztály saját metódusai ): csak az osztály saját metódusai férfér--hetnek hozzá.hetnek hozzá.

NyilvánosNyilvános ( (public): minden, az objektummal ): minden, az objektummal kapcsolatkapcsolat--ban álló kliens eléri, használhatja.ban álló kliens eléri, használhatja.

Egy osztály adatai általában privát adatok.Egy osztály adatai általában privát adatok.

Egy fordítási egység (java fájl) több osztályt is Egy fordítási egység (java fájl) több osztályt is tartalmaztartalmaz--hat, de közülük csak egy lehet nyilvános hat, de közülük csak egy lehet nyilvános ((public). Ha valamelyik osztályban szerepel a ). Ha valamelyik osztályban szerepel a main metódus, akkor az nyilvános kell hogy legyen. metódus, akkor az nyilvános kell hogy legyen.

Egy osztályban ugyanazon a néven Egy osztályban ugyanazon a néven dekla-rálható metódus és változó, sdekla-rálható metódus és változó, sőőt t a metódu-sok túlterhelheta metódu-sok túlterhelhetőőek. ek.

A deklarálás sorrendje általában:A deklarálás sorrendje általában: változókváltozók konstruktorokkonstruktorok metódusokmetódusok main metódus, ha van. metódus, ha van.

A lokális változók A lokális változók eltakarjákeltakarják az ugyanolyan az ugyanolyan nevnevűű osztály-, illetve példányváltozókat. osztály-, illetve példányváltozókat.

Ha az osztály deklarációjára szeretnénk Ha az osztály deklarációjára szeretnénk hivathivat--kozni, akkor osztályváltozó esetén az kozni, akkor osztályváltozó esetén az osztály nevével, példányváltozó esetén osztály nevével, példányváltozó esetén pedig a pedig a this this referenciával kell azt referenciával kell azt minminőősítenünk.sítenünk.

Változók alapértelmezés szerinti kezdeti Változók alapértelmezés szerinti kezdeti értékei: osztályváltozó vagy példányváltozó értékei: osztályváltozó vagy példányváltozó esetén 0, lokális változó esetén esetén 0, lokális változó esetén határozatlan.határozatlan.

KonstruktorokKonstruktorok Feladata az objektum Feladata az objektum new operátorral való létrehozásakor operátorral való létrehozásakor

annak inicializálása.annak inicializálása. Auto auto = new Auto("GHJ123”); A konstruktor speciális metódus, a következő szabályok A konstruktor speciális metódus, a következő szabályok

érvényesek rá:érvényesek rá: Neve kötelezően megegyezik az osztály nevével.Neve kötelezően megegyezik az osztály nevével. Csak a Csak a new operátorral hívható. operátorral hívható. Túlterhelhető.Túlterhelhető. Nincs visszatérési értéke, és nem is void.Nincs visszatérési értéke, és nem is void.

Ha az osztályban nem adunk meg explicit módon Ha az osztályban nem adunk meg explicit módon konstruktort, akkor az osztálynak lesz egy alapértelmezés konstruktort, akkor az osztálynak lesz egy alapértelmezés szerinti (default), paraméter nélküli konstruktora. szerinti (default), paraméter nélküli konstruktora.

Ha az osztályban létezik egy explicit konstruktor, akkor Ha az osztályban létezik egy explicit konstruktor, akkor nem lesz implicit, alapértelmezés szerinti konstruktora. nem lesz implicit, alapértelmezés szerinti konstruktora.

Példa - RaktárprogamPélda - Raktárprogam

Adott egy zöldségraktár, melyben pillanatnyilag egyetlen árut, paradicsomot raktározunk. A raktárba gyakran te-szünk be, illetve veszünk ki onnan paradicsomot. A para-dicsom pillanatnyi egységára 300 Ft, de ez változhat. Készítsünk olyan programot, mely segítségével rögzíteni tudjuk a megfelelő adatokat, és bármikor jelentést tudunk adni a paradicsom aktuális mennyiségéről, egységáráról és értékéről!

Végezzük el a következő akciókat: Tegyünk a raktárba 125 kg paradicsomot, aztán vegyünk ki 25 kg-ot, majd szállítsuk le a paradicsom egységárát 210 Ft-ra! Mindhárom akció után írjuk ki, mennyi paradicsom van raktáron és milyen értékben!

OsztálydiagramOsztálydiagram

RaktarProgram

-aru

-nev: String-egysegar: double-menny: double

Aru

+Aru(aNev:String,aEgysegar:double)+getNev(): String+getEgysegar(): double+setEgysegar(aEgysegar:double)+getMenny(): double+getAr(): double+hozzatesz(aMenny:double)+elvesz(aMenny:double)+toString(): String

+RaktarProgram()+akciok()+main(args)

OsztálydiagramOsztálydiagram

RaktarProgram

-aru

-nev: String-egysegar: double-menny: double

Aru

+Aru(aNev:String,aEgysegar:double)+getNev(): String+getEgysegar(): double+setEgysegar(aEgysegar:double)+getMenny(): double+getAr(): double+hozzatesz(aMenny:double)+elvesz(aMenny:double)+toString(): String

+RaktarProgram()+akciok()+main(args)

class Aru { private String nev; private double egysegar; private double menny;

public Aru(String aNev, double aEgysegar) { nev = aNev; egysegar = aEgysegar; menny = 0; }

public String getNev() { return nev; }

Példányváltozók

Konstruktor

Osztálydiagram

public double getEgysegar() { return egysegar;}

public void setEgysegar(double aEgysegar) { if (aEgysegar >= 0) egysegar = aEgysegar;}

public double getMenny() { return menny;}

public double getAr() { return menny*egysegar;}

Osztálydiagram

public void hozzatesz(double aMenny) { if (aMenny>0) menny += aMenny; }

public void elvesz(double aMenny) { if (aMenny>0 && aMenny<=menny) menny -= aMenny; }

public String toString() { return nev+"\tEgysegar: "+egysegar+ "\tMenny: "+menny+"\tAr: "+getAr(); }}

Osztálydiagram

public class RaktarProgram { private Aru aru;

public RaktarProgram() { aru = new Aru("Paradicsom",300); }

public void akciok() { aru.hozzatesz(125); System.out.println(aru); aru.elvesz(25); System.out.println(aru); aru.setEgysegar(210); System.out.println(aru); }

public static void main(String[] args) { RaktarProgram program = new RaktarProgram(); program.akciok(); }} Osztálydiagram

Kapcsolat

Objektum létrehozása

saját osztályából

Együttműködési diagramEgyüttműködési diagram

RaktarProgram aru:Aruprogram:

RaktarProgram

2: RaktarProgram()4: akciok()

3: Aru(aNev,aEgysegar)5: hozzatesz(aMenny)

6: elvesz(aMenny)7: setEgysegar(aEgysegar)

1: main(args)

OsztálydiagramOsztálydiagram

Bank

-szamla1-szamla2

-utolsoSzamlaSzam: int-szamlaSzam: int-tulajdonos: String-egyenleg: int

Szamla

+Szamla(tulajdonos:String,egyenleg:int)+Szamla(tulajdonos:String)+getTulajdonos(): String+setTulajdonos(Tulajdonos:String)+befizet(osszeg:int)+kivesz(osszeg:int): int+toString(): String

+Bank()+ugyfelKiszolgalas (szamla:Szamla)+menu()+main(args)

Példa – BankprogamPélda – BankprogamKészítsünk egy banki programot, mely az ügyfelek számláit kezeli.Készítsünk egy banki programot, mely az ügyfelek számláit kezeli.

import extra.*;class Szamla{ private static int utolsoSzamlaSzam=0; private int szamlaSzam; private String tulajdonos; private int egyenleg; public Szamla(String tulajdonos, int egyenleg){ szamlaSzam=++utolsoSzamlaSzam; this.tulajdonos=tulajdonos; this.egyenleg=egyenleg; } public Szamla(String tulajdonos){ this(tulajdonos,0); } public String getTulajdonos(){ return tulajdonos; }

public void setTulajdonos(String tulajdonos){ this.tulajdonos=tulajdonos; } public void befizet(int osszeg){ if(osszeg>=0) egyenleg+=osszeg; } public int kivesz(int osszeg){ if(osszeg>=0 && osszeg<=egyenleg) egyenleg-=osszeg; return egyenleg; } public String toString() { return "Szamlaszam: "+szamlaSzam+" Tulajd.: "+tulajdonos+ " Egyenleg: "+egyenleg; }}//Számla osztály vége

public class Bank { private Szamla szamla1, szamla2; public Bank() { szamla1 = new Szamla("Kiss Istvan", 1000000); szamla2 = new Szamla("Nagy Peter"); } public void ugyfelKiszolgalas(Szamla szamla) { char valasz; do{ valasz=Character.toUpperCase(Console.readChar("B(efizet)/K(ivesz)")); }while(valasz!='B' && valasz!='K'); if (valasz == 'B') szamla.befizet(Console.readInt("Mennyit fizet be? ")); else{ int egyenleg = szamla.kivesz(Console.readInt("Mennyit vesz ki? ")); System.out.println("Maradek egyenleg "+egyenleg+" Ft"); } }

public void menu() { char valasz; do{ System.out.println("\n\n"+szamla1); System.out.println(szamla2); System.out.println("\n1: 1. ugyfel kiszolgalasa"); System.out.println("2: 2. ugyfel kiszolgalasa"); System.out.print ("V: Vege "); valasz = Character.toUpperCase(Console.readChar()); switch (valasz) { case '1': ugyfelKiszolgalas(szamla1); break; case '2': ugyfelKiszolgalas(szamla2); break; } }while (valasz!='V'); } public static void main(String[] args) { Bank otp = new Bank(); otp.menu(); }}//Bank osztály vége

InicializálókInicializálók

class Tanulo {class Tanulo { static int alapTandij;static int alapTandij; double atlag;double atlag; int tandij;int tandij; static { static { alapTandij = 2000;alapTandij = 2000; }} {{ atlag = Console.readDouble("Atlag: ");atlag = Console.readDouble("Atlag: ");

tandij = alapTandij + (int)Math.round(3000*(5-tandij = alapTandij + (int)Math.round(3000*(5-atlag));atlag));

}}

// … // …

}}

= = 20002000;; = Console.readDouble("Atlag: ");= Console.readDouble("Atlag: ");

Az inicializálás sorrendjeAz inicializálás sorrendje Osztályadatok (osztály betöltésekor)Osztályadatok (osztály betöltésekor)

alapértelmezés szerinti értékekalapértelmezés szerinti értékek osztályinicializáló kifejezésekosztályinicializáló kifejezések osztályinicializáló blokkokosztályinicializáló blokkok

Objektum adatai (objektum születésekor)Objektum adatai (objektum születésekor) alapértelmezés szerinti értékekalapértelmezés szerinti értékek példányinicializáló kifejezésekpéldányinicializáló kifejezések példányinicializáló blokkokpéldányinicializáló blokkok konstruktor(ok)konstruktor(ok)

Az Object osztályAz Object osztály

Minden osztály közös őseMinden osztály közös őse

A Java minden objektumára jellemző A Java minden objektumára jellemző

metódusokat tartalmaz. Például:metódusokat tartalmaz. Például: boolean equals(Object obj)boolean equals(Object obj)

String toString()String toString()

Class getClass()Class getClass()

Objektumok egyenlőségvizsgálataObjektumok egyenlőségvizsgálata

String s1 = String s1 = new String(new String("Hello""Hello")), s2 = , s2 = new String(new String( "Hello" "Hello"));;

System.out.println(s1==s2);System.out.println(s1==s2);

System.out.println(s1.System.out.println(s1.equalsequals(s2));(s2));

falsetrue

KarakterláncKarakterlánc

A A String osztályú objektum olyan szöveg osztályú objektum olyan szöveg tárolására szolgál, amelynek értékét nem tárolására szolgál, amelynek értékét nem akarjuk megváltoztatni. akarjuk megváltoztatni.

A A StringBufferStringBuffer osztályt akkor használjuk, osztályt akkor használjuk, ha a szövegen szeretnénk változtatni.ha a szövegen szeretnénk változtatni.

A A StringBuilderStringBuilder osztályt a JDK 5.0-tól osztályt a JDK 5.0-tól vezették be, ami gyorsabb, mint a vezették be, ami gyorsabb, mint a StringBufferStringBuffer, de csak egy szálon , de csak egy szálon használható biztonságosan.használható biztonságosan.

Objektum létrehozása a Objektum létrehozása a new operátorral operátorral

Auto auto; //csak referenciaauto = new Auto("GHJ123”);//a konstruktor hívásával létrejön az objektum, //az auto referencia erre mutat

vagy vagy

Auto auto = new Auto("GHJ123”);

OsztályazonosítóOsztályazonosító objektum = new objektum = new OsztályazonosítóOsztályazonosító((paraméterlistaparaméterlista););

String objektum objektum létrehozása létrehozása

String szoveg; //csak referencia

szoveg = new String(”Ez a tartalma”);

csak StringString esetén ez egyszerűsíthető:

szoveg=”Ez a tartalma”;

A A String osztály metódusai osztály metódusai

Az eredeti objektumot Az eredeti objektumot nem változtatjáknem változtatják, , függvények, sokszor új String objektumot hoznak függvények, sokszor új String objektumot hoznak létre.létre.

Néhány metódus:Néhány metódus:

char charAt(int index)tetszőleges indexű karakterét adja vissza, az tetszőleges indexű karakterét adja vissza, az indexelés 0-val kezdődikindexelés 0-val kezdődik

int compareTo(String str)összehasonlítja, értéke 0, ha egyenlő; –, ha kisebb; összehasonlítja, értéke 0, ha egyenlő; –, ha kisebb; +, ha nagyobb, mint a paraméter+, ha nagyobb, mint a paraméter

boolean equals(Object anObject)igaz, ha az objektum String típusú, s karakterei ugyanazok

int indexOf(String str) //hasonlóan lastIndexOfaz adott sztring első előfordulásának pozíciója lesz az értéke, ha nincs benne, akkor érték –1

int indexOf(String str, int fromIndex)az adott sztring első előfordulásának pozíciója lesz az értéke, a keresést a második paraméterben megadott sorszámú karak-tertől kezdi, ha nincs benne, akkor az érték –1

int length()hosszát adja vissza

String replace(char oldChar, char newChar)kicseréli a megadott karaktereket, s visszaadja az új sztringet (maga a sztring objektum nem változik meg)

String substring(int beginIndex)a paraméterben megadott pozíciótól a szöveg végéig kimásol

String substring(int beginIndex, int endIndex)a kezdő pozíciótól a végpozícióig kimásol, endIndex nem tartozik bele a részláncba, így a visszaadott sztring hossza endIndex- beginIndex

String toLowerCase()kisbetűsre alakítottan adja vissza

String toUpperCase()nagybetűsre alakítottan adja vissza

String trim()levágja a fehér szóközöket (space, tab, sorvégejel) az elejéről és végéről, s visszaadja

Stb.

Ezek példánymetódusok, hívásuk: objektumnév.metódusnév([paraméterlista])pl: int hossz = szoveg.length();

Sztringet bekérni a billentyűzetről az extra csomagbeli Console osztály readLine() metódusával lehet.pl: String nev = Console.readLine("A neved: ");

1. példa

String s = Console.readLine();for(int i=s.length()-1; i>=0; i--) System.out.print(s.charAt(i));System.out.println();

System.out.println(s.toUpperCase());System.out.println(s.toLowerCase());

if(s.length()>=9) System.out.println(s.substring(0,9));

if(s.length()>=3) System.out.println(s.substring(s.length()-3));

System.out.println(s.replace(' ','-'));

2. példa

String s=Console.readLine();String elso=s;while(!s.equals("*")){ if(s.compareTo(elso)<0) elso=s; s=Console.readLine();}System.out.println(elso);

StringBuffer osztályStringBuffer osztály KonstruktorokKonstruktorok

StringBuffer()StringBuffer() StringBuffer(int length)StringBuffer(int length) StringBuffer(String str)StringBuffer(String str)

Kapacitás, hossz, indexKapacitás, hossz, index capacity():intcapacity():int length():intlength():int ensureCapacity(int minimumCapacity)ensureCapacity(int minimumCapacity) setLength(int newLength)setLength(int newLength) charAt(int index): charcharAt(int index): char

Manipulálható szöveg

StringBuffer osztály (folyt.)StringBuffer osztály (folyt.) BővítésBővítés

append (append (<<Type> value): StringBufferType> value): StringBuffer append (append (<t<type> value): StringBufferype> value): StringBuffer insert (int offset, insert (int offset, <<Type> value): StringBufferType> value): StringBuffer insert (int offset, insert (int offset, <t<type> value): StringBufferype> value): StringBuffer

TörlésTörlés deleteCharAt(int index): StringBufferdeleteCharAt(int index): StringBuffer delete(int start, int end): StringBufferdelete(int start, int end): StringBuffer

StringBuffer osztály (folyt.)StringBuffer osztály (folyt.) EgyébEgyéb

setCharAt(int index, char ch)setCharAt(int index, char ch) replace(int start, int end, String str): replace(int start, int end, String str):

StringBufferStringBuffer reverse(): StringBufferreverse(): StringBuffer substring(int start): Stringsubstring(int start): String substring(int start, int end): Stringsubstring(int start, int end): String toString(): StringtoString(): String

StringBuffer hegy1 = new StringBuffer("Machu");StringBuffer hegy1 = new StringBuffer("Machu"); //1//1

StringBuffer hegy2 = hegy1.append(" Picchu");StringBuffer hegy2 = hegy1.append(" Picchu"); //2//2

hegy2.insert(0,"Ez is ");hegy2.insert(0,"Ez is "); //3//3

hegy1:StringBuffer

"Machu"

//1 hegy1

hegy2

:StringBuffer

"Machu Picchu"

//2

hegy1

hegy2

:StringBuffer

"Ez is Machu Picchu"

//3

Feladat – CsereOlvassunk be egy szöveget, majd cseréljük ki az összes & jelet az and szóra!

import extra.*;import extra.*;

public class Csere {public class Csere {

public static void main(String[] args) {public static void main(String[] args) {

// következő dián// következő dián

}}

}}

StringBuffer szoveg = StringBuffer szoveg =

new StringBuffer(Console.readLine("Szoveg: "));new StringBuffer(Console.readLine("Szoveg: ")); //1//1

int poz = szoveg.toString().indexOf('&');int poz = szoveg.toString().indexOf('&'); //2 //2

while (poz!=-1) {while (poz!=-1) {

szoveg.replace(poz,poz+1,"and");szoveg.replace(poz,poz+1,"and"); //3//3

poz = szoveg.toString().indexOf('&');poz = szoveg.toString().indexOf('&'); //4//4

}}

System.out.println(szoveg);System.out.println(szoveg); //5//5

Objektum átadása Objektum átadása paraméterkéntparaméterként

Feladat – Objektum paraméterÍrjunk egy olyan eljárást, amely a paraméterként megkapott szöveget széthúzza, vagyis minden karaktere után beszúr egy szóközt!

import extra.*;import extra.*;

public class ObjektumParameter {public class ObjektumParameter {

//következő dián//következő dián

}}

static void szethuz(StringBuffer str) {static void szethuz(StringBuffer str) {

for (int i=str.length()-1; i>0; i--)for (int i=str.length()-1; i>0; i--)

str.insert(i,' ');str.insert(i,' ');

str = null;str = null; // csak demonstrációs célú // csak demonstrációs célú utasításutasítás

}}

public static void main(String[] args) {public static void main(String[] args) {

StringBuffer sb = new StringBuffer("Peace");StringBuffer sb = new StringBuffer("Peace");

szethuz(sb); szethuz(sb);

System.out.println("*"+sb+"*");System.out.println("*"+sb+"*"); // // "*P e a c "*P e a c e*"e*"

}}

Értékadás szerintikompatibilitás!

Csak a referencia másolódik át!

:StringBuffer

"Peace"

str

sb

:StringBuffer

"P e a c e"

str

sb

null

A metódusba való belépéskor:

A metódusból való kilépés előtt:

A metódus csak a mutatott objektumot

változtathatja meg, a referenciát nem!

TömbökTömbök A tömb referencia típusú változó, melyet A tömb referencia típusú változó, melyet

deklarál-nunk kell. Az elemtípus lehet akár deklarál-nunk kell. Az elemtípus lehet akár primitív, akár referencia (osztály típusú vagy primitív, akár referencia (osztály típusú vagy tömb típusú).tömb típusú).

DeklarálásDeklarálás::

elemtípus [] tömbazonosító; vagyvagy elemtípus tömbazonosító [];

pl:pl: int [] a; //inkább ez ajánlott int b[];

Az így deklarált változó képes egy, a Az így deklarált változó képes egy, a megadott elemtípusú tömbre mutatni. Még megadott elemtípusú tömbre mutatni. Még csak a referenciának (memóriacímnek) csak a referenciának (memóriacímnek) foglaltunk helyet, a tömböt külön létre kell foglaltunk helyet, a tömböt külön létre kell hoznunk.hoznunk.

Létrehozás Létrehozás (futás közben): (futás közben): new elemtípus [méret] pl: pl: a = new int[10];

b = new int[20]; Természetesen történhet rögtön a Természetesen történhet rögtön a

deklaráláskor is a létrehozás: deklaráláskor is a létrehozás: String[] sTomb = new String[50];

Minden tömbnek van egy length konstansa. Indexelés: 0 .. length-1

int[] iArray=new int[10];

for(int i=0; i<iArray.length; i++) iArray[i]=Console.readInt(i+1+". szam: ");

System.out.println("Az elemek visszafele:");for(int i=iArray.length-1; i>=0; i--) System.out.print(iArray[i]+" ");

for(int i=0; i<10; i++)

Tömb inicializálásaTömb inicializálása

Inicializáló blokkInicializáló blokk: deklaráláskor a tömb : deklaráláskor a tömb elemeinek kezdeti értékek adhatók, pl:elemeinek kezdeti értékek adhatók, pl: int[] iArray={2, 4, 6, 8, 10};int[] iArray={2, 4, 6, 8, 10}; char[] char[]

szamjegyek={'0','1','2','3','4','5','6','7','8','9'}szamjegyek={'0','1','2','3','4','5','6','7','8','9'}

Ekkor nem kell a tömböt a Ekkor nem kell a tömböt a new new operátorral létrehozni, a operátorral létrehozni, a {}{} blokk képző blokk képző operátor megteszi ezt helyettünk. operátor megteszi ezt helyettünk.

A tömb mérete pontosan akkora lesz, A tömb mérete pontosan akkora lesz, amennyi a felsorolt értékek száma.amennyi a felsorolt értékek száma.

Értékadás tömbök közöttÉrtékadás tömbök között

A A t2 tömb tömb értékadásértékadás szerint kompatibilis a szerint kompatibilis a t1 tömbbel (azaz tömbbel (azaz t1=t2 megengedett), ha megengedett), ha primitív elemtípus esetén primitív elemtípus esetén t1 és és t2 elemtípusa elemtípusa

azonos;azonos; referencia elemtípus esetén referencia elemtípus esetén t2 elemtípusa elemtípusa t1 elem- elem-

típusával azonos, vagy annak leszármazottja.típusával azonos, vagy annak leszármazottja. Értékadáskor a tömb referenciája kap értéket, Értékadáskor a tömb referenciája kap értéket,

nem pedig az elemei (a tömb nem másolódik, nem pedig az elemei (a tömb nem másolódik, hanem átíródik a mutatója), így különböző hosz-hanem átíródik a mutatója), így különböző hosz-szúságú tömbök is értékül adhatók egymásnak.szúságú tömbök is értékül adhatók egymásnak.

Kétdimenziós tömbKétdimenziós tömb

Deklarálás: Deklarálás: elemtípus [][] tömbazonosító; Teljes kétdimenziós tömb létrehozása:Teljes kétdimenziós tömb létrehozása:

new elemtípus [méret0] [méret1] Pl: Pl: int[][] matrix

Lépésenkénti (soronkénti) létrehozás. A sorok Lépésenkénti (soronkénti) létrehozás. A sorok különböző méretűek lehetnek, pl:különböző méretűek lehetnek, pl: double[][] atlagok = new double[4][]; atlagok[0] = new double[20]; atlagok[1] = new double[18]; atlagok[2] = new double[25]; atlagok[3] = new double[22];

Analóg a helyzet a többdimenziós tömbök esetén.Analóg a helyzet a többdimenziós tömbök esetén.

= new int[3][4];

Tömb paraméter Tömb paraméter

Formális paraméterként egy tömbreferenciát Formális paraméterként egy tömbreferenciát kell deklarálnunk, amely fogadja az aktuális kell deklarálnunk, amely fogadja az aktuális tömb referenciáját.tömb referenciáját.

Az aktuális tömbnek értékadás szerint Az aktuális tömbnek értékadás szerint kompatíbi-lisnek kell lennie a formális kompatíbi-lisnek kell lennie a formális tömbbel.tömbbel.

PéldaPélda: Írjunk osztályt, amelynek adata egy : Írjunk osztályt, amelynek adata egy int tömb. Az objektum létrehozásakor a tömb. Az objektum létrehozásakor a konstruktor paraméterében adhassuk meg a konstruktor paraméterében adhassuk meg a tömb hosszát. Tartalmazzon egy tömb hosszát. Tartalmazzon egy bekér, , kiir és egy és egy osszeg nevű metódust! nevű metódust!

import extra.*;class Tomb{ private int[]t; public Tomb(int hossz){ t = new int[hossz]; } public void beker(){ for(int i=0; i<t.length; i++) t[i] = Console.readInt(i+1+". szam: "); } public void kiir(){ for(int i=0;i<t.length;i++) System.out.print(t[i]+" "); System.out.println(); } public int osszeg(){ int s=0; for(int i=0;i<t.length;i++) s+=t[i]; return s; }}//Tomb

public class Tombok{ public static void main(String[] args){ Tomb t1=new Tomb(5); Tomb t2=new Tomb(7); System.out.println("Adja meg az 1. tomb elemeit (5):"); t1.beker(); System.out.println("Adja meg a 2. tomb elemeit (7):"); t2.beker(); System.out.println("Az elso tomb:"); t1.kiir(); System.out.println("Az elemek osszege: "+ t1.osszeg()); System.out.println("A masodik tomb:"); t2.kiir(); }}

ÖröklődésÖröklődés

Öröklődés (inheritance) más néven Öröklődés (inheritance) más néven kiterjesztés (extension): Egy már meglévő kiterjesztés (extension): Egy már meglévő osztály továbbfejlesztése.osztály továbbfejlesztése. Újabb tulajdonságokat és metódusokat Újabb tulajdonságokat és metódusokat

adhatunk hozzáadhatunk hozzá Meglévő metódusait átírhatjukMeglévő metódusait átírhatjuk

Cél: Cél: Specializáció: egy objektum leírásához egyedi Specializáció: egy objektum leírásához egyedi

jellemzőket adunk hozzá.jellemzőket adunk hozzá. Általánosítás: több objektum leírásából Általánosítás: több objektum leírásából

kiemeljük a közös jellemzőket.kiemeljük a közös jellemzőket. Java: Java: class Auto extends Jarmu{class Auto extends Jarmu{ ... ...}}

SzabályokSzabályok Egy osztályból több osztály is Egy osztályból több osztály is

származtathatószármaztatható Egy osztályhierarchia mélysége Egy osztályhierarchia mélysége

elvileg tetszőleges lehetelvileg tetszőleges lehet Az öröklés tranzitívAz öröklés tranzitív Jávában: Jávában:

Egy osztálynak csak egy közvetlen őse Egy osztálynak csak egy közvetlen őse lehet (nincs többszörös öröklés)lehet (nincs többszörös öröklés)

Minden osztálynak őse az objectMinden osztálynak őse az object

MintafeladatMintafeladat Különböző hengereket szeretnénk Különböző hengereket szeretnénk

nyilvántartani:nyilvántartani: Csupán mértani testek, sugaruk és Csupán mértani testek, sugaruk és

magasságuk vanmagasságuk van Tömör hengerek, súlyuk is vanTömör hengerek, súlyuk is van CsövekCsövek

Henger

-sugar, magassag:double

+Henger(sugar, magassag:double)+getSugar():double+getMagassag():double+terfogat():double+toString():String

TomorHenger

-fajsuly:double

+TomorHenger(sugar, magassag, fajsuly:double)+getFajsuly():double+suly():double+toString():String

Cso

-falVastagsag:double

+Cso(sugar, magassag, fajsuly, falVastagsag:double)+getFalVastagsag():double+terfogat():double+toString():String

Megjegyzések a példaprogramhozMegjegyzések a példaprogramhoz

Az Az Object Object osztály osztály getClass()getClass() metódusa egy metódusa egy ClassClass osztályú objektumot ad vissza, melynek osztályú objektumot ad vissza, melynek getName()getName() metódusát használtuk ( metódusát használtuk (HengerHenger: 22. : 22. sor)sor)

thisthis: az objektum referenciája: az objektum referenciájasupersuper: az objektum referenciája, de közvetlen : az objektum referenciája, de közvetlen ősosztály típusúősosztály típusú

A A hengerekhengerek tömb elemei tömb elemei HengerHenger osztályú osztályú referenciák, melyek azonosíthatnak referenciák, melyek azonosíthatnak leszármaztatott osztályú objektumokat is.leszármaztatott osztályú objektumokat is.Henger h; TomorHenger th;Henger h; TomorHenger th;h=th; //jóh=th; //jóth=h; //típushibath=h; //típushibath=(TomorHenger)h //típuskényszerítésth=(TomorHenger)h //típuskényszerítés

A lista és az átlagtérfogat műveleteknél az A lista és az átlagtérfogat műveleteknél az objektumok valódi típusa határozza meg, hogy objektumok valódi típusa határozza meg, hogy melyik melyik toString()toString(), ill , ill terfogat()terfogat() metódus fog metódus fog végrehajtódni: végrehajtódni: polimorfizmuspolimorfizmus ( (ld. 6. diald. 6. dia))

instanceofinstanceof operátor operátor::<objektum> instanceof <osztály><objektum> instanceof <osztály>Eredménye egy Eredménye egy booleanboolean típusú érték, mely típusú érték, mely truetrue, ha az , ha az objektumobjektum osztálya a megadott osztálya a megadott osztályosztály vagy annak leszármazottja. vagy annak leszármazottja.

Statikus típusStatikus típus: amit a referencia : amit a referencia deklaráláskor kapdeklaráláskor kapDinamikus típusDinamikus típus: amilyen osztályú : amilyen osztályú objektumot valójában azonosítobjektumot valójában azonosíthengerek[3]=new Cso(2,10,2,1);hengerek[3]=new Cso(2,10,2,1);hengerek[3]hengerek[3] statikus típusa statikus típusa HengerHenger, , dinamikus típusa dinamikus típusa CsoCso..

Egy utódosztály akkor is örökli az ősosztály Egy utódosztály akkor is örökli az ősosztály adatait, ha nem látja azokat (mert private adatait, ha nem látja azokat (mert private elérhetőségűek)elérhetőségűek)

Metódusok felülírásaMetódusok felülírása Akkor van szó felülírásról, ha a metódusok Akkor van szó felülírásról, ha a metódusok

szignatúrái megegyeznek (egyébként túlterhelés)szignatúrái megegyeznek (egyébként túlterhelés) Csak példánymetódust lehet felülírniCsak példánymetódust lehet felülírni Nem lehet felülírni, ha Nem lehet felülírni, ha finalfinal Dinamikus kötés (futás alatti kötés, késői kötés):Dinamikus kötés (futás alatti kötés, késői kötés):

Az osztályhierarchia bármely pontjáról is hívunk Az osztályhierarchia bármely pontjáról is hívunk meg egy példánymetódust, minden esetben a meg egy példánymetódust, minden esetben a megszólított objektum osztályában (vagy ha ott megszólított objektum osztályában (vagy ha ott nincs, akkor a legközelebbi ősben) deklarált nincs, akkor a legközelebbi ősben) deklarált metódus fog végrehajtódni.metódus fog végrehajtódni.A pontos címet a rendszer futáskor határozza A pontos címet a rendszer futáskor határozza meg.meg.(Pl. (Pl. TomorHengerTomorHenger, ill. , ill. CsoCso osztályú objektumok osztályú objektumok esetén a esetén a sulysuly metódus meghívásakor más-más metódus meghívásakor más-más terfogatterfogat metódus hajtódik végre.) metódus hajtódik végre.)

KonstruktorokKonstruktorok

Nem öröklődik, nem lehet felülírniNem öröklődik, nem lehet felülírni Osztályon belül az egyik konstruktorból a másik Osztályon belül az egyik konstruktorból a másik

így hívható:így hívható:this(paraméterek)this(paraméterek)

Egy konstruktorból a közvetlen ős konstruktor így Egy konstruktorból a közvetlen ős konstruktor így hívható:hívható:super(paraméterek)super(paraméterek)

Minden konstruktornak tartalmaznia kell Minden konstruktornak tartalmaznia kell pontosan egy pontosan egy this()this() vagy vagy super()super() hívást legelső hívást legelső utasításként. Ha egyik sem szerepel, akkor a utasításként. Ha egyik sem szerepel, akkor a fordító betesz egy alapértelmezett paraméter fordító betesz egy alapértelmezett paraméter nélküli nélküli super()super() hívást. Ekkor viszont lennie kell a hívást. Ekkor viszont lennie kell a közvetlen ősosztályban paraméter nélküli közvetlen ősosztályban paraméter nélküli konstruktor. konstruktor.

Elv: minden konstruktor a saját osztálya adatait Elv: minden konstruktor a saját osztálya adatait inicializáljainicializálja

Absztrakt metódus, absztrakt osztályAbsztrakt metódus, absztrakt osztály

Egy metódus absztrakt, ha csak a Egy metódus absztrakt, ha csak a fejlécét adjuk meg. (nem fejlécét adjuk meg. (nem implementáljuk)implementáljuk)

Kifejtése valamely utód osztályban Kifejtése valamely utód osztályban történiktörténik

Egy osztály absztrakt, ha absztrakt Egy osztály absztrakt, ha absztrakt metódus(oka)t tartalmazmetódus(oka)t tartalmaz

Nem példányosítható az absztrakt Nem példányosítható az absztrakt osztály (örökítési célokat szolgál) osztály (örökítési célokat szolgál)

Absztrakt metódust tartalmazó osztály Absztrakt metódust tartalmazó osztály csak absztrakt lehetcsak absztrakt lehet

Idom{abstract}

-fajsuly:double=0.8

+terfogat():double+suly():double

Gomb

-sugar:double

+Gomb(sugar:double)+terfogat():double+toString():String

Hasab

-a,b,magassag:double

+Hasab(a,b,magassag:double)+terfogat():double+toString():String

InterfészInterfész Az interfész olyan viselkedéseket definiál, Az interfész olyan viselkedéseket definiál,

amelyet az osztályhierarchia tetszőleges amelyet az osztályhierarchia tetszőleges osztályával megvalósíthatunk.osztályával megvalósíthatunk.

Az interfész (Az interfész (interfaceinterface) metódusfejeket definiál ) metódusfejeket definiál abból a célból, hogy valamely osztály azt a abból a célból, hogy valamely osztály azt a későbbiekben implementálja, megvalósítsa.későbbiekben implementálja, megvalósítsa.

Definiálhat konstansokat (Definiálhat konstansokat (public static finalpublic static final)) Az objektum elérésének, használatának egy Az objektum elérésének, használatának egy

lehetséges módját határozza meg.lehetséges módját határozza meg. Egy interfészből nem lehet példányt létrehozniEgy interfészből nem lehet példányt létrehozni Az interfészek örökíthetőkAz interfészek örökíthetők Egy konkrét osztály megvalósítja az interfészt, ha Egy konkrét osztály megvalósítja az interfészt, ha

az összes metódusát megvalósítja (UML az összes metódusát megvalósítja (UML szaggatott nyíl, java kulcsszó: szaggatott nyíl, java kulcsszó: implementsimplements))

Konvenció: az Konvenció: az implementsimplements záradék az záradék az extendsextends záradékot követi, ha mindkettő van.záradékot követi, ha mindkettő van.

Egy osztály több interfészt is implementálhatEgy osztály több interfészt is implementálhat Az értékadás kompatibilitás hasonló, mint az Az értékadás kompatibilitás hasonló, mint az

öröklődés eseténöröklődés esetén Mivel az interfész a megvalósítás nélküli, vagyis Mivel az interfész a megvalósítás nélküli, vagyis

absztrakt metódusok listája, alig különbözik az absztrakt metódusok listája, alig különbözik az absztrakt osztálytól. A különbségek:absztrakt osztálytól. A különbségek: Az interfész egyetlen metódust sem implementálhat, az Az interfész egyetlen metódust sem implementálhat, az

absztrakt osztály igen.absztrakt osztály igen. Az osztály megvalósíthat több interfészt, de csak egy Az osztály megvalósíthat több interfészt, de csak egy

ősosztálya lehet.ősosztálya lehet. Az interfész nem része az osztályhierarchiának. Az interfész nem része az osztályhierarchiának.

Egymástól "független" osztályok is megvalósíthatják Egymástól "független" osztályok is megvalósíthatják ugyanazt az interfészt.ugyanazt az interfészt.

Amikor egy osztály megvalósít egy interfészt, Amikor egy osztály megvalósít egy interfészt, akkor alapvetően aláír egy szerződést. Az akkor alapvetően aláír egy szerződést. Az osztálynak implementálni kell az interfészben és osztálynak implementálni kell az interfészben és szülőinterfészeiben deklarált összes metódust, szülőinterfészeiben deklarált összes metódust, vagy az osztályt absztraktként kell deklarálni.vagy az osztályt absztraktként kell deklarálni.

Az interfészek hasznosak a következő Az interfészek hasznosak a következő esetekben:esetekben: Hasonlóságok megfogalmazása anélkül, hogy Hasonlóságok megfogalmazása anélkül, hogy

mesterkélt osztályhierarchiát építenénk felmesterkélt osztályhierarchiát építenénk fel(Például az ember és a papagáj is tud fütyülni, (Például az ember és a papagáj is tud fütyülni, mégsem célszerű az mégsem célszerű az EmberekEmberek és a és a PapagájokPapagájok osztályokat a osztályokat a Fütyülni_tudókFütyülni_tudók osztályból osztályból származtatni, logikusabb az származtatni, logikusabb az ÁllatokÁllatok-ból -ból (valamely köztes osztályokon keresztül), de (valamely köztes osztályokon keresztül), de mindkettő implementálhatja a mindkettő implementálhatja a Fütyülni_tudókFütyülni_tudók interfészt.interfészt.

Olyan metódusok definiálása, amelyeket több Olyan metódusok definiálása, amelyeket több osztályban meg kell valósítaniosztályban meg kell valósítani

Többszörös öröklődés modellezéseTöbbszörös öröklődés modellezése

public interface Ragadozó { public interface Ragadozó { public boolean üldözés(Préda p); public boolean üldözés(Préda p); public void marcangolás(Préda p); public void marcangolás(Préda p); } }

public class Cicus implements Ragadozó { public class Cicus implements Ragadozó { public boolean üldözés(Préda p) { public boolean üldözés(Préda p) { // a p préda üldözésének kifejtése// a p préda üldözésének kifejtése

System.out.println(„hess”); System.out.println(„hess”); } }

public void marcangolás (Préda p) { public void marcangolás (Préda p) { // a préda elfogyasztásának // a préda elfogyasztásának // // kifejtése kifejtése

System.out.println(„Nyamm”);System.out.println(„Nyamm”); } } } }

Az interfészek másik használata, hogy Az interfészek másik használata, hogy objektumokat tudunk használni objektumokat tudunk használni származási osztályának ismerete nélkül származási osztályának ismerete nélkül arra koncentrálva, hogy megvalósít arra koncentrálva, hogy megvalósít egy bizonyos interfészt. egy bizonyos interfészt. (Például egy rendezési algoritmus (Például egy rendezési algoritmus megkívánja, hogy egy objektum megkívánja, hogy egy objektum ÖsszehasonlíthatóÖsszehasonlítható legyen. Így tudja, legyen. Így tudja, hogy valahogy rendezhetőek ezek az hogy valahogy rendezhetőek ezek az objektumok, de nem érdekes, hogy objektumok, de nem érdekes, hogy milyen osztályúak.)milyen osztályúak.)

public static final boolean tartalmaz(Comparable public static final boolean tartalmaz(Comparable szám, Comparable[] tömb) {szám, Comparable[] tömb) {

int alsó = 0;int alsó = 0; int felső = tömb.length - 1;int felső = tömb.length - 1; while (alsó <= felső) {while (alsó <= felső) { int közepe = (alsó + felső) / 2;int közepe = (alsó + felső) / 2; int hasonlítás = int hasonlítás =

szám.compareTo(tömb[közepe]);szám.compareTo(tömb[közepe]); if (hasonlítás < 0) if (hasonlítás < 0) felső = közepe - 1;felső = közepe - 1;

else if (hasonlítás > 0) else if (hasonlítás > 0) alsó = közepe + 1;alsó = közepe + 1;

else return true;else return true; }} return false;return false;}}

class Szám implements Comparable{class Szám implements Comparable{

int x;int x;

public Szám(int x){setX(x);}public Szám(int x){setX(x);}

public int getX(){ return x;}public int getX(){ return x;}

public void setX(int x){this.x=x;}public void setX(int x){this.x=x;}

public int compareTo(Object o){public int compareTo(Object o){

if (((Szám)o).x<getX()) return 1;if (((Szám)o).x<getX()) return 1;

else if (((Szám)o).x==getX()) else if (((Szám)o).x==getX()) return 0;return 0;

else return -1;else return -1;

}}

}}

class Szám implements Comparableclass Szám implements Comparable<Szám><Szám>{{public int compareTo(Szám o){public int compareTo(Szám o){ if (o.x<getX()) return 1;if (o.x<getX()) return 1; else if (o.x==getX()) return 0;else if (o.x==getX()) return 0; else return -1;else return -1; }}

class Szám implements Comparable{class Szám implements Comparable{public int compareTo(Object o){public int compareTo(Object o){

if (((Szám)o).x<getX()) return 1;if (((Szám)o).x<getX()) return 1; else if (((Szám)o).x==getX()) else if (((Szám)o).x==getX())

return 0;return 0; else return -1;else return -1; }}}}

public class Main {public class Main {static Szám szám=new Szám(5);static Szám szám=new Szám(5);static Szám[] tömb={new Szám(1),new static Szám[] tömb={new Szám(1),new

Szám(4),new Szám(6)};Szám(4),new Szám(6)};public static final boolean public static final boolean

tartalmaz(Comparable szám, Comparable[] tartalmaz(Comparable szám, Comparable[] tömb) {……………………tömb) {……………………

}} public static void main(String[] args) {public static void main(String[] args) { System.out.println(tartalmaz(szám, System.out.println(tartalmaz(szám,

tömb));tömb)); }}

}}

Comparable interfészComparable interfész

Object

«interfész»Comparable

+compareTo(Object obj): int

String

+compareTo(Object obj): int...

A String hasonlíthatóA String hasonlítható

class Henger implements Comparable<Henger>{ private double sugar, magassag; ... public int compareTo(Henger obj){ if(terfogat()<obj.terfogat()) return -1; if (terfogat()>obj.terfogat()) return 1; return 0; }}

import java.util.*;

public class HengerProgram { public static void main(String[] args) { Henger[] hengerek=new Henger[4]; ... //Max térfogat int max=0; for(int i=0;i<hengerek.length;i++) if(hengerek[i].compareTo(hengerek[max])>0) max=i; System.out.println("A legnagyobb térfogat: " +hengerek[max].terfogat()); //Rendezés Arrays.sort(hengerek); //Lista System.out.println("\nRendezve:"); for(int i=0;i<hengerek.length;i++) System.out.println(hengerek[i]); }}

A kollekció keretrendszer –A kollekció keretrendszer –Java Collections Framework Java Collections Framework

(JCF)(JCF) A kollekciók (konténerek) olyan objektumok, A kollekciók (konténerek) olyan objektumok,

melyek célja egy vagy több típusba tartozó melyek célja egy vagy több típusba tartozó objektumok memóriában történő összefoglaló objektumok memóriában történő összefoglaló jellegű tárolása, manipulálása és lekérdezése.jellegű tárolása, manipulálása és lekérdezése.

A kollekció keretrendszer egy egységes A kollekció keretrendszer egy egységes architektúra, ami a kollekciók megvalósítására, architektúra, ami a kollekciók megvalósítására, kezelésére szolgál.kezelésére szolgál.

Elemei:Elemei: Interfészek: absztrakt adattípusok, amelyek a kollekciókat Interfészek: absztrakt adattípusok, amelyek a kollekciókat

reprezentálják. Lehetővé teszik a kollekciók reprezentálják. Lehetővé teszik a kollekciók implementáció független kezelését.implementáció független kezelését.

Implementációk: a kollekció interfészek konkrét Implementációk: a kollekció interfészek konkrét implementációi. implementációi.

algoritmusok: azok a metódusok, amelyek hasznos algoritmusok: azok a metódusok, amelyek hasznos műveleteket valósítanak meg, mint például keresés, műveleteket valósítanak meg, mint például keresés, rendezés különböző kollekciókon.rendezés különböző kollekciókon.

C++ Standard Template Library (STL) C++ Standard Template Library (STL)

A kollekció keretrendszer A kollekció keretrendszer használatának előnyeihasználatának előnyei

Csökkenti a fejlesztési időtCsökkenti a fejlesztési időt Növeli a program sebességét és minőségétNöveli a program sebességét és minőségét Megkönnyítik az API-k használatát, Megkönnyítik az API-k használatát,

tervezéséttervezését Elősegíti a szoftver újrafelhasználhatóságátElősegíti a szoftver újrafelhasználhatóságát

InterfészekInterfészek

A kollekció interfészek (generic, általános) A kollekció interfészek (generic, általános) típus paraméterekkel dolgoznak. Például:típus paraméterekkel dolgoznak. Például: public interface Collection<E> ...public interface Collection<E> ...

Az Az <E><E> szintaxis azt jelenti, hogy az szintaxis azt jelenti, hogy az interfész általános (generikus) típussal interfész általános (generikus) típussal működik.működik.

Amikor deklarálunk egy Amikor deklarálunk egy CollectionCollection-t, meg -t, meg tudjuk határozni (ajánlott), hogy milyen tudjuk határozni (ajánlott), hogy milyen típusú objektumot tartalmaz a kollekció. típusú objektumot tartalmaz a kollekció.

A típus paraméter a fordítóprogram A típus paraméter a fordítóprogram számára lehetővé teszi, hogy csak az adott számára lehetővé teszi, hogy csak az adott típusú objektumot engedje belerakni a típusú objektumot engedje belerakni a kollekcióba, így csökkenti a futásidejű hibák kollekcióba, így csökkenti a futásidejű hibák számát.számát.

Ha megértettük az interfészek használatát, Ha megértettük az interfészek használatát, akkor a nagy részét megtudtuk annak, amit akkor a nagy részét megtudtuk annak, amit a JCF-ről tudni érdemes.a JCF-ről tudni érdemes.

CollectionCollection: akkor érdemes ezt : akkor érdemes ezt választani, ha a lehető legnagyobb választani, ha a lehető legnagyobb rugalmasságra van szükség. rugalmasságra van szükség.

SetSet: matematikai halmaz modellezése: matematikai halmaz modellezése ListList: sorszámozott kollekció, : sorszámozott kollekció,

hozzáférés az elemekhez index hozzáférés az elemekhez index segítségévelsegítségével

QueueQueue: várakozási sor létrehozására: várakozási sor létrehozására MapMap: az egyedi kulcsokat értékekké : az egyedi kulcsokat értékekké

képezi le.képezi le. SortedSetSortedSet SortedMapSortedMap

Általános célú implementációkÁltalános célú implementációk

A A CollectionCollection interfész interfész

Használható például különböző Használható például különböző kollekciók közötti konverzióra (mint kollekciók közötti konverzióra (mint közös nevező)közös nevező)List<String> list = new List<String> list = new ArrayList<String>(c);ArrayList<String>(c);

public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator<E> iterator();

// Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional

// Array operations Object[] toArray(); <T> T[] toArray(T[] a);}

import java.util.*;

public class HengerProgram { public static void main(String[] args) { Collection<Henger> hengerek= new ArrayList<Henger>(); hengerek.add(new Henger(2,10)); hengerek.add(new Henger(3,6)); hengerek.add(new TomorHenger(2,10,2)); hengerek.add(new Cso(2,10,2,1)); System.out.println(hengerek.size()); hengerek.clear(); System.out.println(hengerek.size()); }}

import java.util.*;

public class CollectionAddDemo { public static void main(String[] args) { Collection<Integer> szamok=new HashSet<Integer>(); int n=0; do{ if(szamok.add(Math.round((float)Math.random()*89)+1)) n++; }while(n<5); System.out.println(szamok); }}

import java.util.*;class Diak{ private String nev; private int pont; public Diak(String nev, int pont){ this.nev=nev; this.pont=pont; } public int getPont(){ return pont; } public boolean equals(Object obj){ return nev.equals(((Diak)obj).nev); } public String toString(){ return nev+": "+pont; }}

public class Diakok{ public static void main(String[]args){ Collection<Diak> diakok=new ArrayList<Diak>(); diakok.add(new Diak("Kovács István",10)); diakok.add(new Diak("Kiss Péter",2)); diakok.add(new Diak("Nagy Pál",10)); Diak diak=new Diak("Kiss Péter",0); System.out.println(diakok.contains(diak)); }}

A kollekciók bejárásaA kollekciók bejárása

1. A „1. A „for-eachfor-each” ciklussal” ciklussalfor (Object o : collection)for (Object o : collection) System.out.println(o); System.out.println(o);

for(Henger henger:hengerek)for(Henger henger:hengerek) System.out.println(henger.terfogat());System.out.println(henger.terfogat());

2. Iterátorral2. IterátorralAz iterátor egy olyan objektum, ami megengedi, Az iterátor egy olyan objektum, ami megengedi, hogy bejárjuk a kollekciót, és eltávolítsuk az hogy bejárjuk a kollekciót, és eltávolítsuk az elemeket a kollekcióból, ha akarjuk.elemeket a kollekcióból, ha akarjuk.Egy kollekció bejárásához az Egy kollekció bejárásához az iteratoriterator metódusának a meghívásával kérhetünk egy metódusának a meghívásával kérhetünk egy IteratorIterator objektumot. objektumot.

Az Az Iterator Iterator interfész:interfész:public interface Iterator<E> {public interface Iterator<E> { boolean hasNext(); boolean hasNext(); E next(); E next(); void remove(); } void remove(); }

A A hasNexthasNext metódus visszatérési értéke metódus visszatérési értéke truetrue, ha az , ha az iterációnak van még be nem járt eleme.iterációnak van még be nem járt eleme.A A removeremove metódus eltávolítja a kollekcióból az metódus eltávolítja a kollekcióból az utolsó elemet, amit a utolsó elemet, amit a nextnext hívására kaptunk. hívására kaptunk. Az Az Iterator.removeIterator.remove az egyetlen biztonságos út, az egyetlen biztonságos út, hogy módosítsuk a kollekciót az iteráció folyamán.hogy módosítsuk a kollekciót az iteráció folyamán.Iterátor használata célszerű a Iterátor használata célszerű a for-each for-each ciklus ciklus helyett a következő esetekben:helyett a következő esetekben:

Törölni szeretnénk a bejárás közben.Törölni szeretnénk a bejárás közben. Párhuzamosan több kollekciót szeretnénk bejárniPárhuzamosan több kollekciót szeretnénk bejárni

for (Iterator<Henger> it=hengerek.iterator(); it.hasNext(); )for (Iterator<Henger> it=hengerek.iterator(); it.hasNext(); ) System.out.println(it.next()); System.out.println(it.next());

for (Iterator<Henger> it=hengerek.iterator(); it.hasNext(); )for (Iterator<Henger> it=hengerek.iterator(); it.hasNext(); ) if (it.next().terfogat()<100) if (it.next().terfogat()<100) it.remove(); it.remove();

Collection Interface Bulk Operations Collection Interface Bulk Operations

Az egész kollekcióval hajtanak végre műveleteket.Az egész kollekcióval hajtanak végre műveleteket. containsAllcontainsAll – megmondja, hogy a kollekció tartalmazza-e – megmondja, hogy a kollekció tartalmazza-e

a paraméterben megadott kollekció összes eleméta paraméterben megadott kollekció összes elemét addAlladdAll – hozzáadja a kollekcióhoz a paraméterben – hozzáadja a kollekcióhoz a paraméterben

megadott kollekció összes elemétmegadott kollekció összes elemét removeAllremoveAll – eltávolítja a kollekcióból a paraméterben – eltávolítja a kollekcióból a paraméterben

megadott kollekció összes elemétmegadott kollekció összes elemét retainAllretainAll – eltávolítja a kollekcióból azokat az elemeket, – eltávolítja a kollekcióból azokat az elemeket,

amelyek a paraméterben megadott kollekcióban nincsenek amelyek a paraméterben megadott kollekcióban nincsenek bennebenne

clearclear – eltávolítja a kollekció összes elemét – eltávolítja a kollekció összes elemét

Pl: Pl: c.removeAll(Collections.singleton(e));c.removeAll(Collections.singleton(e)); c.removeAll(Collections.singleton(null));c.removeAll(Collections.singleton(null));

Collections.singleton(e)Collections.singleton(e): egy halmazzal tér vissza, mely : egy halmazzal tér vissza, mely csak a megadott elemet tartalmazza.csak a megadott elemet tartalmazza.

A A SetSet interfész interfész

Set Set egy speciális egy speciális CollectionCollection, amely nem tartalmaz , amely nem tartalmaz ismétlődő elemeket és van legalább egy ismétlődő elemeket és van legalább egy nullnull eleme. eleme.

A A SetSet csak a csak a CollectionCollection-tól örökölt metódusokat -tól örökölt metódusokat tartalmazza, azzal a megszorítással kiegészítve, hogy tartalmazza, azzal a megszorítással kiegészítve, hogy nem engedi meg az elemek ismétlődését.nem engedi meg az elemek ismétlődését.

// http://java.sun.com/j2se/1.5.0/docs/api/java/util/Set.html

public interface Set<E> extends Collection<E> { int size(); boolean isEmpty();

...

}

A Java platform három általános célú A Java platform három általános célú Set Set implementációt tartalmaz: a implementációt tartalmaz: a HashSetHashSet, , TreeSetTreeSet, és , és LinkedHashSetLinkedHashSet. .

HashSet HashSet esetén az elemeket egy hash esetén az elemeket egy hash táblában (hasítótáblában) tárolja, ez a táblában (hasítótáblában) tárolja, ez a legjobb választás, ha a bejárás sorrendje legjobb választás, ha a bejárás sorrendje nem fontos. nem fontos.

A A TreeSet TreeSet az elemeket egy fában tárolja az az elemeket egy fában tárolja az értékük szerint rendezetten. Lényegesen értékük szerint rendezetten. Lényegesen lassabb, mint a lassabb, mint a HashSetHashSet..

A A LinkedHashSetLinkedHashSet ötvözi a láncolt listát a ötvözi a láncolt listát a hash táblával. Beszúrás szerinti hash táblával. Beszúrás szerinti rendezettség.rendezettség.

import java.util.*;

public class SetDemo { public static void main(String[] args) { Collection<Integer> szamok=new ArrayList<Integer>(); for(int i=0;i<50;i++) szamok.add(Math.round((float)Math.random()*99)+1); for(Integer iobj:szamok) System.out.print(iobj+" "); System.out.println(); Set<Integer> szamokh=new HashSet<Integer>(szamok); for(Integer iobj:szamokh) System.out.print(iobj+" "); System.out.println(); }}

import java.util.*;public class FindDups { public static void main(String[] args) { String[] words={"i", "came", "i", "saw", "i", "left"}; Set<String> h = new HashSet<String>(); for (String s : words) if (!h.add(s)) System.out.println(„Többszörös elem: " + s); System.out.println(h.size() + " Különböző szavak: " + h); }}

String w="i came i saw i left";String s;Set<String> h = new HashSet<String>();for(StringTokenizer st=new StringTokenizer(w);st.hasMoreTokens();) if (!h.add(s=st.nextToken())) System.out.println(" Többszörös elem : " + s); System.out.println(h.size() + " Különböző szavak : " + h);

Set Interface Bulk Operations Set Interface Bulk Operations

Egyszerűen megvalósíthatók az algebrából ismert Egyszerűen megvalósíthatók az algebrából ismert halmazműveletek.halmazműveletek.

s1.containsAll(s2)s1.containsAll(s2) – Igaz logikai értékkel tér vissza, ha – Igaz logikai értékkel tér vissza, ha s2s2 részhalmaza részhalmaza s1s1-nek-nek

s1.addAll(s2)s1.addAll(s2) – Az – Az s1s1-be -be s1s1 és és s2s2 uniója kerül.uniója kerül. s1.removeAll(s2)s1.removeAll(s2) – Az – Az s1s1-be -be s1s1 és és s2s2 különbség kerül.különbség kerül. s1.retainAll(s2)s1.retainAll(s2) – Az – Az s1s1-be -be s1s1 és és s2s2 metszete kerül.metszete kerül. clearclear – eltávolítja a kollekció összes elemét – eltávolítja a kollekció összes elemét

Feladatok: Feladatok: 1. Módosítsuk a 1. Módosítsuk a FindDupsFindDups programot úgy, hogy azt akarjuk programot úgy, hogy azt akarjuk

tudni, hogy mely szavak fordulnak elő egyszer a listában, és tudni, hogy mely szavak fordulnak elő egyszer a listában, és mely szavak fordulnak elő többször, de nem akarunk duplán mely szavak fordulnak elő többször, de nem akarunk duplán kiírt szavakat látni. Ezt úgy tudjuk elérni, hogy két halmazt kiírt szavakat látni. Ezt úgy tudjuk elérni, hogy két halmazt hozunk létre: az egyik minden elemet tartalmaz, a másik hozunk létre: az egyik minden elemet tartalmaz, a másik csak a duplikáltakat.csak a duplikáltakat.

2. Hozzunk létre két Integer objektumokat tartalmazó halmazt 2. Hozzunk létre két Integer objektumokat tartalmazó halmazt a a FindDupsFindDups programban látott módon tömbökkel programban látott módon tömbökkel inicializálva. Állítsuk elő a két halmaz unióját, metszetét, inicializálva. Állítsuk elő a két halmaz unióját, metszetét, különbségét.különbségét.

A A ListList interfész interfész

Sorszámozott kollekcióSorszámozott kollekció A A CollectionCollection osztálytól örökölt műveletek mellett osztálytól örökölt műveletek mellett

újabbakat is tartalmaz:újabbakat is tartalmaz: Pozíció szerinti elérés: Az elemek a listában betöltött helyük Pozíció szerinti elérés: Az elemek a listában betöltött helyük

alapján is elérhetők. alapján is elérhetők.   E get(int index) index) Keresés: A megadott elemet kikeresi a listából, és visszaadja a Keresés: A megadott elemet kikeresi a listából, és visszaadja a

pozícióját. pozícióját. int indexOf(Object o)int indexOf(Object o) Bejárás: Kibővíti az Bejárás: Kibővíti az Iterator Iterator lehetőségeitlehetőségeit ListIterator<E> listIterator(); ListIterator<E> listIterator(int ListIterator<E> listIterator(); ListIterator<E> listIterator(int

index); index); Részlista: Lehetővé tesz részlista műveleteket.Részlista: Lehetővé tesz részlista műveleteket.

List<E>subList(int fromIndex, int toIndex) List<E>subList(int fromIndex, int toIndex) A Java platform két általános célú A Java platform két általános célú List List implementációt implementációt

tartalmaz: a tartalmaz: a ArrayListArrayList (mely általában hatékonyabb), és a (mely általában hatékonyabb), és a LinkedList LinkedList (mely bizonyos esetekben hatékonyabb), (mely bizonyos esetekben hatékonyabb), valamint hozzáigazította a régebbi valamint hozzáigazította a régebbi Vector Vector osztályt az új osztályt az új interfészhez.interfészhez.

public interface List<E> extends Collection<E> { // Pozicionált elérés E get(int index); E set(int index, E element); //optional boolean add(E element); //optional void add(int index, E element); //optional E remove(int index); //optional boolean addAll(int index, Collection<? extends E> c); //optional

// Keresés int indexOf(Object o); int lastIndexOf(Object o);

// Iterátor ListIterator<E> listIterator(); ListIterator<E> listIterator(int index);

// Tartomány nézet List<E> subList(int from, int to); }

A Collection-tól örökölt metódusokat az A Collection-tól örökölt metódusokat az elvárásainknak megfelelően elvárásainknak megfelelően használhatjuk.használhatjuk. removeremove metódus mindig az első előforduló metódus mindig az első előforduló

elemet törli a listából. elemet törli a listából. Az Az addadd és és addAll addAll metódusnál az elem a metódusnál az elem a

lista végére kerül. Például a lista végére kerül. Például a list1list1 végére végére másolja a másolja a list2list2 elemeit:elemeit: list1.addAll(list2);list1.addAll(list2);

A listaelemek összehasonlítása azok A listaelemek összehasonlítása azok equalsequals metódusa alapján történik metódusa alapján történik

A pozíció szerinti elérés és keresés A pozíció szerinti elérés és keresés metódusainak működése értelemszerűmetódusainak működése értelemszerű

Iterátor funkciók kiterjesztéseIterátor funkciók kiterjesztésepublic interface ListIterator<E> extends Iterator<E> { boolean hasNext(); E next(); boolean hasPrevious(); E previous(); int nextIndex(); int previousIndex(); void remove(); //optional void set(E e); //optional void add(E e); //optional }

Pl:for (ListIterator<Type> it = list.listIterator(list.size()); it.hasPrevious(); ) { Type t = it.previous(); ...}

Tartomány nézetTartomány nézet

A A subList(int fromIndex, int toIndex)subList(int fromIndex, int toIndex) részlista metódus visszaadja a lista egy részlista metódus visszaadja a lista egy szeletétszeletét

A visszaadott lista kapcsolatban marad az A visszaadott lista kapcsolatban marad az eredeti listával. Így bármilyen módosítás eredeti listával. Így bármilyen módosítás történik a részlistán, az hatással lesz az történik a részlistán, az hatással lesz az eredetire is, sőt ez fordítva is igaz.eredetire is, sőt ez fordítva is igaz.

Pl: A lista egy részét töröljükPl: A lista egy részét töröljüklist.subList(fromIndex, toIndex).clear();list.subList(fromIndex, toIndex).clear();

Lista algoritmusokLista algoritmusok A A CollectionsCollections osztály nagyon hatékonyan osztály nagyon hatékonyan

használható algoritmusokat nyújt listák kezelésére.használható algoritmusokat nyújt listák kezelésére. A következő lista csak felsorolja a fontosabbakat:A következő lista csak felsorolja a fontosabbakat:

sortsort: Rendezi a listát.: Rendezi a listát. shuffleshuffle: Véletlenszerűen felcserél elemeket a listában. : Véletlenszerűen felcserél elemeket a listában.

(Permutál.)(Permutál.) reversereverse: Megfordítja az elemek sorrendjét a listában.: Megfordítja az elemek sorrendjét a listában. rotaterotate: Egy adott távolsággal rotálja az elemeket.: Egy adott távolsággal rotálja az elemeket. swapswap: Felcserél két meghatározott pozícióban levő elemet.: Felcserél két meghatározott pozícióban levő elemet. replaceAllreplaceAll: Az összes előforduló elemet kicseréli egy : Az összes előforduló elemet kicseréli egy

másikra.másikra. fillfill: Felülírja az összes elemet egy meghatározott : Felülírja az összes elemet egy meghatározott

értékkel.értékkel. copycopy: Átmásolja a forráslistát egy céllistába.: Átmásolja a forráslistát egy céllistába. binarySearchbinarySearch: Egy elemet keres a bináris keresési : Egy elemet keres a bináris keresési

algoritmust használva.algoritmust használva. indexOfSubListindexOfSubList: Visszatér az első olyan indexszel, : Visszatér az első olyan indexszel,

amelynél kezdődő részlista egyenlő a másik listával.amelynél kezdődő részlista egyenlő a másik listával. lastIndexOfSubListlastIndexOfSubList: Visszatér az utolsó olyan indexszel, : Visszatér az utolsó olyan indexszel,

amelynél kezdődő részlista egyenlő a másik listával.amelynél kezdődő részlista egyenlő a másik listával.

FeladatFeladat

Módosítsa a korábban látott raktárprogramot úgy, Módosítsa a korábban látott raktárprogramot úgy, hogy az egy listában tárolja az egyes árufajták hogy az egy listában tárolja az egyes árufajták adatait. Végezze el a következő műveleteket:adatait. Végezze el a következő műveleteket:

Árufajta felvételeÁrufajta felvétele ListázásListázás EladásEladás VételVétel ÁrmódosításÁrmódosítás

A A Map Map interfészinterfész

Kulcs-érték párokat tartalmazKulcs-érték párokat tartalmaz Az egyedi kulcs alapján megkereshetjük a Az egyedi kulcs alapján megkereshetjük a

kulcshoz tartozó értéket (sokkal kulcshoz tartozó értéket (sokkal kényelmesebb, mintha össze kellene kényelmesebb, mintha össze kellene állítanunk egy keresőobjektumot)állítanunk egy keresőobjektumot)

A Java platform három általános célú A Java platform három általános célú Map Map implementációt tartalmaz: implementációt tartalmaz: HashMap, HashMap, TreeMapTreeMap és és LinkedHashMap LinkedHashMap (melyek (melyek hasonló tárolási elvűek és működésűek, hasonló tárolási elvűek és működésűek, mint a Set implementációk), valamint mint a Set implementációk), valamint hozzáigazította a régebbi hozzáigazította a régebbi Hashtable Hashtable osztályt az új interfészhez.osztályt az új interfészhez.

public interface Map<K,V> { // Alap műveletek V put(K key, V value); V get(Object key); V remove(Object key); boolean containsKey(Object key); boolean containsValue(Object value); int size(); boolean isEmpty(); // Tömeges (bulk) műveletek void putAll(Map<? extends K, ? extends V> m); void clear(); // Kollekció nézetek public Set<K> keySet(); public Collection<V> values(); public Set<Map.Entry<K,V>> entrySet(); // Az entrySet elemeihez használt interfész public interface Entry { K getKey(); V getValue(); V setValue(V value); } }

import java.util.*;

public class Freq { public static void main(String[] args) { String[] words={"i","came","i","saw","i","left"}; Map<String, Integer> m=new HashMap<String, Integer>();

for (String w: words) { Integer freq=m.get(w); m.put(w, (freq==null)?1:freq+1); }

System.out.println(m.size() + " különböző szavak:"); System.out.println(m); }}

A A Collection viewCollection view metódusokkal háromféle nézetét kapjuk metódusokkal háromféle nézetét kapjuk a Map-neka Map-nek keySetkeySet: kulcsok halmaza (: kulcsok halmaza (SetSet)) valuesvalues: értékek kollekciója (: értékek kollekciója (CollectionCollection)) entrySetentrySet: kulcs-érték párok halmaza (: kulcs-érték párok halmaza (SetSet). A ). A MapMap interfész interfész

tartalmaz egy kis beágyazott interfészt – tartalmaz egy kis beágyazott interfészt – Map.EntryMap.Entry – ezen – ezen halmaz elemei típusának meghatározására.halmaz elemei típusának meghatározására.

Csak a kollekció nézetekkel lehet iterációt végezni a Map-en.Csak a kollekció nézetekkel lehet iterációt végezni a Map-en. Használhatók Használhatók remove, removeAll, retainAll, clear remove, removeAll, retainAll, clear

kollekció műveletekkollekció műveletek

for (KeyType key : m.keySet()) System.out.println(key);

//Iterátorral: //A kulcsok valamely tulajdonsága alapján szűrünk.for (Iterator<Type> it = m.keySet().iterator(); it.hasNext(); ) if (it.next().nemjó()) it.remove();

//A kulcs-érték párokon való iteráció bemutatása for (Map.Entry<KeyType, ValType> e : m.entrySet()) System.out.println(e.getKey() + ": " + e.getValue());

RendezésRendezés

Collections.sort(l);Collections.sort(l);Alapértelmezett rendezés, a lista elemeinek Alapértelmezett rendezés, a lista elemeinek osztálya implementálja osztálya implementálja ComparableComparable interfészt, interfészt, azaz tartalmaz egy azaz tartalmaz egy compareTocompareTo metódust. metódust. Korlátok:Korlátok:

Csak egyféle rendezettségCsak egyféle rendezettség Be van égetve az objektumba, nem lehet változtatni rajtaBe van égetve az objektumba, nem lehet változtatni rajta Lehet, hogy nem is implementálta a Lehet, hogy nem is implementálta a ComparableComparable interfészt interfészt

Rendezés egy Comparator objektummalRendezés egy Comparator objektummalpublic interface Comparator<T> {public interface Comparator<T> { int compare(T o1, T o2); int compare(T o1, T o2); }} „„Névtelen osztály” létrehozásávalNévtelen osztály” létrehozásával

import java.util.*;

public class DiakokList3{ public static void main(String[]args){ final Comparator<Diak> PONTSZERINT=new Comparator<Diak>(){ public int compare(Diak d1, Diak d2){ return d1.getPont()-d2.getPont(); } };

List<Diak> diakok=new ArrayList<Diak>(); diakok.add(new Diak("Kovács István",10)); ... //Természetes rendezettség szerinti lista Collections.sort(diakok); for(Diak a:diakok) System.out.println(a); //Lista comparator szerinti rendezettséggel Collections.sort(diakok, PONTSZERINT); for(Diak a:diakok) System.out.println(a); }}

A A SortedSet SortedSet interfészinterfészpublic interface SortedSet<E> extends Set<E> { // Tartomány nézet SortedSet<E> subSet(E fromElement, E toElement); SortedSet<E> headSet(E toElement); SortedSet<E> tailSet(E fromElement);

// Végpontok E first(); E last();

// Comparator hozzáférés Comparator<? super E> comparator();}

Rendezettség:Rendezettség:• Az elemek természetes rendezettsége szerintAz elemek természetes rendezettsége szerint•A létrehozásakor megadott A létrehozásakor megadott ComparatorComparator alapján alapján

Általános implementáció: Általános implementáció: TreeSetTreeSet

import java.util.*;public class SortedSetDemo{ public static void main(String[]args){ int[]a={21,25,23,28,22,26,12}; SortedSet<Integer> s1=new TreeSet<Integer>(); for(Integer i: a) s1.add(i); System.out.println(s1); System.out.println(s1.headSet(25)); Comparator<Integer> reverse=new Comparator<Integer>(){ public int compare(Integer i1, Integer i2){ return i2-i1; } }; SortedSet<Integer> s2=new TreeSet<Integer>(reverse); s2.addAll(s1); System.out.println(s2); }}

int count = dictionary.subSet("doorbell", "pickle").size();

dictionary.subSet("f", "g").clear();

for (char ch = 'a'; ch <= 'z'; ch++) { String from = String.valueOf(ch); String to = String.valueOf(ch); System.out.println(from + ": " + dictionary.subSet(from, to).size());}

A A SortedMap SortedMap interfészinterfész

public interface SortedMap<K, V> extends Map<K, V>{ Comparator<? super K> comparator(); SortedMap<K, V> subMap(K fromKey, K toKey); SortedMap<K, V> headMap(K toKey); SortedMap<K, V> tailMap(K fromKey); K firstKey(); K lastKey();}

Rendezettség:Rendezettség:• Az kulcsok természetes rendezettsége szerintAz kulcsok természetes rendezettsége szerint•A létrehozásakor megadott A létrehozásakor megadott ComparatorComparator alapján alapján

Általános implementáció: Általános implementáció: TreeSetTreeSet

Az interfészek összegzéseAz interfészek összegzése

A kollekciós „mag” (core) interfészek A kollekciós „mag” (core) interfészek alkotják a JCF alapjait. A Java Kollekciók alkotják a JCF alapjait. A Java Kollekciók Keretrendszer két elkülönülő interfész Keretrendszer két elkülönülő interfész fát tartalmaz: fát tartalmaz:

Az első fa gyökere a Az első fa gyökere a CollectionCollection interfész, ami biztosítja a többi interfész, ami biztosítja a többi kollekció alap funkcióit, mint például az kollekció alap funkcióit, mint például az addadd és a és a removeremove metódusok. metódusok.

A belőle származtatott interfészek A belőle származtatott interfészek (subinterface) — Set, List, Queue — (subinterface) — Set, List, Queue — teszik lehetővé a specializáltabb teszik lehetővé a specializáltabb kollekciókat. kollekciókat.

A A SetSet interfész nem enged meg interfész nem enged meg többszörös elemeket. A Set többszörös elemeket. A Set interfész alinterfésze a SortedSet, interfész alinterfésze a SortedSet, mely rendezettséget ad a halmaz mely rendezettséget ad a halmaz elemeinek. elemeinek.

A A ListList interfész egy rendezett interfész egy rendezett kollekciót tesz lehetővé tetszőleges kollekciót tesz lehetővé tetszőleges elemek számára, és megszabható elemek számára, és megszabható bármely elem pozíciója.bármely elem pozíciója.

A A QueueQueue interfész a FIFO interfész a FIFO adatszerkezetet valósítja megadatszerkezetet valósítja meg..

A második fa gyökere a Map interfész, A második fa gyökere a Map interfész, mely a hasítótáblához hasonlóan mely a hasítótáblához hasonlóan képezi le a kulcsokat és az értékeket. képezi le a kulcsokat és az értékeket. A Map alinterfésze a SortedMap, vagy A Map alinterfésze a SortedMap, vagy növekvő sorrendben tartalmazza az növekvő sorrendben tartalmazza az elemeit vagy a Comparator által elemeit vagy a Comparator által meghatározott sorrendben. meghatározott sorrendben.

Ezek az interfészek teszik lehetővé Ezek az interfészek teszik lehetővé azt, hogy a kollekciókat a azt, hogy a kollekciókat a reprezentációjuk pontos ismerete reprezentációjuk pontos ismerete nélkül is helyesen tudjuk kezelni.nélkül is helyesen tudjuk kezelni.

Általános célú implementációkÁltalános célú implementációk

Az általános célú implementációk mind Az általános célú implementációk mind biztosítják az összes opcionális műveletet, biztosítják az összes opcionális műveletet, amit az interfészek tartalmaznak.amit az interfészek tartalmaznak.

Általános szabály, hogy programíráskor az Általános szabály, hogy programíráskor az interfészeken, és nem az implementációkon interfészeken, és nem az implementációkon kell gondolkodni. kell gondolkodni.

Legtöbb esetben az implementáció Legtöbb esetben az implementáció megválasztása csak a teljesítményt megválasztása csak a teljesítményt befolyásolja.befolyásolja.

Az előnyben részesített programozói stílus az, Az előnyben részesített programozói stílus az, ha egy interfész típusú változóhoz választunk ha egy interfész típusú változóhoz választunk egy implementációt. egy implementációt.

Így a program nem függ majd egy adott Így a program nem függ majd egy adott implementáció esetén az ahhoz hozzáadott új implementáció esetén az ahhoz hozzáadott új metódusoktól, ezáltal a programozó bármikor metódusoktól, ezáltal a programozó bármikor szabadon változtathatja az implementációt, szabadon változtathatja az implementációt, mikor jobb teljesítményt szeretne elérni, vagy mikor jobb teljesítményt szeretne elérni, vagy a működési részleteket szeretné módosítani.a működési részleteket szeretné módosítani.

A Java Collections Framework A Java Collections Framework többfajta implementációját biztosítja többfajta implementációját biztosítja a mag interfészeknek: a mag interfészeknek: SetSet : : HashSetHashSet a leghasználtabb a leghasználtabb

List:List: ArrayList ArrayList a leghasználtabba leghasználtabb

Map:Map: HashMap HashMap a leghasználtabba leghasználtabb

Queue:Queue: LinkedList LinkedList a leghasználtabba leghasználtabb