Unknown user: Új oldal, tartalma: „{{GlobalTemplate|Valaszthato|JavaTechElmelet}} Minden feladat 30 pontot ér. A feladatok a tárgy weblapjáról származnak, a rövid jegyzetek pedig a kiadott diák …”

2012-10-22T11:41:16Z

Új oldal, tartalma: „{{GlobalTemplate|Valaszthato|JavaTechElmelet}} Minden feladat 30 pontot ér. A feladatok a tárgy weblapjáról származnak, a rövid jegyzetek pedig a kiadott diák …”

Új lap

{{GlobalTemplate|Valaszthato|JavaTechElmelet}}

Minden feladat 30 pontot ér. A feladatok a tárgy weblapjáról származnak, a rövid jegyzetek pedig a kiadott diák alapján készültek, készülnek. A címsorban a kérdések vizsgákon való előfordulásának dátuma szerepel (ééhhnn).

__TOC__

==Collections Framework, (060614)==

'''Mutasd be a java Collections Framework-öt! Ismertesd az adatmodelleket (1.4), nevezz meg néhány implementációt, és a köztük levő különbséget. Miben változott az 1.5 java CF-je az 1.4-hez képest? Mutasd be az elvet, ahogy egy gyűjtemény elemeihez hozzáférünk. Mik az elvárások a CF-ben tárolt objektumokkal szemben? Hogyan lehet egy gyűjteményt rendezni?'''

===!! 3 adatmodell (6 pont)===
===!! implementációk (4 pont)===
===!! 1.5 újdonság (5 pont)===
==!!Generikusok==
List words = new ArrayList();
helyett:
List<String> words = new ArrayList<String>();
==!!Autoboxing-unboxing==
collection-ök osztályokat tárolnak, primitív típusokat nem, tehát int helyet Integert, de a konverziót (wrapperbe csomagolás, kicsomagolás) a fordító végzi

Map<String, Integer> m =� new TreeMap<String, Integer>();�

for (String word : args) {�

m.put(word, m.get(word) + 1);�

}

==!!Új for ciklus==
iterátor használata egyszerűbb, de így nem lehet törölni iterátorral, ha az is kell, azt kell használni

for (String word : args) { }

új "typesafe" enumot is kapott az 1.5

-- [[Main.mp9k1]] - 2012.06.11.
===!! iterator (5 pont)===

A =Collection iterator()= metóduásval kérhetünk egy iterátort, amellyel be tudjuk járni a gyűjteményt. Van =Iterator= és =ListIterator=.

* =Iterator= metódusai: =hasNext=, =next=
* =Iterator= opcionális metódusai: =remove=
* =ListIterator= további metódusai: =hasPrevious=, =previous=, =previousIndex=, =nextIndex=
* =ListIterator= opcionális metódusai: =add=, =set=

===!! equals, hashcode (5 pont)===
===!! Collections.compare (5 pont)===

==Kivételkezelés (060522, 051219, 050111, 040112, 021218)==

'''Írd le a Java kivételkezelés felépítését és működését. Szempontok: a kivételkezelés elve, kivételosztályok, azok hierarchiája és szerepe, ellenőrzött és nem ellenőrzött kivételek közötti különbségek, a kivételkezelés kulcsszavai és jelentésük, nyelvi konstrukciók és működésük, kivételek keletkezési módjai.'''

===!! elv (5 pont)===

Exception objektumokkal történik a hibák kezelése. Ezek a hiba helyén keletkeznek, és felfele terjednek az utasításblokkok és a híváslánc mentén, amíg valaki le nem kezeli őket, vagy ha nem kezeljük sehol, akkor megszakad a program futása.

Öröklődésnél a leszármazott osztály túlterhelt metódusa nem dobhat újabb kivételt, mint amik az ősben vannak.

===!! osztályok, hierarchiájuk és szerepük (5 pont)===

A kivtelek a =Throwable= osztályból származnak. =Error=, =Exception=, =RunTimeException=, +UML ábra.

