Z2 JAVA

Forrás: JAVA 2 Útikalauz programozóknak 5.0

Z2/29 A Java programozási nyelv általános jellemzői. A statikus main függvény szerepe. A kiíró utasítás.

Változók, operátorok, típuskonverziók. Egyszerű típusok, adatok tárolása tömbökben. Tömbök

létrehozása, a tömbök használata. Többdimenziós tömbök. Tömbök rendezése.

A Java programozási nyelv általános jellemzői

Egyszerű

Objektumorientált

Elosztott

Robosztus

Biztonságos

Architektúra semleges

Hordozható

Interpretált

Nagy teljesítményű

Többszálú

Dinamikus

A statikus main függvény szerepe Amikor a JVM elindul, felkutatja azt az osztályt, amelyiknek a nevét megadtuk neki a parancssorba, majd egy

különleges alakú tagfüggvényt keres, a main tagfüggvényt. Ezt követően a JVM mindent lefuttat, ami a main

tagfüggvény kapcsos zárójelei között található. Minden Java-alkalmazásban lennie kell legalább egy osztálynak,

és legalább egy main tagfüggvénynek. public static void main (String[] args) {

}

public: nyolvános, tehát mindenki hozzáférhet

void: visszaadott érték típusa

main: tagfüggvény neve

static: az osztályhoz tartozik

String[] args: a tagfüggvény argumentumai. Ennek a tagfüggvénynek egy karakterláncokból álló tömböt

kell átadni, amelynek neve „args”

{ }: tagfüggvény nyitó és záró kapcsos zárójelei

A kiíró utasítás A konzolra kiiratni a System.out.print, printf es println utasitasokkal lehet, az első a parameterkent

kapott valtozot egyszerűen csak kiirja, a printf formazott sztringet ir ki, a formazast is meg kell adni

neki parameterkent, mig a println a parameterkent kapott valtozot es egy sortorest fog a konzolra

kiirni.

Változók A Java nyelv azonosítói betűvel kell, hogy kezdődjenek, és betűvel vagy számmal kell, hogy folytatódjanak. A

betűk közé itt az _ és a $ jel is beletartozik. pl.: abra, __abra$$A, EGY_SZÁM. Egy azonosító hossza tetszőleges

lehet. A nyelv kulcsszavai nem lehetnek azonosítók. A const és goto kulcsszavak nem használtak, de foglaltak.

Hasonlóan nem lehetnek azonosítók a nyelv alaptípusaihoz kapcsolódó literálok sem: null, true, false.

Operátorok A kifejezések kiértékelési sorrendjét alapvetően a benne szereplő operátorok határozzák meg. Egy kifejezésben

annak eldöntésére, hogy melyik operátor lesz először végrehajtva, három szabály alkalmazható:

először a legbelső zárójelen belüli kifejezés lesz kiértékelve

ha nincs zárójel, akkor először a nagyobb prioritású operátor lesz végrehajtva

ha több operátor prioritása is egyenlő, akkor balról jobbra, illetve néhány esetben jobbról balra lesznek

azok kiértékelve

A műveletek többsége balról jobbra értékelődik ki: a+b+c ugyanaz, mint (a+b)+c. Az értékadások viszont

jobbról balra értékelődnek ki: a=b=c ugyanaz, mint a=(b=c).

Postfix operátorok

[] tömb indexelése, pl.: array[12]

. minősített név, pl.: java.lang.System.out.println(„ ”);

(kif) zárójelezett kifejezés, pl.: (12+3) - 4


kif++ kif—postfix növelő, illetve csökkentő operátorok (a teljes kifejezés kiértékelése után változtatják

meg az adott változót), pl.: a++; b++;

Prefix operátorok

++kif, --kif prefix növelő, illetve csökkentő műveletek (a teljes kifejezés kiértékelése előtt változtatják

meg az adott változót), pl.: --a; --b;

+kif, -kif előjelváltás, pl.: -1

! logikai tagadó művelet, pl.: !true == false

~ bitszintű NEM művelet, pl.:

~0x00ff = 0xff00

Objektum létrehozása, típuskényszerítés

new objektum létrehozása, pl.: new NoSuchElementException()

(típus)kif típuskiűényszerítés, pl.: double d = (double)i;

Multiplikatív operátorok

*,/,% szorzás, osztás, illetve maradékos osztás maradéka

Additív operátorok

+, - összeadás és kivonás. Az összeadás operátor szövegekre is alkalmazható

Léptető műveletek

<< eltolás balra, a legkisebb bit helyére 0 kerül

>> eltolás jobbra, balról a legmagasabb helyiértékű bit értéke lép be

>>> eltolás jobbra, balról 0 kerül be

Összehasonlítások

<, >, <=, => skalár értékek összehasonlítása

instanceof megadja, hogy egy objektum egy adott osztály példánya-e Egyenlőségvizsgálatok

==, != értékek egyenlőségének és egyenlőtlenségének vizsgálata. Ez referenciák esetében magát a

referenciát hasonlítja, nem az objektumok tartalmát

Bitenkénti műveletek

& mohó kiértékelésű logikai ÉS

^ mohó kiértékelésű logikai kizáró VAGY

| mogó kiértékelésű logikai VAGY

&& lusta kiértékelésű logikai ÉS

|| lusta kiértékelésű logikai VAGY

Feltételes kifejezés

A ? : operátorral feltételes kifejezés készíthető kif1 ? kif2 : kif3 alakban

Értékadások

= egyszerű értékadás, +=, -=, *=. /=, %=, >>=, <<=, >>>=, &=, ^=, |= értékadás műveletek

Típuskonverziók A Java egy erősen típusos nyelv, ezért a kifejezésekben szinte minden esetben megvizsgálja, hogy összeegyeztethető típusok vannak-e benne, pontosabban azt, hogy az automatikus konverziókat végrehajtva

azonos típusra alakíthatók-e az elemek. Ha az ellenőrzés fordítási időben elvégezhető, akkor hiba esetén a

