Az előadás letöltése folymat van. Kérjük, várjon

Az előadás letöltése folymat van. Kérjük, várjon

1 Fejlett Programozási Technikák 2. 15/3. Fejlett Programozási Technológiák 2. 2 A mai előadás tartalma: Java Virtual Machine  Memória kezelés  Szemét.

Hasonló előadás


Az előadások a következő témára: "1 Fejlett Programozási Technikák 2. 15/3. Fejlett Programozási Technológiák 2. 2 A mai előadás tartalma: Java Virtual Machine  Memória kezelés  Szemét."— Előadás másolata:

1 1 Fejlett Programozási Technikák 2. 15/3

2 Fejlett Programozási Technológiák 2. 2 A mai előadás tartalma: Java Virtual Machine  Memória kezelés  Szemét gyűjtő  Hiba keresés támogatás  Fordító Java nyelv alapjai  Változók  Operátorok, Vezérlő szerkezetek  Osztályok  Interfészek  RTTI  Reflexió  Alap objektumok  Csomagok JAR fájlok

3 Fejlett Programozási Technológiák 2. 3 Irodalom

4 Fejlett Programozási Technológiák 2. 4 Java nyelv I. Egyszerű  a kezdők is könnyen boldogulnak vele (C,C++) Magasszintű  komplex feladatok egyszerűen megoldhatóak vele (hálózat kezelés, grafika) Objetum orientált  az alapoktól kezdve (a primitív adattípusok kivételével minden objektum)  elosztott rendszerek (komponens alapú fejlesztés, újrafelhasználhatóság) Biztonságos, robosztus  fordításkor ellenőrzés  nincs pointer (NULL pointerre hivatkozás, levegőbe lógó mutatók)  nincs automatikus konverzió  dinamikus szemétgyűjtés (memory leak)

5 Fejlett Programozási Technológiák 2. 5 Java nyelv II. Platform független  nem tartalmaz architektúra függő elemeket (az int, mérete … nyelvi szinten definiált) Interpretált, dinamikus  gyors fejlesztési ciklus (nincs szükség make-re, ant )  class loader (package)  virtuális gép  byte kód (a hivatkozások csak futás időben oldódnak fel)  szor lassabb mint gépi kódú megfelelője Többszálú Elosztott (a class loader képes hálózatról betölteni az osztályt, RMI, …)

6 Fejlett Programozási Technológiák 2. 6 Hol, hogyan használhatjuk? Kliens oldal:  Java Applet  Java Kliens  Java Swing Szerver oldal:  Java Swing  JDBC  Java Servlet  JSP  RMI  JMS  Java IDL  JTS  EJava Bean

7 Fejlett Programozási Technológiák 2. 7 Hogyan működik ? I. JVM Java API.java fájl javac osztaly.java osztaly.class java osztaly

8 Fejlett Programozási Technológiák 2. 8 Hello World ! /** * A HelloWorldApp osztály mely a szabványos kimenetre kiírja a Hello World üdvözletet. */ class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); //Kiírja a szöveget. } 1. ClassLoader() 2. Ellenőrzés 3. Memória foglalás 4. A hivatkozott osztályok betöltése (implementáció függő) 5. Inicializálás 6. main metódus meghívása

9 Fejlett Programozási Technológiák 2. 9 Java megvalósítások JVM  VM (Interpretált) Egy bájtos utasítások (kicsi byte-kód) Nincs regiszter -> Minden a stack-ben történik  JIT (Lefordított)

10 Fejlett Programozási Technológiák HotSpot Verziói:  Kliens  Szerver Memória modell Szemét Gyűjtő Fordító Debug támogatás