=Error=: A JVM dobja, illetve API-ban használják.

Kivétel tovább dobható, illetve becsomagolható.

=printStackTrace()= metódus.

===!! ellenőrzött és nem ellenőrzött különbségek (5 pont)===

Ellenőrzött: az =Exception= osztályból származnak, kötelező kezelni, vagy =throws= kulcsszóval jelezni, hogy a hívó kezelje le őket.

Nem ellenőrzött: nullával való osztás és egyéb (=null= referencia, stb.) mindenhol előforduló hibákat jelezhet, de kényelmetlen és átláthatatlan lenne őket mindenhol jelezni, kezelni.

===!! kulcsszavak és jelentésük (5 pont)===

=throw=, =catch= (=finally=, =try=, =try-catch= blokk)

===!! konstrukciók és működésük (5 pont)===

=try-catch-finally= + folyamatábra

===!! keletkezési módok (5 pont)===

=throw= paranccsal, kifejezéskiértékelés során (nullával való osztás), metódushívás során ("kivétellel tér vissza").

==Generics, generikus típusok (060201)==

'''Ismertesd a Java 5.0-ban bevezetett generics (generikus típusok) működését. Mire szolgál, mik az előnyei a korábbi típuskezeléssel szemben. Generikus típusok definiálása, használata (ezekre mutass példát). Írd le, hogyan lehet a típusparaméterek körét szűkíteni. Mire szolgál a határozatlan típusparaméter? Hogyan valósították meg a generikus típusokat az 5.0-ás fordítóban és virtuális gépben? Ismertesd a generikus metódusok specialitásait.'''

===!! általános ismertetés (6 pont)===
===!! fordítási időben való típusellenőrzés (2 pont)===
===!! castolások elhagyása (2 pont)===
===!! generikus típusok definiálására és használatára példa (6 pont)===
===!! generikus típusok körének korlátozása (5 pont)===
===!! határozatlan típusparaméter (2 pont)===
===!! típustörlés, nyers típusok (3 pont)===
===!! generikus metódusok: leszármaztatás (4 pont)===

==Collections Framework (060120)==

'''Mutasd be a Java Collections Framework alapjait! Mutasd be a három fő adatmodellt, és ezek jellemzőit. Említs néhány implementációt mindhárom típusra! Hogyan lehet egy Collection-t rendezni? Említs meg néhány egyéb, Collection-ökön elérhető szolgáltatást! Mire kell ügyelni többszálú alkalmazás esetén?'''

===!! alapok (3 pont)===

=java.util= alatti osztályok és interfészek, amelyek a dinamikus adatszerkezeteket és az azokat kiszolgáló interfészeket valósítják meg.

UML ábra.

* Collection
** Set
*** SortedSet
** List
* Map
** SortedMap

===!! list + impl (5 pont)===

Lista: duplikátumok lehetnek, sorrend opcionálisan meghatározott

Implementációk: ArrayList (tömb), LinkedList (láncolt lista)

===!! set +impl (5 pont)===

Set: Matematikai halmaznak megfelelő, nincsenek duplikátumok, sorrend opcionális.

Implementációk: HashSet (hash tábla), TreeSet (kiegyenlített fa)

===!! map +impl (5 pont)===

Map (leképzés): kulcsok és értékek egyértelmű hozzárendelését határozza meg. Nem kölcsönösen egyértelmű.

Implementációk: HashMap (hash tábla), TreeMap (kiegyenlített fa)

===!! sort, Comparable, Comparator (5 pont)===

Természetes rendezés:
* A =Comparable= interfészt megvalósítva egy objektum saját magát tudja összehasonlítani egy másik objektummal.
* =compareTo(Object o)= metódust kell megvalósítani.

Összehasonlító osztályos rendezés:
* egy =Comparator= -ból származó objektum segítéségével történik a rendezés
* =compare(Object o1, Object o2)= metódus