fordítás megszakad. Ha egy konverziós hiba csak futási időben deríthető ki, akkor hibaüzenetet a futtató rendszer

generál. Típuskonverzióra a nyelvben három módszer kínálkozik:

Automatikus konverzió: néhány konverzió a programozó külön óhaja nélkül is végrehajtásra kerül

értékadás esetén, vagy paraméterátadásnál metódusok hívásakor

Explicit konverzió: ha a programban konvertálni kell típusok között, és ezt automatikus konverzióval

nem lehet elérni, vagy az nem egyértelmű, akkor explicit módon is meg lehet ezt tenni

Szövegkonverzió: ha egy kifejezésben String típusra van szükség, de a kifejezésben lévő elem nem

ilyen, akkor azt a fordító megpróbálja automatikusan konvertálni

Egyszerű típusok A Java nyolc darab egyszerű típust, más néven primitív típust különböztet meg:

boolean – logikai típus

char – 16 bites Unicode karakter

byte – 8 bites előjeles egész szám

short – 16 bites előjeles egész szám int – 32 bites előjeles egész szám

long – 64 bites előjeles egész szám

float – 32 bites lebegőpontos racionális szám

double – 64 bites lebegőpontos racionális szám


Tömbök létrehozása, a tömbök használata Java nyelvben a [] jelöléssel lehet egy tömb típust megadni. A tömbelemek indexelése 0-val kezdődik.

A [] jel írható az alaptípus, de a változó neve után is:

int[] ia, ib; // ia és ib tömb definíciója

int ic[], id; // alternatív forma, de itt csak ic lesz tömb Az így létrehozott változó tetszőleges hosszúságú, egész számokból álló tömbre hivatkozhat. A tömb értéket a

new operátorral lehet létrehozni: ia = new int[20]; A tömb típusok tehát nem primitív típusok, a tömb típusú

változók objektumhivatkozást tartalmaznak.

A tömb ismeri saját méretét, amit meg is lehet tőle kérdezni a length mező használatával:

System.out.println(ia.length);

A tömb mérete ismeretében el tudja dönteni, hogy egy adott index érvényes-e. Ezt a futtató rendszer minden

tömbelem-hivatkozásakor ellenőrzi is. Amennyiben az index nem érvényes, egy IndexOutOfBouindsException

váltódik ki.

A tömb típusok sok tekintetben az osztályokra hasonlítanak – még az öröklődésben is részt vesznek. A

programozó ugyan nem tud egy tömb típust egy új osztály létrehozásakor őstípusként felhasználni, de a tömb

típusok között fennállhatnak bázistípus-altípus kapcsolatok.

Tömbliterál

Tömbök a következő formában inicializálhatóak:

String[] szinek = {„piros”, „fehér”, „zöld”};

Lehetőség van úgynevezett név nélküli tömbök létrehozására is a new operátor típusos formájában:

szinek = new String[]{„piros”, „fehér”, „zöld”};

Többdimenziós tömbök A Java nyelvben nincs többdimenziós tömb, de van más megoldás, mivel egy tömb akár tömbökből is állhat,

melynek hossza még különböző is lehet:

int[][] iaa = new int[3][]; // egy 3 elemű, tömbökből álló tömb létrehozása

for (int i=0; i<iaa.length; i++) {

iaa[i] = new int[i+1]; // i+1 elemű tömb létrehozása

for (int j=0; j<iaa[i].length; j++) iaa[i][j]=0; //tömbelemek inicializálása

}

Ez a kódrészlet egy háromszög-mátrix létrehozását és inicializálását végzi.

Tömbök rendezése int[] n = new int[]{-32,43,53,54,32,0,65,63,98,43,23};

boolean rendezett = false;

while (!rendezett){

rendezett = true;

for (int j=1; j<n.length; j++){ if (n[j-1]>n[j]){

int v = n[j-1];

n[j-1] = n[j];

n[j] = v;

rendezett = false;

}

}

}

System.out.println(Arrays.toString(n));


Z2/30 Vezérlési szerkezetek, szekvencia, feltételes elágazások, több ágú szelekció, ciklusok (iteráció),

foreach, számláló ciklus, elöltesztelő ciklus, hátul-tesztelő ciklus.

A szekvencia: az adott sorban levő utasítás végrehajtása után (amennyiben az utasítás mást nem eredményezett)

a következő sorba levő utasítás végrehajtása következik.

Elágazások Két vezérlési szerkezettel készíthetünk a Javában elágazást. Az egyszerű elágazáshoz az if-szerkezetet, az

összetett elágazáshoz pedig a switch-szerkezetet használjuk.

Egyszerű elágazás

Az egyszerű elágazás formája: if(logikai kifejezés) utasítás1 else utasítás2. Sajnos ez a szintaxis nem elég

egyértelmű, így a Java nyelvben is számítanunk kell a más nyelvekből ismert „if-then-else” ( avagy „csellengő

else”) problémára. Ha if-utasításokkal többágú elágazást készítünk, az alábbi tördelés javasolt:

if ( a < 0 ) {

b++;

} else if ( a == 0 ) { //…

b = 0;

} else {

b--;

}

Összetett elágazás Ha egy egész értékű kifejezéstől függően kell különböző programrészleteket végrehajtani, akkor használható a

switch elágazás:

switch ( egész kifejezés ) {

case címke1: // a címke egy egész értékű literál

utasítások;

break; // a címke1 ág vége

case címke2: // ennek a végrehajtása

case címke3: // ezen az ágon folytatódik

utasítások;

break; // címke2 és címke3 ágak vége

…

default: // alapértelmezett ág

utasítások;

}

Az elágazás fejrészében lévő „egész kifejezés” kiértékelését követően a case ágakban lévő címkeértékek lesznek

megvizsgálva. Ezek a címkeértékek fordítási időben ismert értékek kell, hogy legyenek. Ha valamelyik címkeérték megegyezik az „egész kifejezés” értékével, akkor az utána lévő utasításra adódik át a vezérlés. Az