11 Fejlett Programozási Technológiák Memória kezelés pc register  Tartalmazza az adott szál által aktuálisan végrehajtott utasítás címét (Natív metódus esetén definiálatlan) Stack (kereteket tárol)  Minden szál rendelkezik egy veremmel (a szál létrehozásakor jön létre)  A második leggyorsabb tároló.  Az aktuális metódusok adatai tárolódnak itt. (Helyi változók, részeredmények) Heap  A VM induláskor hozza létre (a HotSpot-ban dinamikus a mérete)  A szálak osztoznak a heap-en (közös memóriaterület)  Általános célú memória  Minden new operátorral létrehozott objektum ide kerül (tömb, objektum)  Közvetlen memória címzés (két szó méretű fejléc)  A GC kezeli Static storage  Minden szálank közös terület  Azon adatok tárolódnak itt melyekre az egész programból lehet hivatkozni a futás teljes ideje alatt. (static) Constant storage  A nem változó adatok tárolóhelye (final)

12 Fejlett Programozási Technológiák Hulladék gyűjtő (Garbage Collector) A Java környezet egyik legfontosabb szolgáltatása Nem új ötlet 1960 óta: Lisp, Smalltalk, Modula-3, … 1970-es években elméleti cikkek: a szemét gyűjtés az erőforrások 20-40%-át fogja le nagyobb Lisp programokban Mérőszámai:  Szünet időtartam  Szünet megjósolhatóság  Memória használat  CPU használat  Virtuális memória kezelés  Cache kezelés  Igény a fordító, runtime felé

13 Fejlett Programozási Technológiák Probléma Hogyan állapítsuk meg, hogy az objektum aktív?  Hivatkozás a gyökérben  Hivatkozás más objektumból Típusok:  Hivatkozás számlálás  Követő gyűjtők  Megjejlölő-cserélő gyűjtők  Másoló gyűjtők  Megjelölő-tömörítő gyűjtők

14 Fejlett Programozási Technológiák Generációs hulladék gyűjtés  Az objektumok 98%-a fiatalon fejezi be pályafutását -> Másoló Gyűjtő  Az első szemétgyűjtést túlélő objektumok jelentős része hosszú életű lesz -> Megjelölő-Tömörítő algoritmus  Kártya jelölés JDK 1.4.1:  Fiatal Éden Túlélő 1. Túlélő 2.  Öreg  Tartós System.gc() nagy gyűjtemény HotSpot Kis gyűjtemény Nagy gyűjtemény

15 Fejlett Programozási Technológiák HotSpot Növekményes gyűjtemény:  Train algoritmus: új memória terület a fiatal és öreg objektumok között, ez kocsikra van osztva Párhuzamos gyűjtögetés  „A legtöbb algoritmus megállítja a világot”  Párhuzamos Másoló gyűjtő  Párhuzamos Jelölő-Cserélő gyűjtő

16 Fejlett Programozási Technológiák Fordító JIT Just in Time fordító:  Egyszerű gyors hagyományos fordító  Problémák: A felhasználó ideje alatt fordítódik A Java metódusok nagy része polimorfikus (nem használható a hagyományos statikus fordító) A Java programok futás közben megváltozhatnak (dinamikus osztály betöltés)

17 Fejlett Programozási Technológiák HotSpot JIT A legtöbb program idejének nagy részét egy kis részébe tölti (HotSpot) Az összes metódus lefordítása helyett csak a leggyakrabban használt metódusokat fordítja le gépi kódra A gyakran használt metódusok behelyettesítése (inlininig). Nem foglalkozik azzal, hogy final-e. Dinamikos deoptimalizálás. Egy egy osztláy betöltése után előfordulhat, hogy a behelyettesített metódust vissza kell cserélni metódushívásra Két típus:  Kliens (gyors, kevesebb memóriát használ, nem optmális)  Szerver (lassabb, optimálisabb)

18 Fejlett Programozási Technológiák Debug támogatás JPDA Java Plaform Debugger Architecture  JVMDI (HotSpot) Stack Break point …  JDWP Távoli processz Ugyanaz csak információ szűrés Kötegelés  JDI Magas szintű Java interfész Full Speed Debugging (nem csak interpretált) HotSwap Class File Replacement

19 Fejlett Programozási Technológiák Java Alapok Változók Operátorok Vezérlő szerkezetek Osztályok Interfészek RTTI Reflexió Alap objektumok Csomagkezelés Dokumentáció