Negatív, pozitív, nulla visszatérési értékek.

===!! Collections szolgáltatások (4 pont)===

Interfész, általános műveletek:
* =contains=
* =containsAll=
* =isEmpty=
* =iterator=
* =size=
* =toArray=

Opctionális műveletek (ha nincs megvalósítva, akkor kivételt dob):
* =add= (opcionális)
* =addAll(másikCollection)= (opcionális)
* =clear= (opcionális)
* =remove= (opcionális)
* =removeAll= (opcionális)
* =retainAll= (opcionális)

Lehetnek fix tartalmú Collection-ök is. A Collection-ök elemei csak objektumok lehetnek (wrapper class primitívek esetén).

Vannak kész algoritmusok: rendezésre, bináris keresésre, listák megfordítására, véletlen permutációk előállítására, stb.

Előállíthatóak szinkronizált nézetek, valamint módosíthatatlan nézetek is (a =Collections= statikus metódusaival).

===!! nem thread safe (3 pont)===

A CF megvalósításai nem szinkronizáltak.

Az =Iterator= és a =ListIterator= ún. '''fail-fast iterátor''', ha használat közben más módosít, akkor dob egy kivételt, de ez nem garantálható.

Vannak =synchronized= kezdetű metódusok az adatszerkezetek létrehozására, de az iterátorok nem tartoznak bele, azokra külön kell figyelni.

==Java I/O (060104, 031222)==

'''Mutasd be a java I/O-t! Alapelv, legfontosabb ősosztályok. Várható kivételek, stream végének kezelése. Szűrő fogalma. Karakteres I/O, objektumos I/O. Szerializáció fogalma. További lehetőségek.'''

===!! elv (4 pont)===

Stream, adatfolyam, szekvenciális hozzáférésű.
Megnyitás, írás/olvasás, lezárás. Karakteres- (=*Reader=, =*Writer=), és Bytestream (=*Stream=).

Olvashatunk/írhatunk bárhonnan/bárhova: fájl, pipe, memória, stb.

Konverzió: karakterkódolást is be lehet állítani.

===!! ősosztályok (3 pont)===

=Reader=, =Writer=, =InputStream=, =OutputStream=

===!! kivételek (3 pont)===

Az EOF néhol speciális érték, máshol kivétel (=EOFException=).

=IOException=, =FileNotFoundException=, =SecurityException=

===!! szűrők (3 pont)===

Szűrő lezárása lezárja a stream-et is.

Szűrők: =BufferedReader=, =PrintWriter=, =ObjectInputStream=, =ObjectOutputStream=.
* =DataInputStream=, =DataOutputStream=: minden típushoz külön =read/write= függvény

===!! karakteres i/o (4 pont)===

=PrintWriter=, =PrintStream=. Karakterenként ír, a neki megadott objektum =toString= metódusának eredményét írja ki. Sorvége jelet automatikusan cseréli a platform formátumára (csak a =Writer=).

Bufferelt olvasás.

=FileReader=, =FileWriter=

===!! objektumos i/o (5 pont)===

* Objektumok közvetlen írása/olvasása.
* =ClassNotFoundException=: ha nem ismerjük a fájlban lévő osztályt.
* Beolvasásnál cast-olni kell a nekünk kellő típusra.

===!! szerializáció (4 pont)===

* Objektum bájtsorozattá alakítása
* =Serializable= interfész kell hozzá
* Lehet sajátot is (=writeObject=, =readObject= metódusok felülírása)
* =transient= mező nem íródik ki (titkosításhoz is jó)
* argumentum nélküli konstruktor kötelező
* Verziók! (régi verzió által kiírt objektumot az új is jól olvassa be - az objektum felelőssége, de van amit tud automatikusan kezelni)

===!! további lehetőségek (típusos, módosítószók stb.) (4 pont)===