utasítások a megfelelő címkétől kezdve egymás után kerülnek végrehajtásra a switch végéig, vagy az első break

utasításig. Ennek hatására a program elhagyja a switch blokkját. Egy újabb case címke tehát nem szakítja meg az

utasítások végrehajtásának menetét, a program végrehajtása az azt követő utasításon folytatódik. Ha nincs

megfelelő címke, akkor a default ág kerül végrehajtásra. A Java 5-ös verziójától kezdve a switch utasítás a

felsorolási típusokkal is működik:

enum Napok {HÉTFŐ, KEDD, SZERDA, CSÜTÖRTÖK, PÉNTEK, SZOMBAT, VASÁRNAP;}

int munkaÓrák;

switch(nap){

case HÉTFŐ:

case KEDD:

case CSÜTÖRTÖK: munkaÓrák = 9; break;

case SZERDA: munkaÓrák = 7; break;

case PÉNTEK: munkaÓrák = 6; break;

default: munkaÓrák = 0;

}

Ciklusok Ciklusszervező szerkezetből négyet ismer a Java nyelv: az elöltesztelő, a hátultesztelő, a léptető és a bejáró

ciklusokat.


Elöltesztelő ciklus

Formája: while (logikai kifejezés) utasítás.

Ez a ciklus a ciklusmag lefuttatása előtt kiértékeli a ciklus feltételét, amely egy logikai kifejezés. Ennek igaz

értékekor a ciklus folytatja futását. Ha a feltétel kezdetben hamis, akkor a ciklus magja egyszer sem kerül

végrehajtásra. Egy-egy sorban 1-től 9-ig a számok kiírása:

i = 1; while(i < 10) System.out.println(i++);

Hátultesztelő ciklus

Formája: do utasítás while (logikai kifejezés)

Ez a while-ciklushoz hasonló, de a ciklusmag lefutása után vizsgálja meg a feltétel értékét. Ha a feltétel igaz,

akkor újra kezdi a ciklusmagot. Ha a feltétel kezdetben hamis, akkor is lefut egyszer a ciklusmag.

i = 1; do System.out.println(i++); while(i < 10);

Léptető ciklus

Formája: for (kezdet; logikai kifejezés; továbblépés) utasítás

A for-ciklussal nagyon egyszerűen írhatók számlálót léptető ciklusok – leggyakrabban éppen erre használjuk ezt

a szerkezetet. Egy tömb elemeinek feldolgozása:

int[] tömb = …

int összeg = 0;

for (int i = 0; i<tömb.length; i++) összeg += tömb[i];

A for ciklus fejében deklarált azonosítók csak a ciklus törzsében lesznek érvényesek. A fenti példánál a ciklus

után már nem használható az i változó, mert ott már nem látható. Általában biztonságosabb a ciklusváltozót a ciklus fejében definiálni, és ezáltal a ciklusra lokálissá tenni.

Bejáró ciklus (Javaban nincs foreach! Továbbfejlesztett for (enhanced for) néven fut a másik for ciklus!)

Formája: for (típus változó: gyűjtemény) utasítás

Ezzel a ciklussal egy adatszerkezet bejárását, elemeinek sorravételét végezhetjük. Az adatszerkezet lehet egy

tömb, de akár egy gyűjtemény-keretrendszerbeli sorozat vagy halmaz is. Egészekből álló tömb elemeinek

összegzése:

int[] tömb = …

int összeg = 0;

for (int n: tömb) összeg += n;

Feltétlen vezérlésátadás Címkék

Bármely utasítás elé írható címke, mely az utasítás egyértelmű azonosítását teszi lehetővé feltétlen

vezérlésátadások pontos meghatározása érdekében. Formája: címke: utasítás

A break utasítás A break utasítás egy blokkból való kilépésre szolgál: break [címke];

Ha nem áll mellette címke, akkor a legbelső blokkból lép ki. Ha egy blokk címkéje áll mellette, akkor a

megjelölt blokkból lép ki:

int i = 1;

ciklus: while (i<1000) {

for (int j=1; j<=1; j++) {

if (logikai_fv(i, j)) break ciklus;

…

}

}

A break utasítással nem lehet metódusból vagy inicializáló blokkból kiugrani.

A continue utasítás

Egy ciklus magjának hátralévő részét át lehet ugrani a continue utasítással. Ennek alakja: continue [címke];

Az utasítás hatására a ciklusmag hátralévő része nem kerül végrehajtásra, és a program futása a ciklus

feltételének kiértékelésével folytatódik.

while (! bemenet.eof() ) { // amíg a bemeneten még van valami sor = bemenet.redln(); // egy sor olvasása a bemenetről

if (ures(sor)) continue; // nyomtat(sor) kimarad

nyomtat(sor); // egy sor nyomtatása


}

Visszatérés

Egy metódusból a return [kifejezés] utasítással lehet visszatérni. Az adott metódus visszatérési értéke a return

után írt kifejezés értéke lesz:

int abszolut(int szám) { if (szám < 0) return –szám;

else return szám;

}


Z2/31 Osztályok felépítése, tagváltozók, metódusok, konstruktorok, egységbezárás, UML jelölései

Osztályok felépítése Az osztály definíciója fejből és törzsből áll. A fejet a class kulcsszó vezeti be, amelyet az osztály neve követ. Az

osztály nevét hagyományosan nagybetűvel kezdjük, összetett szó esetén a szóösszetevők is nagybetűvel

kezdődnek. Célszerű főnevet vagy főnévi kifejezést választani. A class kulcsszó előtt szerepelhetnek módosítók: olyan szintaktikus elemek, melyek a velük ellátott definícióban bevezetett egységet valamilyen jellemzővel

ruházzák fel. Egy definíciót több, egymástól szóközzel elválasztott módosító is megelőzhet. A megengedett

módosítók halmaza és jelentése a definíció fajtájától függ, osztályokhoz a public, abstract és final módosítókat