20 Fejlett Programozási Technológiák Változó típusok

21 Fejlett Programozási Technológiák Változók és a memória A változó egy programterület a memóriában melyben adatokat tárolhatunk Jellemzői:  Azonosító (segítségükkel hivatkozunk a memória területre)  Hatókör, élettartam (az adat hozzáférhetőségét adja meg a program futása alatt, amíg az objektumra van hivatkozás az objektum hozzáférhető)  Cím (a memóriacím, nem kell vele foglalkoznunk)  Adattípus (megadja a tárolt adat értelmezését)  Érték (ha egy objektumhoz tartozik akkor létrehozásakor alapértelmezett értéke lesz.)

22 Fejlett Programozási Technológiák Wrapper (csomagoló) Osztályok Minden primitív adattípusnak van csomagoló osztálya Segítségükkel a primitív típusokat is objektumként kezelhetjük Boolean, Integer, …

23 Fejlett Programozási Technológiák Változók A minden változóhoz típust és nevet kell rendelnünk. A változók nevét kicsi betűvel kezdjük, a több szóból álló változókat a szóhatárnál nagybetűvel választjuk el. bool isVisible; az aláhúzást mindenhol használhatjuk de csak a konstansokban szokás az utasítások végén ; Létrehozáskor az alapértelmezett érték:  0  0.0  False  /U0000  null