* =SequenceInputStream=: Byte-os csatornák egymás után fűzhetőek
* =LineNumberStream=: olvasott sorok számát nyilvántartja
* =PushbackReader=
* =FilterReader=
* =RandomAccesFile=
* =StreamTokenizer=: szövegfeldolgozáshoz

==Java biztonsági architektúra (050622)==

'''Mutasd be a Java biztonsági architektúráját, annak fejlődését. Ismertesd a Java biztonsági architektúra alapelemeit (permission, policy, kulcsok, kulcsmenedzsment, kulcstárolás). Hogyan történik egy digitális aláírás létrehozása és ellenőrzése? A Java fejlesztői környezetben milyen, a biztonsággal kapcsolatos eszközök állnak rendelkezésünkre?'''

===!! Biztonsági modellek (5 pont)===
===!! Permission osztályok (5 pont)===
===!! Policy file-ok (5 pont)===
===!! Kulcsok, kulcsmenedzsment, kulcstárolás (5 pont)===
===!! Aláírás létrehozása és ellenőrzése (5 pont)===
===!! policytool, keytool, jarsigner (5 pont)===

==Szálkezelés (threads) (050607, 030129)==

'''Írd le a Java szálkezelésének elemeit, működését. Mi a szinkronizáció alapja? Hogyan valósítható meg szinkronizáció metódus, illetve blokk szinten? Hogyan valósíthatunk meg szálakat? Szálak vezérlése + elavult módszerek'''

=Thread= osztály és leszármazottai, =Runnable= interfész, =run()= metódus.

===!! monitor (8 pont)===

Minden objektumhoz tartozik egy monitor, ezekkel valósul meg a szinkronizáció. A monitort egyszerre egy szál birtokolhatja - ha többnek is kell, akkor várakoznak, futásuk felfüggesztődik. Ha a birtokló elengedi, akkor a többi verseng érte, az ütemező választ.

===!! synchronized metódusok (3 pont)===

<pre>
public synchronized void method { ... }
</pre>

A metódust tartalmazó objektum monitora kell a belépéshez. Rekúrziv híváskor újra beléphet.

Statikus metódus esetén a =new MyClass.getClass()= monitorát kell megszerezni.

===!! synchronized blokkok (3 pont)===

<pre>
synchronized (monitorobj) { ... }
</pre>

Belépéskor a szál megszerzi a monitort, kilépéskor elengedi.

Atomi művelethez nem kell szinkronizáció (primitív típusok írása, olvasása, kivéve =long= és =double=).

Atomicitás: a többi szál nem láthat inkonzisztens állapotot, de nem garantál semmit, hogy másik szál mikor látja az új állapotot. Megoldás: =synchornized= mezőhozzáférés mindenhol vagy =volatile= mezők (ez garantálja, hogy az új érték azonnal láthatóvá válik a többi szál számára).

===!! Thread, Runnable (5 pont)===

Kivétel kimegy =stderr= -re ha nem kezeljük le.

===!! notify, notifyAll, wait, join, ... (4 pont)===

Ezek az =Object= osztály szolgáltatásai, kell hozzá az objektum monitora

* =wait(long timeout, long nanos)=: felfüggeszti a hívó szál futását
* =notify()=: az objektum monitorán wait()-elő szála felébresztése

Thread szolgáltatásai:

* =join(millis, nanos)=: A hívó szál várakozik, míg ez a szál be nem fejezi futását, vagy le nem jár az időkorlát (ha van).
* =sleep(millis, nanos)= felfüggeszti a futást, monitorokat nem enged el.
* =interrupt()=: alvás megszakítása
* =setDaemon(boolean)=: démon szál legyen-e

===!! start, stop, suspend, resume (4 pont)===

=Thread= szolgáltatásai. A =stop()= vesélyes, és a =suspend()=, =resume()= metódusokkal együtt elavult.

=stop()= esetén =ThreadDeath= kivétel bárhol a szálban, nehéz kezelni.

===!! stop, suspend, resume deprecated (3 pont)===

==Java Servlet, JavaServer Pages (050523)==