használhatjuk. A public módosító azt jelenti, hogy az adott osztály hozzáférhető más csomagokból is. Adott

esetben az osztály fejében kell megadni azt is, hogy az osztályt mely osztály kiterjesztéseként definiáljuk, illetve

azt, hogy az osztály mely interfészeket valósítja meg.

Az osztály törzse az osztály tagjait, vagyis változóit és metódusait tartalmazza kapcsos zárójelek között. A

változók és metódusok szerepelhetnek akár felváltva is. A változókat kisbetűvel kezdődő főnévvel, a

metódusokat kisbetűvel kezdődő igével szokták azonosítani. Egy adott tulajdonság fennállását vizsgáló, logikai

értéket visszaadó metódust a megfelelő melléknévről célszerű elneveznünk. Törzsben szerepelhetnek még

konstruktorok, inicializáló blokkok és tagosztályok is.

public class ClassName {

String nev; int fizetes;

void fizetestEmel(int novekmeny) {

fizetes += novekmeny;

}

}

Példányváltozók Az osztály változóit változódeklarációk adják meg. Egy változódeklaráció egy vagy több azonos típusű változót

vezet be. A deklaráció a változók típusának nevével kezdődik, amely mögött vesszővel elválasztva a változók

nevei állnak, és egy pontosvesszővel zárul: int fizetes, potlekok, levonasok;

Lehetséges a változókhoz egyenként kezdőértéket rendelni. A kezdőértéket egy kifejezéssel, az inicializátorral

adjuk meg. Az inicializátor nélkül deklarált változó kezdőértéke az implicit kezdőérték lesz. Az implicit

kezdőérték a változó típusától függően nulla, ’\u0000’, false vagy null lesz.

int fizetes = 30000, potlekok, levonasok = fizetes/4;

A final módosítóval ellátott változó értéke nem változtatható meg értékadással, használatával konstansok

deklarálhatók. A konstansok nevét nagybetűvel írják, hogy ránézésre is meglehessen különböztetni őket a

változóktól. Egy konstans kezdőértékének beállítására három lehetőség van:

a konstans deklarációjában inicializátort adunk meg

a konstans deklarációjában nem adunk meg inicializátort de:

o minden konstruktor értéket kell, hogy adjon neki o vagy inicializáló blokkon belül állítjuk be

Egy adott osztály metódusaiban egyszerűen a nevükkel hivatkozhatunk az osztály változóira. Az ilyen

hivatkozás mindig az aktuális példány változóira vonatkozik. A változó neve előtt egy ponttal elválasztva

megadhatjuk, hogy más objektum változójára hivatkozunk. Az ilyen hivatkozást minősített hivatkozásnak

nevezzük. Ennek segítségével tudjuk az adott osztály más példányainak vagy más osztályok példányainak

változóit elérni. A minősítés lehet többszörös is: dolgozo.fonok.fizetes

Metódusok Egy osztály metódusait metódusdefiníciók írják le. Egy metódusdefiníció két részből, fejből és törzsből áll. A fej

rendre megadja a metódus visszatérési típusát, az azonosítóját, és zárójelek között, egymástól vesszővel

elválasztva a formális paramétereit. Az azonosítót és a paraméterek típusának sorrend szerinti listáját együttesen

a metódus szignatúrájának hívjuk. Szükség esetén a fejben kell feltüntetni a törzsben kiváltott ellenőrzött

kivételeket is. A metódusdefiníció feje előtt megengedett módosítók a public, protected, private, az abstract, a

static, s synchronized és a native.

A metódus törzse a működést definiáló utasításblokkot tartalmazza. Ha a metódus abstract vagy native, a törzset