24 Fejlett Programozási Technológiák Példa public class MaxVariablesDemo { public static void main(String args[]) { byte largestByte = Byte.MAX_VALUE; short largestShort = Short.MAX_VALUE; int largestInteger = Integer.MAX_VALUE; long largestLong = Long.MAX_VALUE; float largestFloat = Float.MAX_VALUE; double largestDouble = Double.MAX_VALUE; char aChar = 'S'; boolean aBoolean = true; System.out.println("The largest byte value is " + largestByte); … }

25 Fejlett Programozási Technológiák Operátorok () []. zárójelek, indexelés, osztály komponensére hivatkozás ! ~ instanceof (pre- vagy poszt-) inkremens és dekremens, logikai és bitenkénti negálás, típus ellenôrzés new (type)expression új egyed létrehozása * / % szorzás, osztás, moduló + - összeadás, kivonás > >>> bitenkénti léptetések >= <= összehasonlítások == != egyenlô, nem egyenlô & bitenkénti AND ^ bitenkénti XOR | bitenkénti OR && logikai AND || logikai OR ? : feltételes kifejezés = += -= *= /= %= ^= &= |= >= >>>= különbözô értékadások

26 Fejlett Programozási Technológiák Vezérlő szerkezetek I. ciklusok:  while  do-while  for döntési pontok:  if-else  switch-case while (kifejezés) { utasítások } do { utasítások } while (kifejezés); for (inicializálás; befejezés; növekmény) { utasítások } if (feltétel) { utasítás ha teljesül} else { utasítás ha nem teljesül } switch (változó(csak int)) { case érték1: utasítás1; break; case érték2: utasítás2; break; default: utasítás; }

27 Fejlett Programozási Technológiák Vezérlő szerkezetek II. kivétel kezelés:  try-catch-finally elágazás  break (kilép)  continue (ellenőrzi a feltételt)  return (kilép a metódusból) try { utasítások } catch (kivétel neve) { utasítások} finally { utasítások}

28 Fejlett Programozási Technológiák Objektumok I. A primitív típusok kivételével minden objektum Egy objektum létrehozásának fázisai: Point origin_one = new Point(23, 94); Rectangle rect_one = new Rectangle(origin_one, 100, 200); Rectangle rect_two = new Rectangle(50, 100); PéldányosításDeklarálás Inicializálás

29 Fejlett Programozási Technológiák Objektumok II. Az objektumok metódusait, változóit az objektumon keresztül érhetjük el. Nem célszerű a változókhoz közvetlen hozzáférést engedélyezni. Minden egyes objektumnak meghatározott típusa kell, hogy legyen. Minden változó hivatkozás. Érték adáskor erre figyelnünk kell ! Rectangle rect_one = new Rectangle(origin_one, 100, 200); int terulet = rect_one.area(); int w = rect_one.width;

30 Fejlett Programozási Technológiák Objektumok III. public class Point { public int x = 0; public int y = 0; public Point(int x, int y) { this.x = x; this.y = y; } class teszt { public static void main(String[] args) { Point masolat; Point eredeti = new Point(23, 94); masolat = eredeti; masolat.x=1000; System.out.println(eredeti.x); } if (x instanceof Person) System.out.println("x egy személy!");

31 Fejlett Programozási Technológiák System.gc() Az objektumok felszabadításával a program futása után nem kell foglalkoznunk. A szemét gyűjtő megteszi ezt helyettünk finalize metódus (a szemétgyűjtő meghívja ezt mielőtt megszüntetné) Gyakori hibák (lehetnek):  System.gc() hívás (Minden generációt ellenőriz)  finalize metódus szükségtelen alkalmazása: ez esetben a szemét gyűjtőnek regisztrálni kell a metódust úgy létrehozáskor mint megsemmisítéskor  Objektum referencia NULL értékre állítás

32 Fejlett Programozási Technológiák Hiba public class LinkedList { private static class ListElement { private ListElement nextElement; private Object value; } private ListElement head; } public void finalize() { try { ListElement p = head; while (p != null) { p.value = null; ListElement q = p.nextElement; p.nextElement = null; p = q; } head = null; } finally { super.finalize(); }

33 Fejlett Programozási Technológiák Osztályok Osztályok létrehozása:  Osztály deklaráció public – alapértelmezés, egyébként csak az azonos csomagban lévő osztályok használhatják abstract – az osztály nem pédányosítható final – az osztályból nem származtatható másik class osztálynév – az osztály neve extends – az osztály őse (mindenképpen kell egy ős) implements interface – a megvalósított egy, vagy több interfész  Osztály törzs a változókat és a metódusokat tagoknak nevezzük Konstrutor (null konstruktor)  private – más osztály nem példányosíthatja az osztályunkat  protected – csak alosztályok és az egy csomagban lévő osztályok példányosíthatják  public – bármely osztály példányosíthatja

34 Fejlett Programozási Technológiák Tag változók tag változók:  hozzáférési szint: private - osztály protected – osztály, alosztály public - mindneki default – osztály, csomag, alosztály  static – ez osztály változó (pl. példány számlálás)  final – nem változtatható (csak a konstruktorban adhatunk értéket)  transient – nincs teljesen specifikálva de az objektum mentésnél az ilyen nem mentődik el  voaliate – ritkán használt tulajdonság (megakadályozza a fordítót bizonyos optimalizálások elvégzésében)

35 Fejlett Programozási Technológiák Metódusok Módosító (mutator) setXXX Hozzáférő (accessor) getXXX Argumentum nélküli

36 Fejlett Programozási Technológiák Metódusok public Object push(Object item) throws … { items.addElement(item); return(item); } törzs deklaráció Hozzáférési szint Visszatérési érték Paraméterek Kivétel kezelés

37 Fejlett Programozási Technológiák Metódusok I. Hozzáférési szint:  private - osztály  protected – osztály, csomag, alosztály  public - mindenki  Default (nem adunk meg semmit) – osztály, csomag, alosztály Static – akkor is el lehet érni amikor nincs példányosítva public class teszt { public static int x; public static void pelda() { System.out.println(x); } class teszt1 { public static void main(String[] args) { System.out.println(teszt.x); }

38 Fejlett Programozási Technológiák Metódusok II. abstract – nincs implementálva, csak absztrakt osztály tagja lehet (csak a koncepciót vázoljuk, a megvalósítás az alosztályok feladata lesz) final – nem írható felül (biztonsági okok (string - final), tervezés) native – más nyelven írt függvény(a JNI segítségével oldható meg) synchronised – párhuzamosan futó szálak metódusokat használhatnak, hogy hozzáférjenek a változókhoz. Ezzel oldhatjuk meg a zárolást

39 Fejlett Programozási Technológiák Metódusok III. throws exceptions – segítségével tudunk kivételeket kezelni az argumentumokat érték szerint adja át, a visszatérési értéket is. több metódusnak lehet egy neve, ekkor az argumentumok alapján dől el melyik hívódik meg Az alosztályokban lévő ilyen nevű metódusok felülírják az ős metódusait

40 Fejlett Programozási Technológiák Metódusok IV Érték szerinti paraméter átadás (pass by value)  Primitív típusnál az érték másolata adódik át  Referencia esetén a referencia másolata adódik át, az objektum tulajdonságait megváltoztathatja, hivatkozását viszont nem! Metódus lenyomat (method signature)  Visszatérési érték  Név  Paraméterlista Példány metódusok (instance) Osztály metódusok (class)

41 Fejlett Programozási Technológiák Final Hiba:  Gyakran azért használják mert nagyobb sebességet várnak tőle Osztályoknál, Metódusoknál:  Csak akkor használjuk, ha tényleg azt szeretnénk, hogy osztályunk, metódusunk végleges legyen Adattagoknál:  Használata segíti a hibák kiküszöbölését és gyorsabb is lehet a kódunk (regiszterben tárolhatja az értékét)

42 Fejlett Programozási Technológiák Metódus túlterhelés (overloading) A gyermek osztályban definiált ugyanolyan nevű metódus nem fedi el az ős osztály metódusait (amennyiben más az argumentumlistájuk) Konstruktor esetén elsőnek kell meghívni (this(xxx))

43 Fejlett Programozási Technológiák class Homer { char doh(char c) { System.out.println("doh(char)"); return 'd'; } float doh(float f) { System.out.println("doh(float)"); return 1.0f; } class Milhouse {} class Bart extends Homer { void doh(Milhouse m) { System.out.println("doh(Milhouse)"); } public class Hide { private static Test monitor = new Test(); public static void main(String[] args) { Bart b = new Bart(); b.doh(1); b.doh('x'); b.doh(1.0f); b.doh(new Milhouse()); }

44 Fejlett Programozási Technológiák Konstruktorok public class Rectangle { public int width = 0; public int height = 0; public Point origin; Rectangle() { origin = new Point(0, 0); } public Rectangle(Point p) { origin = p; } public Rectangle(int w, int h) { this(new Point(0, 0), w, h); } public Rectangle(Point p, int w, int h) { origin = p; width = w; height = h; }

45 Fejlett Programozási Technológiák Objektumok létrehozásának lépései 1. Deklarálás (lefoglalja az objektumhoz tartozó területet) 2. Alapértelmezett inicializálás 3. Explicit inicializálás 4. Konstruktor meghívása 5. A referencia hozzárendelése a változóhoz

46 Fejlett Programozási Technológiák Inicializáló blokkok Statikus inicializáló blokk (csak statikus adattagok inicializálására) csak egyszer fut le static { ARRAY_SIZE = 57; } Nem-Statikus inicializáló blokk (mindenfajta adattag inicializálására) minden objektum létrehozásakor lefut { Calendar c = Calendar.getInstance(); dateOpened = c.getTime(); c.add(Calendar.DATE, 30); nextBillingDate = c.getTime(); }

47 Fejlett Programozási Technológiák Inicializálás (argumentumok nélkül) class Art { Art() { System.out.println("Art constructor"); } class Drawing extends Art { Drawing() { System.out.println("Drawing constructor"); } public class Cartoon extends Drawing { public Cartoon() { System.out.println("Cartoon constructor"); } public static void main(String[] args) { Cartoon x = new Cartoon();} } Art constructor Drawing constructor Cartoon constructor

48 Fejlett Programozási Technológiák Inicializálás (argumentumokkal) class Game { Game(int i) { System.out.println("Game constructor"); } class BoardGame extends Game { BoardGame(int i) { super(i); System.out.println("BoardGame constructor"); } public class Chess extends BoardGame { Chess() { super(11); System.out.println("Chess constructor"); } public static void main(String[] args) { Chess x = new Chess(); } Kötelező Elsőként kell meghívni

49 Fejlett Programozási Technológiák Konstruktorok és a polymorfizmus A konstruktorok implicit static metódusok Inicializálás:  Az objektumok memóriaterületeire bináris nulla íródik  Az ős osztályok konstruktorai hívódnak meg  Deklaráció sorrendjében a tag változók inicializálódnak  A származtatott osztály konstruktora meghívódik Csak final vagy private metódusokat érdemes a konstruktorból meghívni !!!

50 Fejlett Programozási Technológiák Megfelelő befejezés finally – egyes esetekben nekünk kell lekezelni finalize() – nem tudjuk mikor hajtódik végre A szemétgyűjtőre csak a memóriakezelést érdemes hagyni, a többit érdemes nekünk megcsinálni

51 Fejlett Programozási Technológiák public static void main(String[] args) Kötelező formátum java x ”elso parameter” Tesztelésre minden osztályba használható

52 Fejlett Programozási Technológiák Öröklődés I. az alap objektum az Object belőle származik minden objektum közvetlenül vagy közvetve az alosztály örökli az ős metódusait, változóit (az össze elődét) melyek public vagy protected láthatóságúak örököl mindent aminél nincs specifikálva a láthatóság és egy csomagban vannak mivel a konstruktor-ok nem tagok azok nem öröklődnek

53 Fejlett Programozási Technológiák Öröklődés II. superclass – ősosztály az egyforma nevű változóknál, metódusoknál az alosztályé érvényes final metódust nem lehet felülírni abstract metódust kötelező felülírni (vagy az alosztálynak absztraktnak kell lennie) super.valtozonev – az ős változója super.metodusnev() – az ős metódusa super() – ős konstruktor

54 Fejlett Programozási Technológiák Object minden osztály belőle származik közvetve vagy közvetlenül felülírható metódusai:  clone (klónozás)  equals / hashCode (összehasonlítás, int)  finalize (memória felszabadítás, super.finalize())  toString végleges metódusai:  getClass  notify  notifyAll  wait

55 Fejlett Programozási Technológiák getClass() végleges segítségével lekérhetjük az objektum osztályát, ősosztályát void PrintClassName(Object obj) { System.out.println("The Object's class is " + obj.getClass().getName()); } Object createNewInstanceOf(Object obj) { return obj.getClass().newInstance(); }

56 Fejlett Programozási Technológiák Egymásba ágyazott osztályok I. class TartalmazoOsztaly{... class BeagyazottOsztaly {... } } a beágyazott osztály hozzáfér a tartalmazó osztály minden tagjához a protected-hez is gyakran használják eseménykezelésre a beágyazott osztály lehet:  teljes  anonymous – egy metódusban definiáljuk

57 Fejlett Programozási Technológiák Egymásba ágyazott osztályok II. anonymous public class kezelo implements ActionListener { helyette: public hourField.addActionListener() { new ActionListener() { public void actionPerformed(ActionEvent e) { Integer.parseInt(e.getActionCommand); }

58 Fejlett Programozási Technológiák Upcasting Az új osztály a meglévő osztály egy típusa Minden üzenetet melyet az ősosztálynak küldhetünk elküldhető a gyermek osztálynak is A Java erősen típusos nyelv azonban a gyermek referencia ős referenciává alakítása működik (upcasting)! Mindég biztonságos (egy specifikusabb megvalósításból megyek egy általánosabbra) ezért nem kell semmilyen módon jeleznünk a fordító számára class Instrument { public void play() {} static void tune(Instrument i) { //... i.play(); } // Wind objects are instruments // because they have the same interface: public class Wind extends Instrument { public static void main(String[] args) { Wind flute = new Wind(); Instrument.tune(flute); // Upcasting }

59 Fejlett Programozási Technológiák Kései kötés (late binding) Shape s = new Circle(); s.draw(); Minden metódus így működik Kivétel final, static (ezzel gyorsíthatjuk a programot, a fordító hatékonyabb kódot generál, a private metódusok is finalként működnek) A private metódus nem felülírható !!! public class PrivateOverride { private void f() { System.out.println("private f()"); } public static void main(String[] args) { PrivateOverride po = new Derived(); po.f(); } class Derived extends PrivateOverride { public void f() { System.out.println("public f()"); }

60 Fejlett Programozási Technológiák abstract class Glyph { abstract void draw(); Glyph() { System.out.println("Glyph() before draw()"); draw(); System.out.println("Glyph() after draw()"); } class RoundGlyph extends Glyph { private int radius = 1; RoundGlyph(int r) { radius = r; System.out.println( "RoundGlyph.RoundGlyph(), radius = " + radius); } void draw() { System.out.println( "RoundGlyph.draw(), radius = " + radius); } public class PolyConstructors { public static void main(String[] args) { new RoundGlyph(5); } Glyph() before draw() RoundGlyph.draw(), radius = 0 Glyph() after draw() RoundGlyph.RoundGlyph(), radius = 5

61 Fejlett Programozási Technológiák Downcasting Az upcasting biztonságos downcasting-nál meg kell vizsgálni a referenciát RTTI (run time type identification) ClassCastException

62 Fejlett Programozási Technológiák class Useful { public void f() {} public void g() {} } class MoreUseful extends Useful { public void f() {} public void g() {} public void u() {} public void v() {} public void w() {} } public class RTTI { public static void main(String[] args) { Useful[] x = { new Useful(), new MoreUseful() }; x[0].f(); x[1].g(); // Compile time: method not found in Useful: //! x[1].u(); ((MoreUseful)x[1]).u(); // Downcast/RTTI ((MoreUseful)x[0]).u(); // Exception thrown } } ///:~

63 Fejlett Programozási Technológiák RTTI Class objektum – minden általunk használt osztályhoz Class.forName() Class.newInstance() X.class instanceof Amikor egy objektumot létrehozunk a JVM megnézi, hogy az adott Class objektum be van-e már töltve, ha nincs akkor betölti (nem töltődik be minden a program elindításakor)

64 Fejlett Programozási Technológiák class Candy { static { System.out.println("Loading Candy"); } } class Gum { static { System.out.println("Loading Gum"); } } class Cookie { static { System.out.println("Loading Cookie"); } } public class SweetShop { public static void main(String[] args) { System.out.println("inside main"); new Candy(); System.out.println("After creating Candy"); try { Class.forName("Gum"); } catch(ClassNotFoundException e) { System.out.println("Couldn't find Gum"); } System.out.println("After Class.forName(\"Gum\")"); new Cookie(); System.out.println("After creating Cookie"); } } ///:~ inside main Loading Candy After creating Candy Loading Gum After Class.forName(\"Gum\") Loading Cookie After creating Cookie

65 Fejlett Programozási Technológiák Reflexió Fordításkor nem áll rendelkezésre az osztály  Grafikus felület készítés (RAD)  RMI java.lang.reflect  Field  Method  Constructor  Member interfész  invoke( ),getFields( ), getMethods( ), getConstructors( ), Hasznos lehet még ha nem akarjuk a dokumentációt böngészni, de kíváncsiak vagyunk egy osztály összes metódusára (nem csak a felülírtakra!)

66 Fejlett Programozási Technológiák import java.lang.reflect.*; import java.util.regex.*; public class ShowMethods { private static final String usage = "usage: \n" + "ShowMethods qualified.class.name\n" + "To show all methods in class or: \n" + "ShowMethods qualified.class.name word\n" + "To search for methods involving 'word'"; private static Pattern p = Pattern.compile("\\w+\\."); public static void main(String[] args) { if(args.length < 1) { System.out.println(usage); System.exit(0); } int lines = 0; try { Class c = Class.forName(args[0]); Method[] m = c.getMethods(); Constructor[] ctor = c.getConstructors(); if(args.length == 1) { for(int i = 0; i < m.length; i++) System.out.println( p.matcher(m[i].toString()).replaceAll("")); for(int i = 0; i < ctor.length; i++) System.out.println( p.matcher(ctor[i].toString()).replaceAll("")); lines = m.length + ctor.length; }else { for(int i = 0; i < m.length; i++) if(m[i].toString().indexOf(args[1]) != -1) { System.out.println( p.matcher(m[i].toString()).replaceAll("")); lines++; } for(int i = 0; i < ctor.length; i++) if(ctor[i].toString().indexOf(args[1]) != -1) { System.out.println(p.matcher( ctor[i].toString()).replaceAll("")); lines++; } }} catch(ClassNotFoundException e) {System.out.println("No such class: " + e); } }} ///:~

67 Fejlett Programozási Technológiák Interfészek az interfész egy protokollt definiál mely bárhol megvalósítható. segítségével tulajdonképpen megvalósítható a többszörös öröklődés az interfész metódusokat definiál, de nem implementálja őket definiálhat változókat is különbség az absztrakt osztály és az interfész között:  egy interfész nem implementálhat metódusokat  egy osztály több interfészt megvalósíthat  az interfész nem tagja az osztályhierarchiának

68 Fejlett Programozási Technológiák Interfész definiálása az interfész örökölhet extends (őse a szuper interfész) a metódusok törzs nélküliek csak static, final módosítók használhatóak minden public public interface StockWatcher extends PStockWatcher{ final String sunTicker = "SUNW"; final String oracleTicker = "ORCL"; final String ciscoTicker = "CSCO"; void valueChanged(String tickerSymbol, double newValue); }

69 Fejlett Programozási Technológiák Interfész megvalósítása minden az interfészben deklarált metódust meg kell valóstani az interfészt nem szabad módosítani! az extends az implements előtt szerepel public class StockApplet extends Applet implements StockWatcher {... public void valueChanged(String tickerSymbol, double newValue) { if (tickerSymbol.equals(sunTicker)) {... } else if (tickerSymbol.equals(oracleTicker)) {... } else if (tickerSymbol.equals(ciscoTicker)) {... } }

70 Fejlett Programozási Technológiák Csomagkezelés az osztálykezelés egyszerűbbé tétele feloldja az elnevezési problémákat az összefüggő osztályokat csomagokba lehet foglalni minden forrás fájl elejére oda kell tenni a package szót a csomagon kívül csak a public tagok, osztályok hozzáférhetőek elnevezésre a cégek a cég URL címének inverze használható: com.company.package package graphics; public class Circle extends Graphic implements Draggable {... }

71 Fejlett Programozási Technológiák Csomagok használata Hivatkozhatunk a tagra a teljes névvel A csomag tagot importáljuk Az egész csomagot importáljuk graphics.Rectangle myRect = new graphics.Rectangle(); import graphics.Circle; import graphics.*;

72 Fejlett Programozási Technológiák JAR fájlok Segítségükkel több fájlt egy archívumba pakolhatunk Tipikusan egy alkalmazás class fájlait tartalmazza Az így csomagolt alkalmazás futtatható közvetlenül, appletként, az osztályai hozzáférhetőek Előnyei:  biztonságos  rövid letöltés  tömörítés  hordozhatóság

73 Fejlett Programozási Technológiák JAR fájlok kezelése jar cf jar-file input-file(s) - becsomagolás jar tf jar-file – tartalom megtekintése jar xf jar-file [archived-file(s)] - kicsomagolás java -jar jar-file – futtatás jar uf jar-file input-file(s) – frissítés jarsigner jar-file alias – aláírás jarsigner -verify jar-file - ellesnőrzés

74 Fejlett Programozási Technológiák A következő előadás J2SE 5.0 Tiger újdonságok Hibakezelés Szálak


Letölteni ppt "1 Fejlett Programozási Technikák 2. 15/3. Fejlett Programozási Technológiák 2. 2 A mai előadás tartalma: Java Virtual Machine  Memória kezelés  Szemét."

Hasonló előadás


Google Hirdetések