'''Írd le a Java Servlet és JavaServer Pages technológiák célját, a köztük lévő alapvető különbségeket, egymáshoz való viszonyukat! Rajzon mutasd be a servletek tipikus elhelyezkedését egy szerveren! Mutasd be a servletek életciklusát! Hogyan épül fel egy, a Java Servlet specifikációnak megfelelő web alkalmazás? Hogyan működik, és mi a célja a session kezelésnek? Mi egy tag library, és mi a célja?'''

===!! Java Servlet, JavaServer Pages célja, különbségeik, viszonyuk (10 pont)===
===!! servletek életciklusa (5 pont)===
===!! web alkalmazás felépítése (5 pont)===
===!! session kezelés (5 pont)===
===!! tag library (5 pont)===

==Swing MVC (050126)==

'''Írd le a Swing MVC architektúrán alapuló működési modelljét, és ennek programozási hatásait. Szempontok: koncepció, architektúrális felépítés, szálkezelés (eseménykezelés, renderelés), saját eseménykezelő rutinok írása és ezek hatása a Swing működésére, hosszan tartó műveletek összekapcsolása a grafikus felülettel.'''

===!! koncepció (5 pont)===

Pehelysúlyú komponensek, Java-ban megvalósítva, platformfüggetlen, bővebb, mint az AWT, ami az operendszer komponenseit használja. A megjelenés is egységes, J betűvel kezdődnek a komponensek nevei. Az AWT eseménykezelőjét használja.

===!! MVC architektúra (5 pont)===

Modell-View-Controller, adatmodell, megjelenítés, vezérlés. A Swingben a View és a Controller össze van vonva (Document-View).

LAF (look-and-feel): kinézet, minden komponenshez külön beállítható.

===!! Swing-ben használt módosított MVC architektúra, ennek szinkronizálási követelménye, kölcsönös kizárás megvalósítása a renderelő és az eseménykezelő rutin között (8 pont)===

Ha a képernyőfrissítés közepén megváltozik az adat, akkor inkonzisztens lehet a GUI tartalma. Ezért egy szálon történik a rajzolás és az eseménykezelés, amiből az következik, hogy a hosszú eseménykezelő műveletek blokkolhatják a GUI-t, így nem teljes a felhasználói élmény (mintha lefagyna). A hosszú műveleteket (I/O, hálózatkezelés, komplex számítások, stb.) ezért új szálon kell futtatni, majd a =javax.swing= csomag =SwingUtilities= osztályának =invoke= és =invokeLater= metódusinak átadni egy GUI-t frissítő objektumot, amit majd az eseménykezelő szál végrehajt GUI frissítés előtt.

Az eseménykezelő szálat nevezzük EDT, vagyis AWT EventDispatch Thread-nek.

Ha egy boolean adatot frissítünk, akkor azért lehet a feldolgozást végző szálból is frissíteni, de ettől bonyolultabbat nem ajánlott.

+folyamatábra.

===!! a saját eseménykezelő rutin feltartja az egész Swing működését, ezt kezelni kell (5 pont)===
===!! hosszan tartó műveleteket külön szálban kell elindítani, és ezeket vissza kell csatolni a grafikus felületbe az invokeAndWait vagy az invokeLater metódusok valamelyikével (5 pont)===
===!! invokeAndWait és invokeLater közötti különbség ismertetése (2 pont)===

Az =invokeLater= után rögtön visszakapja a futást az őt hívó szál, míg az =invokeAndWait= esetében csak miután frissült a GUI.

==Reflection (040126)==

'''Írd le a Reflection fogalmát, lehetőségeit, illetve az API felépítését (fontosabb osztályok, interfészek, ezek kapcsolata). Írj le egy szituációt, amikor szükség lehet a Reflection használatára.'''

===!! Reflection fogalma (5 pont)===

Hozzáférést biztosít a program metaszintű elemeihez a programból (osztályok, metódusok, mezők, stb.)