egy pontosvessző helyettesíti. A metódus törzsét nem választhatjuk el e fejétől. boolean kozepesJovedelmu(int minimum, int maximum) {

return minimum <= fizetes && fizetes <= maximum;


A formális paraméterek olyan lokális változók, amelyek a metódus futásának ideje alatt léteznek. Kezdőértékük

a metódushívásban szereplő, nekik megfelelő aktuális paraméter. A paraméterek nevének különböznie kell

nemcsak egymástól, hanem a törzsben szereplő lokális változók nevétől is. A formális paraméterekre

alkalmazhatjuk a final módosítót, hogy ne lehessen értéküket megváltoztatni. A formális araméterek listájában

minden paraméternek külön meg kell adni a típusát. A paraméter nélküli metódusok paraméterlistája csak a

zárójelekből áll. void fizetesDuplaz() {

fizetes * = 2;

}

A void visszatérési típus azt jelzi, hogy a metódus nem ad vissza értéket. A metódus futása a törzs utolsó

utasításának végrehajtásával fejeződik be, hacsak paraméter nélküli return utasítással más ponton ki nem lépünk

belőle, vagy egy kivételt nem kezelünk le. Az értéket visszaadó metódus törzsét ezzel szemben úgy kell

kialakítanunk, hogy abból mindenképpen a visszatérési értéket megadó paraméteres return utasítással térjünk

vissza, különben fordítási hibát kapunk.

A metódus hívásban meg kell adnunk a metódus definíciójában előírt számú és típusú paramétert. Kizárólag egy

konkrét példányra vonatkozóan hívhatjuk meg. A metódushívásnak egy objektumra kell vonatkoznia. A

példányváltozók nevéhez hasonlóan a metódusok nevét is minősítéssel vagy anélkül használjuk. Minősített

metódusnévvel a minősítésben szereplő objektumra hívjuk meg a metódust.

Alkalmazott a;

a.fizetesDuplaz();

Egy osztály több metódusát is elnevezhetjük ugyanúgy, ha szignatúrájuk különböző, vagyis formális paramétereik száma és/vagy típusa nem egyezik meg. Egy metódust ugyanis a szignatúrája azonosítja. A

metódusnév többszörös használatát túlterhelésnek nevezzük. Túlterhelt név használatánál az aktuális

paraméterek száma és típusa szerint választja ki a Java fordító, hogy melyik metódust kell meghívni.

public class Alkalmazott {

void fizetesEmel(int novekmeny) {

fizetes += novekmeny;

}

void fizetesEmel() {

fizetes += 5000;

}

void fizetesEmel(Alkalmazott masik) {

if (kevesebbetKeresMint(masik)) fizetes = masik.fizetes.;

}

…

Alkalmazott a = new Alkalmazott(), b = new Alkalmazott();

a.fizetesEmel(5000); a.fizetesEmel(); a. fizetesEmel(b);

Konstruktorok A konstruktor olyan programkód, amelynek végrehajtása a példányosításkor automatikusan megtörténik. A

konstruktorok nagyon hasonlítanak a metódusokra, de mégsem tekintjük őket tagoknak(mert nem

öröklődhetnek). Nevüknek meg kell egyeznie az osztály nevével. Paramétereket fogadhatnak, sőt egy osztálynak

több, különböző szignatúrájú konstruktora is lehet. Közvetlenül nem hívhatók meg, csak példányosításon

keresztül. Mivel ilyen esetben a visszatérési értéket a példányosító operátor adja, a konstruktoroknak visszatérési

típusa nincsen, még csak nem is void.

Egy konstruktordefiníció majdnem pontosan olyan mint egy metódusdefiníció. A különbség mindössze annyi,

hogy az azonosító között, nem szabad semmilyen visszatérési típust feltüntetni, és cak a hozzáférési kategóriát

meghatározó módosítók alkalmazhatók.

public Alkalmazott(String nev, int fizetes) {

this.nev = nev;

this.fizetes = fizetes;

this.evesFizetes = 12*fizetes;

}

public Alkalmazott(String nev) {

this(nev, 40000); }

Az első konstruktor számára az alkalmazott neve és fizetése is paraméterként adható meg, a második a fizetést

önkényesen állapítja meg.


A formális paramétereknek lehet ugyanazt az azonosítót adni, mivel a formális paraméterek elfedik az osztály

változóit, a this minősítéssel érhetjük el csak azokat. A konstruktor első utasításaként lehetőségünk van

ugyanazon osztály egy másik konstruktorát meghívnunk. A hívásban a this kulcsszót kell használni. Túlterhelt

metódusok hívásához hasonlóan, itt is az aktuális paraméterek típusa határozza meg a meghívandó konstruktort.

Egy osztálynak mindig van konstruktora. Ha egy programozó ír konstruktorokat, akkor azok lesznek az osztály

konstruktorai, ha nem, akkor a fordító automatikusan biztosít egy implicit konstruktort, amely public, paraméter nélküli, és törzse üres. A konstruktor hozzáférési kategóriája azt határozza meg, hogy mely osztályok jogosultak

az adott konstruktoron keresztül példányosítani.

Egységbezárás Az adatstruktúrákat és az azokat kezelő metódusokat egy egységként kezeljük és elzárjuk őket a külvilág elől.

Az így kapott egységeket objektumoknak nevezzük.

UML jelölései Az osztály jele egy általában három részre osztott téglalap, ahol a felső sávba az osztály nevét, a középsőbe az

osztály attribútumait, az alsóba pedig az osztály műveleteit írjuk.

jelölések……..Szoftech. Z1/12. tétel


Z2/32 Az objektumközpontú programozás működése. Mik az objektumok, mi a példány? Az objektum

diagramok UML jelölései.

Az objektumorientált programozás egy programozási módszertan. Ellentétben a korábbi programozási

módszertanokkal, nem a műveletek megalkotása áll a középpontban, hanem az egymással kapcsolatban álló

programegységek hierarchiájának megtervezése. Az objektumorientált gondolkodásmód lényegében a valós világ lemodellezésén alapul – például egy hétköznapi fogalom, a „kutya” felfogható egy osztály (a kutyák

osztálya) tagjaként, annak egyik objektumaként. Minden kutya objektum rendelkezik a kutyákra jellemző

tulajdonságokkal (például szőrszín, méret stb.) és cselekvési képességekkel (például futás, ugatás). Az

objektumorientált programozásban fontos szerep jut az úgynevezett öröklődésnek, ami az osztályok egymásból

való származtatását teszi lehetővé: a kutyák osztálya származhat az állatok osztályából, így megörökli az állatok

tulajdonságait és képességeit, valamint kibővítheti vagy felülírhatja azokat a kutyák tulajdonságaival,

képességeivel.

Mik az objektumok Minden objektum, egy előre definiált osztály példánya. Egy osztályban általában egy feladat elvégzéséhez

szükséges kódrészleteket gyűjtik össze funkciójuk szerint, tagfüggvényekbe rendezve. Egy osztályt létrehozása

után példányosítani kell, hogy használhatóvá váljanak a benne összegyűjtött rutinok. Az osztály példányát

nevezzük objektumnak.

Az objektum részei

• adatelemek,

• szerkezeti összefüggések, • szelekciós műveletek,

• konstrukciós műveletek.

Objektumok 4 fő tulajdonsága:

• Az adat és kód egysége

• Öröklődés

• Polimorfizmus

• Zártság

Adat és kód kombinációja

Egy objektum adatból és kódból épül fel. A kód az objektum függvénye, melyet metódusnak hívunk. Az adatot,

melyeket változókkal írunk le, az objektum egyedváltozóinak, vagy attribútumainak nevezzük

Öröklés

Egy új osztály létrehozásakor annak alapja egy másik osztály. Az új osztályban a szülő osztály metódusai és

egyedváltozói is használhatóak, az új osztály saját egyedváltozókat és metódusokat is tartalmazhat. Fontos

kiemelni, hogy minden objektumnak van szülője a Javaban (Object class)

Polimorfizmus

Egy osztály leszármazottjában a metódust újra lehet definiálni. (AZ EGYEDVÁLTOZÓT NEM!!!) Hasonló

osztályok, hasonló tulajdonságát, ugyan olyan nevű metódussal kezelhetjük.

A metódusok ugyan arra névre hallgatnak, de az objektumoknak megfelelő adatokat szolgáltatnak.

Zártság

Az objektumok egyedváltozóinak manipulálása a programban, kizárólag az objektum metódusain keresztül

lehetséges. Az objektum metódusai tartják a kapcsolatot a külvilág és az objektum között.

Példány Adott osztálytípussal több objektum példányt is létrehozhatunk. A példányok saját adatterülettel rendelkeznek,

de a metódusokat közösen használják. Az aktuális példányra a this pszeudováltozóval hivatkozhatunk.

Az objektum diagramok UML jelölései

Szoftech. Z1/12. tétel

http://hu.wikipedia.org/wiki/Programoz%C3%A1s


Z2/34 Az applet grafikus felülete – java.awt csomag -, Swing, a HTML nyelv alapjai, applet beágyazása

HTML oldalba, az applet életciklusa

Az applet grafikus felülete Mivel az Applet a java.awt.Panel közvetlen leszármazottja, így a grafikus megjelenítésének megvalósítása ezen

felső konténerből kiindulva kell, hogy történjen. Mivel maga az Applet teljesértékű grafikus Component is egyben, így akár mi magunk is kézbe vehetjük a megjelenítés megvalósítását a paint, illetve update

metódusainak megfelelő felüldefiniálásával. Mivel az appletek megjelenítése egy HTML oldalba beágyazva

történik, ezért grafikus megjelenítésükre a következő megszorítások vonatkoznak:

A böngészőprogram az appletbeágyazás feldolgozásakor a létrehozott appletpéldányt egyből a megadott

width és height paramétereknek megfelelően méretezi. Ezen méretek megváltoztatását a

böngészőprogram figyelmen kívül hagyhatja.

Az applet megjelenítési területének HTML oldalon belüli koordinátáit nem lehet megtudni.

Pontosabban minden applet a szülő konténer(ei)hez képest a (0, 0) koordinátán látja önmagát, vagyis

mindig csak a számára lefoglalt ablakterület koordinátarendszerét használja.

Biztonsági megfontolások miatt nem javasolt önálló ablak nyitása. Ha egy applet mégis egy saját

ablakot jelenít meg, akkor azt a böngészőprogramok mindig figyelmeztető felirattal látják el, nehogy

HTML tartalom részének lehessen tekinteni.

Egy applet magától nem veszi figyelembe az őt tartalmazó HTML oldal színeit, sem a HTML oldal

hátterének beállított képet. Ugyanakkor a színbeállítás vagy háttérkép saját megjelenítési kóddal

egyszerűen megvalósítható.

AWT Abstract Window Toolkit – Absztrakt Ablakozó Eszköztár. Grafikus felhasználói felületek készítéséhez

szükséges alap API, amelyet a java.awt csomaghierarchia tartalmaz. Nevében az absztrakt jelző arra utal, hogy a

felületelemek megjelenítéséért nem a Java platform, hanem az azt futtató operációs rendszer grafikus ablakozó

rendszere felelős. Ennek hátránya, hogy emiatt a felhasználható grafikus komponensek halmaza a jelenlegi

összes ablakozó rendszer által támogatott komponensek elég szűk közös metszetére korlátozódik, és hogy a

komponensek tényleges kinézete az operációs rendszertől függ, ami a Java platformfüggetlenségi elvének mond

ellent. Előnye viszont, hogy a Java felhasználói felületek könnyen integrálódnak a megszokott ablakozó-rendszer

által megvalósított stílusú munkafelületbe, valamint biztosítja a különböző ablakok tartalma közötti áthúzással

történő adatátvitel lehetőségét.

Swing Az AWT megszorításainak kiküszöbölésére létrehozott igen fejlett grafikus programkönyvtár. Elnevezését a JFC

grafikus komponenseit fejlesztő projekt kódnevéről kapta. A Swing komponensek az AWT alapjaira épülnek, de

színtiszta Javában íródtak és önmaguk gondoskodnak a saját megjelenítésükről, ezáltal függetlenek a grafikus

felületet biztosító operációs (és ablakozó) rendszertől. Ezen különbség hatására lehetővé vált az AWT

szolgáltatásait meghaladó komplex grafikus felhasználói elemek megvalósítása, valamint igen könnyen

elvégezhető a már meglévő komponensek tetszőleges kombinálása és akár módosítása is. A Swing típusokat a javax.swing csomagok tartalmazzák.

HTML nyelv alapjai A WWW alapnyelve a HTML nyelv (Hypertext Markup Language - hiperszöveges jelölő nyelv)

WWW=World Wide Web= világháló

Egyszerű jelölőnyelv, amellyel platformfüggetlen hiperszöveges dokumentumokat lehet készíteni. A HTML

tehát egy olyan jelölő nyelv, amely leírja (leírókódnyelvnek is nevezik), miként kell a fájlt (dokumentumot)

megformázni. Tulajdonképpen egy ASCII-szövegfájl beágyazott jelölőkódokkal.

A hiperszöveg (hypertext) elnevezés arra utal, hogy egy szöveg egyes elemeihez (pl. szavakhoz) további

szöveget lehet rendelni. Egy ilyen szöveget olvasva tehát egyes szavak, mondatrészek stb. kiemelve jelennek

meg, amelyeket kiválasztva a hozzájuk kapcsolt további szöveg megjelenik. Ebben a szövegben is el lehet

helyezni ilyen kapcsolatokat (hiperhivatkozások, linkek), amelyek további tetszőleges szövegre mutathatnak, így

szinte pókhálószerű információhálót lehet létrehozni. Természetesen a HTML fájlokban nem csak szöveghez

rendelhetünk hivatkozásokat, hanem pl. képekhez is. Fájl helyett a továbbiakban általánosan használjuk

az objektum elnevezést. Amikor hiperhivatkozást hozunk létre alapvetően három kérdésre kell válaszolnunk.

1. Mi az elérendő HTML fájl (objektum) neve?

2. Hol helyezkedik el? o webkiszolgáló neve

o elérési út a kiszolgálón belül

3. Hogyan lehet elérni azt?


A fenti három kérdésre az URL ismerete adja meg a választ

Az applet beágyazása HTML oldalba Applet HTML oldalba való beágyazására a 4.0-s HTML változatától kezdve az <applet> kulcsszó helyett az

<object> használandó a következő attribútumokkal:

codebase=url: az applet alapértelmezett könyvtára. Alapértelmezett értéke a beágyazó HTML oldal elérési útvonala, relatív formája is ehhez viszonyítva értendő.

archive=lista: az applet kódját és erőforrásait tartalmazó – szóközzel elválasztott- archívumlista.

Relatívan megadott archívumhivatkozások csak a codebase alá (tehát nem léphetnek onnan ki..

/használatával) mutathatnak, míg teljes http://URL csak a codebase-zel azonos hosztra hivatkozhat.

classid=osztálynév: a végrehajtandó applet osztályneve java:osztálynév formában. Amennyiben az

applet futtatókörnyezetének (JRE) szükséges verziószámát is elő akarjuk írni, akkor azt szintén ezen

attribútum következő értékével tehetjük meg: „clsid:CAFEEFAC-xxxx-yyyy-zzzz-

ABCDEFFEDCBA”, ahol az xxxx, yyyy és zzzz a fő+al-, mikro- és frissítési verziószámot jelenti.

Amennyiben a classid attribútum egy JRE-re mutat, akkor az applet végrehajtandó kódjának megadása

a code nevű indítási paraméter értékeként történik.

codetype=”application/x-java-applet”, „application/java” vagy „application/java-archive”: appletet jelző

MIME típuskódok.

data=fájlnév: a futtatandó szerializált appletpéldányt jelöli ki.

standby=szöveg: ez a szöveg látszik, míg az applet futtatása el nem kezdődik.

name vagy id=azonosító: a HTML oldalon belüli egyedi azonosítót rendel az applethez, melynek

segítségével ugyanazon oldalba ágyazott appletek elérhetik egymást.

width=szám: az applet grafikus felületének szélessége képpontban (kötelező).

height=szám: az applet grafikus felületének magassága képpontban (kötelező)

align=konstans: az applet grafikus felületének igazítását lehet vele szabályozni.

vspace: az applet felett és alatt üresen hagyandó képpontsorok száma.

hspace: az applet mellet üresen hagyandó képpontoszlopok száma.

Egy <object> HTML blokk felépítése:

<object …>

<param name=azonosító value=érték>

…

HTML sorok

</object>

A <param> HTML kulcsszó segítségével lehet indítási paramétereket átadni az applet számára. A <object>

blokk végén található HTML sorok csak akkor kerülnek értelmezésre és megjelenítésre, amennyiben a

megjelenítést végző böngészőprogram nem képes (pl.: túl elavult) az applet végrehajtására. Ennek

kihasználásával akár több <object> blokkot is egymásba ágyazva egy adott applet különböző verzióit is

előírhatjuk.

Az applet életciklusa Az applet futtatását végző külön programszál a konstruktor lefutása után, négy publikus metóduson keresztül

vezérli az applet végrehajtását.

init: az applet inicializálását végzi. Normál esetben a konstruktor után egyből meghívódik, kivéve, ha az

appletbeágyazás egy szerializált objektum megadásával történt, ekkor ugyanis ez a metódus nem kerül

végrehajtásra. Épp ezért itt érdemes az applet indítási paramétereit átvenni. Csak ezen metódus

végrehajtása után hívódnak meg először az applet grafikus megjelenítési metódusai.

start: az applet el-(vagy újra)indításkor kerül végrehajtásra. Közvetlenül a meghívása előtt az applet

aktív állapotba kerül. A kezdeti indításkor az init metódus után, majd mindig akkor hívódik meg,

amikor az appletet újra kell indítani. Ez akkor következik be, ha például a böngészőben visszatérünk az

appletet tartalmazó HTML laphoz, vagy ha a böngészőprogram visszakerül eredeti méretébe ikonizált

állapot után, vagy egyszerűen csak az applet (a HTML oldal görgetésével) láthatóvá válik. Itt érdemes

az applet saját programszálait el-/újraindítani. Az applet indítási kép egészen ezen metódus első

meghívásának befejeződéséig fog látszani!

stop: az applet megállításakor kerül végrehajtásra. Közvetlenül a meghívása előtt az applet inaktív

állapotba megy át. Mindig akkor hívódik meg, ha az appletnek nem kell tovább futnia. Ez akkor következik be, ha például a böngészőben elhagyjuk az appletet tartalmazó weblapot, vagy ha a

böngészőt ikonizáljuk, vagy egyszerűen csak az applet (görgetés miatt)már nem látható. Itt érdemes az

applet saját programszálait leállítani.

http://url/


destroy: az applet megszüntetésekor, még a finalize előtt kerül végrehajtásra. Itt kell az applet által még

lefoglalt erőforrásokat felszabadítani, például a kommunikációs vagy I/O végpontokat lezárni.

Ezen metódusok Applet-beli implementációi üresek, ezért nem kötelező ezek felüldefiniálásakor a felülírt ős-

metódust is meghívni. Az applet állapotának aktív mivoltát az isActive metódusával lehet lekérdezni.

Megjegyzendő továbbá, hogy az életciklus metódusok végrehajtásának kiváltása erősen függ a ténylegesen

felhasznált futtatókörnyezet megvalósítástól, tehát például különböző bön.gészőprogramok akár egymástól eltérő alkalmakkor is kérhetik az applet leállítását és újraindítását.


Z2/35 Java kisalkalmazások (applet) készítése és futtatása, appletek biztonsága. Az applet-ek előnyei és

hátrányai.

Java kisalkalmazások (applet) készítése Minden applet az Applet osztály leszármazottja kell, hogy legyen, az appletspecifikus alaptípusokat pedig a java.applet csomag tartalmazza. Alapértelmezett osztálybetöltőjük a sun.applet.AppletClassLosader a keresési

útvonal mentén, a gyorsítótárazás figyelembe vételével intézi a kódbetöltést. Mivel a java.net.URLClassLoader

leszármazottja, így biztosítja szükség esetén a hálózaton keresztül történő letöltést. Digitálisan aláírt archívumok

kezelését specializációja, a sun.plugin.security.PluginClassLoader végzi.

Mivel az appletek példányosítása automatikusan, a beágyazó HTML oldalt megjelenítő böngészőben futó

virtuális gépen történik, ezért minden applet osztálynak publikusnak kell lennie, valamint rendelkeznie kell

publikus paraméter nélküli konstruktorral!

Futtatása Minden egyes applet futtatása külön programszálban, egyes megvalósítások esetén pedig még külön

programszálcsoportban történik. A felhasznált böngészőprogram a tartalmazó HTML dokumentum

megjelenítésekor az applet beágyazásának helyén kihagy az indítási paramétereknek megfelelő méretű

téglalapot, majd a megadott osztálynév vagy szerializált forma alapján példányosítja és elindítja az appletet.

Mivel ennek elvégzése elég sokáig is eltarthat, ezen idő alatt az applet helyén az úgynevezett indítási kép jelenik

meg.

Alapértelmezett esetben az applet területének közepén fehér körlapon a Java logó látszik, melyet sugárirányú,

aktivitást jelző animáció jár körbe, alatta pedig egy állapotjelző csík mutatja a letöltés előrehaladottságát, a böngésző státuszsorában pedig a Loading Java Applet … szöveg jelenik meg.

Amennyiben az applet betöltésekor hiba lépne fel, a kijelölt területén vagy a böngésző státuszsorában megjelenik

a hibaüzenet, a bal felső sarokban pedig egy figyelmeztető ikon lesz látható. Ekkor jobb egérrel az appletre

kattintva egy felbukkanó menü hívható elő, amely lehetővé teszi a Java konzol indítását, illetve információ

megjelenítését az alkalmazott Java futtatókörnyezetről.

Beágyazó környezet

Az applet sikeres betöltése és példányosítása után a futtató környezet létrehoz és a setSub metódussal beállít egy

AppletStub interfészt megvalósító hozzárendelt objektumot, melyen keresztül az adott applet a böngészővel

tartja a kapcsolatot. A beágyazási környezetet, azaz magát az appletet megjelenítő programot egy AppletContext

interfészt megvalósító objektum reprezentálja, melynek elérése a getAppletContext metódussal lehetséges.

Ha egy appletet nem egy böngészőprogram példányosít automatikusan, akkor ezen objektumok sem jönnek létre,

így a böngészőspecifikus lehetőségek nem állnak az ilyen appletek rendelkezésére. Ugyanez a helyzet az applet

konstruktorának végrehajtásakor is, ugyanis ekkor még nem történt meg a beágyazó objektum beállítása.

Appletek biztonsága Az appletekre vonatkozó biztonsági megkötések betartását egy java.lang.SecurityManager osztály appletek által le nem cserélhető példánya ellenőrzi az applet futása alatt, így megkötések minden böngészőprogramban mások.

Alkalmazás esetén nem kerül beállításra alapértelmezett SecurityManager.

Az aktuális SecurityManager példányt a java.lang.System osztály tartalmazza. Minden kényesebb Java metódus

végrehajtása előtt a futtatórendszer ellenőrzi, hogy az adott műveletet engedélyezi-e az aktuális

SecurityManager. Az ellenőrzés rendszerint így történik:

SeyurityManager security = System.getSecurityManager();

if(security!=null) security.checkXXX(argumentum, …);

Ha a program nem megengedett műveletet akar végrehajtani, akkor a SecurityManager egy

java.lang.SecurityException kivételt vált ki. Ha a művelet engedélyezett, akkor a megfelelő ellenőrzőmetódus

nem csinál semmit. Az alábbi felsorolás a jelenlegi böngészők által megvalósított megszorításokat illusztrálja.

Az appletek

nem használthatnak native metódusokat

nem tölthetnek be programkönyvtárakat (Runtime.loadLibray)

a futtató gépen nem engedélyezett semmilyen fájlművelet számukra, erőforrásfájlokat is csak a saját

codebase vagy documentbase könyvtáruk alatt érhetnek el

csak az applet kódját tartalmazó géppel hozhatnak létre hálózati kapcsolatot

a végrehajtó számítógépen nem engedélyezett semmilyen program futtatása számukra (Runtime.exec)

nem látják az összes rendszerparamétert, a java.lang.System getProperty metódusával általában csak a

következőket tudják olvasni: os.arch, os.name, os.version, browser, browser.vendor, browser.version,


file.separator, line.separator, path,separator, java.class.verison, java.vendor, java.vendor.url,

java.version

Ezen megkötések alapján az appletek használata elvileg teljesen biztonságosnak tekinthető, hiszen azok

mindentől elszigetelve, saját kis végrehajtási környezetükben futnak.

Azonban mindez a megszorítások helye implementálásától függ. Tehát akkor mondhatjuk a biztonsági

megkötések implementálását helyesnek, ha a felhasználó tudta nélkül egy applet nem tehet semmi olyat, amiből bárkinek esetleg kára származhat.

Az applet-ek előnyei és hátrányai. • Előnyök:

Az appletek különböző platformokon „futhatnak”- Windows, Linux, Mac OS.

Az appletek a Java Plugin tetszőleges verziójával működnek.

Appletek futtatása biztonságos

Legtöbb web böngésző támogatja

A böngésző cache-li az appleteket: az oldal újboli megtekintésekor gyorsabb a betöltés.

• Hátrányok:

Java Plugin szükséges az appletek futtatásához.

Az első akalomkor a JVM (Java Virtual Machine) „hosszadalmas” betöltése.

Ha az applet nincs cache-lve, akkor annak letöltése a netről időt igényel.

Nehéz a jó felhasználói interfész kialakítása

Documents

Z2 JAVA