===!! Reflection lehetőségei (10 pont)===
===!! osztályok, interfészek (10 pont)===

=java.lang.reflect= csomag, de a =java.lang.Class= és a =java.lang.Package= osztályok is ide tartoznak.

* =Object=
** =Array=
** =Class=
** =Modifier=
** =Package=

* =AccessibleObject=
** =Constructor= (implementálja a =Member= interfészt)
** =Method= (implementálja a =Member= interfészt)
** =Field= (implementálja a =Member= interfészt)

Kell egy =Class= példány, ami leírja a vizsgálandó osztályt vagy objektumot. Hozzáférés:
* =class= literás (pl.: =String.class=)
* =getClass= metódus
* =Class.forName= metódussal betöltött osztály (minősített névvel)

===!! szituáció (5 pont)===

* Hozzáférés privát tagokhoz valamilyen szerializációhoz hasonló szolgáltatásnál (letiltható)
* Proxy osztályok (=java.lang.reflect.Proxy=): futásidőben változtathatjuk, hogy milyen interfészt implementálnak. Az interfészekre érkező hívásokat továbbítja egy híváskezelő osztályhoz (invocation handler).
** Az interfészek sorrendje számít, a =hashCode=, =equals= és =toString= metódusokat is továbbítja, a többi =Object= metódust nem.

==Logging API (040524)==

'''Írd le a Java Logging API elemeit és működését. Írj le egy alkalmazási példát a Logging API elemei segítségével.'''

Java 1.4 óta 
- Logok használata: 
- Hibák, kivételek jelzése a végfelhasználónak vagy a rendszergazdának
(konfigurációs hiba, erőforráshiány, biztonsági hiba ...) 
- Tesztelési fázisban a fellépő kivételek részletes leírása (+kontextus). Ezeket a
logokat eljuttatni a fejlesztőkhöz. 
- A fejlesztési fázisban hibadetektálásra, végrehajtási történet követésére,
események bekövetkeztének ellenőrzésére. 

===!! Elemek (10 pont)===

===!! Osztályok (8 pont)===

=Logger=, =Handler=, =Filter=, =Formatter=

===!! Működés (8 pont)===

Loggereknek van szülője, neki is továbbítja az üzeneteket. Egy loggerhez több handler is tartozhat. Logolási szintek. Loggerek neve.

Handler: stream, console, file, socket, memory

===!! Alkalmazási példa (4 pont)===

=Logger.getLogger(String name)= metódus, aztán =logger.info=, =logger.entering=, stb. metódusok.

==JNI, Java Native Interface (040608)==

'''Írd le a Java Native Interface (JNI) célját, elemeit, eszközeit, használatának két alapvető módját. Írd le egy natív kódrészlet JNI segítségével történő integrációjának lépéseit.'''

===!! Célja (5 pont)===

Natív, rendszerközeli, platformfüggő dolgokhoz hozzáférni más nyelvekkel készült kódon keresztül, vagy más nyelvekből Java objektumok elérése. Hatékonysági okok, assembly. Java-C kommunikáció mindkét irányban, kivételek dobása-elkapása is működik.

===!! Elemei (JNI API, Invocation API) (5 pont)===

Natív Java metódusok (C-ben megvalósítva mondjuk), illetve az Invocation API segítségével egy Java virtuális gépet indíthatunk C-ből. Leállítani közvetlenül nem lehet, csak megkérni rá (majd leáll, ha az összes nem démon szál leállt).

===!! Eszközei (javah) (5 pont)===
===!! Használati módok (5 pont)===
===!! Példa (10 pont)===

A natív metódusokat a =native= kulcsszóval jelezzük, és nem írjuk meg a kódját (mintha absztrakt lenne). Ezután fordítunk, majd a =javah= programmal generálunk belőle egy C-s header fájlt, ami alapján meg tudjuk írni a C kódot. Ha ez megvan, akkor ez lefordítjuk C fordítóval, amiből kaptunk mondjuk egy DLL-t, amit a natív metódus osztályának statikus inicializátorában betölthetünk a =System.loadLibrary= metódussal. Ezután a szokásos módon használható a metódus.

==Package-ek (041220, 030108)==

'''Írd le a Java csomagok (package-ek) szerepét, tulajdonságait, használatát! (definiálásuk, hivatkozás csomagokra, hozzáférésvezérlés csomagokkal kapcsolatos kérdései, stb.)'''

===!! szerepük: hierarchikus csoportosítás (5 pont)===
===!! nem valódi hierarchia (5 pont)===
===!! package deklaráció (5 pont)===
===!! hozzáférés minősített nevekkel, import-tal (5 pont)===
===!! névtelen csomag (4 pont)===
===!! névtelen csomaghoz nem lehet hozzáférni másik csomagból (3 pont)===
===!! package private (3 pont)===

==RMI (030122)==

'''Írd le a Remote Method Invocation (RMI) elemeit és azok szerepét! Hogyan továbbítódnak a metódushívások paraméterei és a visszatérési értékek a kliens és a szerver között? Egy kliens hogyan talál meg egy adott szolgáltatást egy szerveren? Mely lépéseket kell követni egy RMI alkalmazás megírásakor?'''

===!! szerver, kliens, stub, skeleton (10 pont)===

Távoli objektum távoli metódusa hívható, objektumok is közlekedhetnek. Tisztán Java. Kliens és szerveroldali vázak. Interfészek a működés leírására.
* kliens: tudja hogy működik, egy proxy fut a kliensoldalon, ami továbbít a szerver felé.
* szerver: végrehajtja

Három absztakciós réteg:
* stub és szkeleton réteg: a fejlesztő ezen keresztül veheti igénybe a szerver szolgáltatásait, a szerver oldalon ezek kapcsolódnak az implementált szolgáltatáshoz
* távoli referencia réteg: a kliensek távoli objektumokra való hivatkozását kezeli
* transzport réteg: TCP/IP

Stub működése:
# kapcsolat felépítése a távoli JVM-el
# marshalling
# várakozás eredményre
# unmarshalling
# eredmények visszaadása a hívónak

===!! skeleton-ra nincs már szükség (2 pont)===

JDK1.2-től már nem kell a skeleton segédosztály (a stub protokoll továbbfejlesztése miatt). Amúgy a marshalling és a hívás elvégzéséért felelt.

===!! marshalling, unmarshalling (6 pont)===

marshalling: szerializáció és átküldés
unmarshalling: eredmények olvasása (deszerializáció)

===!! RMI Registry (5 pont)===

Kell a távoli egyedre referencia. Megoldás: naming vagy directory service, =java.rmi.Naming= osztály

Szerver oldalon van =java.rmi.registry.Registry=.

===!! lépések (7 pont)===

# Interfész megírása (=java.rmi.Remote= kiterjesztése)
# Szolgáltatás-implementáció elkészítése
# Stubok létrehozása
** =rmic Osztálynév= generálja
# Szerver létrehozása a kérések fogadására
# Kliens létrehozása
# A rendszer beindítása
** =rmiregistry= parancs
** =java Server=
** +kliens

-- [[KarakoMiklos|palacsint]] - 2007.01.08.
-- [[KarakoMiklos|palacsint]] - 2007.01.11.

[[Category:Valaszthato]]

Java-technológia - Elméleti kérdések - Laptörténet

David14: David14 átnevezte a(z) Java-technológia elméleti kérdések lapot a következő névre: Java-technológia - Elméleti kérdések

Unknown user: Új oldal, tartalma: „{{GlobalTemplate|Valaszthato|JavaTechElmelet}} Minden feladat 30 pontot ér. A feladatok a tárgy weblapjáról származnak, a rövid jegyzetek pedig a kiadott diák …”

← Régebbi változat		A lap 2013. február 6., 12:03-kori változata
(Nincs különbség)