Milyen hozzáférés módosítók vannak a java-ban. Hozzáférés módosítók

Itt megpróbáljuk lefedni a hozzáférés-módosítók használatának szinte minden esetét. Az egyetlen kivétel a beágyazott ( beágyazott) és belső ( belső) osztályokhoz, valamint a felületekhez, mivel ezekkel a témákkal még nem foglalkoztunk.

A hozzáférés-módosítókkal együtt használt osztályok és csomagok beágyazási eszközként szolgálnak, vagyis egy egyszerű felület mögé rejtik a megvalósítás részleteit.

Hozzáférés módosítók egyaránt alkalmazhatók az osztályokra és azok tagjaira - mezőkre és metódusokra. Összesen négy hozzáférésmódosító van, ezekről itt rövid leírást adunk, majd mindegyiket részletesen megvizsgáljuk.

• nyilvános- bármely komponensként bejelentett nyilvános, bármely kódból elérhető
• védett- hozzáférést tesz lehetővé a csomagon belüli összetevőhöz és annak leszármazott osztályaihoz
• magán- hozzáférést tesz lehetővé az osztályon belüli komponensekhez
• alapértelmezett(nincs kulcsszó) – hozzáférést tesz lehetővé a csomagon belüli összetevőkhöz

Az örökölt osztályok egy osztályból örökölt osztályok. Még nem tanulmányoztuk az öröklődést.

Hozzáférés az osztályokhoz

Alapértelmezés szerint a legfelső szintű osztályok abban a csomagban érhetők el, amelyben meghatározásra kerültek.... Ha azonban a legfelső szintű osztályt a következőképpen deklaráltuk nyilvános akkor mindenhol elérhető (vagy ahol maga a csomag elérhető). Ezt az utasítást a legfelső szintű osztályokra korlátoztuk, mivel az osztályok deklarálhatók más osztályok tagjaiként. Mivel ezek a belső osztályok az osztály tagjai, betartják az osztály tagjaihoz való hozzáférés szabályozására vonatkozó szabályokat..

Hozzáférés az osztály tagjaihoz

Az osztály tagjai mindig elérhetők az osztály törzsében. Alapértelmezett osztály tagjai is elérhetők abban a csomagban, amelyben az osztály definiálva van.

Nyilvános módosító

Egy nem beágyazott osztályhoz a két lehetséges hozzáférési szint közül csak az egyik adható meg: adott alapértelmezettés nyilvános . Amikor az osztályt mint nyilvános, ez legyen az egyetlen nyilvános a fájlban deklarált osztálynak és a fájl nevének meg kell egyeznie az osztály nevével.

Hogyan nyilvános osztályok, mezők, metódusok és konstruktorok deklarálhatók.

Védett módosító

Ezt a módosítót közelebbről megvizsgáljuk az osztályöröklődés témakörében. Ha az öröklődést nem használja, akkor ez a módosító ugyanúgy működik, mint az alapértelmezett módosító.

Az egyetlen dolog, amit most röviden elmondhatunk, az az, hogy a ként deklarált összetevők védett hozzáférése lesz bármely gyerekosztály bármilyen csomagból vagy bármely osztály ugyanabból a csomagból.

Hogyan védett mezők, metódusok, konstruktorok, beágyazott osztályok és beágyazott interfészek deklarálhatók.

védett .

Privát módosító

Ez a leginkább korlátozó módosító a hozzáférés korlátozása szempontjából. A következőként bejelentett tételek magán csak ugyanazon az osztályon belül érhetők el, az osztályon kívül senki számára.

Hogyan magán mezők, metódusok, konstruktorok, beágyazott osztályok és beágyazott interfészek deklarálhatók.

A legfelső szintű osztályok és felületek nem deklarálhatók magán .

A hozzáférés-módosítók alapvetően egy egyszerű téma, de később még visszatérünk rájuk. Míg ez csak egy ismeretség volt. És most egy kis gyakorlás...

Létrehoztam a Mod02.java, DefMod.java, ProMod.java és PrvMod.java osztályokat, amelyek a pro.java.pkg002 csomaghoz tartoznak, valamint a PubMod.java osztályt, amely a pro.java.pkg003 csomaghoz tartozik. Ezután csak képernyőképeket adok ezekről az osztályokról és a program eredményéről:

Szó lesz a módosítókról: mik azok a módosítók, hatókörök, osztályok módosítói, mezők, metódusok. Szerintem nem lesz unalmas.

Módosítók a Java nyelven Olyan kulcsszavak, amelyek bizonyos tulajdonságokat adnak egy osztálynak, osztálymezőnek vagy metódusnak.

Egy osztály metódusai és mezői láthatóságának jelzésére 4 hozzáférés-módosító található:

• magán az osztály tagjai csak az osztályon belül érhetők el;
• csomag privát vagy alapértelmezett (alapértelmezett) osztály tagjai láthatók a csomagon belül;
• védett osztály tagjai a csomagon belül és származtatott osztályokban is elérhetők;
• nyilvános osztály tagjai mindenki számára elérhetőek.

Ha emlékszel, a végén, amikor már importáltuk a Cat osztályt, még mindig volt egy fordítási hiba.

A helyzet az, hogy a mezőinkhez és metódusainkhoz nem regisztráltunk hozzáférésmódosítókat, és ezeknek van egy alapértelmezett tulajdonságuk (az osztálytagok a csomagon belül láthatók). Ahhoz, hogy kijavítsuk a kódunk fordítási hibáját és végre le tudjuk futtatni, publikussá kell tennünk konstruktorunkat és metódusainkat. Ezután más csomagokból is hívhatók.

Elkezdhet gondolkodni: minek ez az egész? Miért nem teszi láthatóvá a kódot bármely csomagból vagy osztályból, de meg kell különböztetni a hozzáférést? Ezek a kérdések maguktól eltűnnek, ha eljön az ideje bonyolult és nehézkes projektek megírásának. Most, amikor olyan alkalmazásokat írunk, amelyek funkcionalitása egy vagy két osztályra korlátozódik, úgy tűnik, nincs értelme valamit korlátozni.

Képzelje el, hogy van egy osztálya, amely egy termékobjektumot jelenít meg. Például egy autó. Az autónak lehet ára. Létrehozott egy ármezőt és sok más mezőt, egy csomó metódust, amelyek felelősek a funkcionalitásért. Minden jónak tűnik. Az Ön osztályú autója egy hatalmas projekt része, és mindenki boldog. De tegyük fel, hogy valaki tévedésből vagy szándékosan példányosította az autóosztályt, és negatív árat szabott meg. Hogyan lehet egy terméknek negatív ára? Ez egy nagyon primitív példa, és nem valószínű, hogy a való életben megtörténik, de szerintem az ötlet egyértelmű. Néha nem közvetlenül, hanem bizonyos módszerekkel kell hozzáférést biztosítania. Előfordulhat, hogy a kód felelős egy másik kód funkcionalitásáért, és Ön nem akarja, hogy valaki módosítsa és szerkessze a saját kódját. Mindehhez hozzáférési korlátozás vonatkozik.

A konstruktoroknak, metódusoknak és mezőknek bármilyen hozzáférésmódosítója lehet. Egy osztály csak nyilvános vagy alapértelmezett lehet, és egy fájlban csak egy nyilvános osztály lehet.

Egyelőre elég lesz a hozzáférés módosítókról. Az "Objektumorientált programozás" cikkben részletesebben fogunk beszélni róluk, de most beszéljünk a többi módosítóról, amelyekről egyébként sok van.

Most a következő módosító statikus... Használható metódus, mező, sőt osztály előtt is, ha beágyazott osztályt szeretnénk deklarálni. Java-ban más osztályokon belül is lehet osztályokat írni, és ha az osztályon belül az osztály előtt álló módosító statikus, akkor az ilyen osztályt beágyazottnak nevezzük, ha van másik módosító vagy alapértelmezés szerint, akkor egy ilyen osztályt belsőnek. A beágyazott és a belső osztályokról külön cikk lesz, mivel ott nem minden olyan egyszerű.

A metódus vagy mező előtti statikus módosító azt jelzi, hogy nem tartoznak ennek az osztálynak egy példányához. Mit jelent ez számunkra? Ha egy osztálymezőt vagy metódust statikusként írtunk le, akkor az osztálypéldány használata nélkül is meghívható. Vagyis e konstrukció helyett: Cat cat = new Cat (); cat.method (), akkor csak írja a Cat.method (). Feltéve, hogy a metódust statikusnak nyilvánították. A statikus változók az osztály minden objektumánál azonosak. Egy linkjük van.

nyilvános osztály módosítók (

static int otherStaticField = 5;

public static void myStaticMethod () (

someField = "Saját mezőm";

// nonStaticField = ""; összeállítási hiba

// nem statikus mezők nem használhatók

// statikus módszerekben

public void myNonStaticMethod () (

otherStaticField = 4; // statikus mezők használhatók

// nem statikus módszerekben

// a fő metódusnak van statikus módosítója is

új Módosítók () .myNonStaticMethod ();

Modificators.myStaticMethod (); // statikus metódusok és mezők meghívása

// az osztálynév.metóduson keresztül

Egy másik fontos dolog, amit meg kell jegyezni a statikus módosítóknál, hogy a statikus mezők inicializálása az osztály betöltési idején történik. A különféle Java-tesztekben gyakran a következő kód található:

Kérdés: mi fog megjelenni a konzolon? Emlékeztetni kell arra, hogy minden forgatókönyvben először a statikus blokk jelenik meg. A következő lesz az alapértelmezett blokk. Ezután nézze meg a konzol képernyőjét:

A következő módosító, amelyet megvizsgálunk, ez lesz végső.

Szerintem a végleges szó önmagáért beszél. A végső módosító alkalmazásával azt mondod, hogy a mezőket nem lehet megváltoztatni, a metódusokat felülírják, az osztályokat pedig nem lehet örökölni (az öröklődésről külön cikk lesz). Ez a módosító csak osztályokra, metódusokra és változókra vonatkozik (a helyi változókra is).

A metódusok és osztályok végső módosítóiról az OOP cikkben fogunk beszélni.

Ezután lesznek olyan módosítók, amelyek nem lesznek túl egyértelműek a kezdőknek vagy azoknak, akik a semmiből olvassák ezt a cikksorozatot. És bár még mindig nem tudok mindent elmagyarázni Önnek (mivel nem ismeri a kísérő anyagot), mégis azt tanácsolom, hogy ismerkedjen meg velük. Amikor eljön az ideje, hogy ezeket a módosítókat használja, máris megérti az alábbiakban használt kifejezések többségét.

Módosító szinkronizált- azt jelzi, hogy a metódust egyszerre csak egy szál használhatja. Noha ez nem mond semmit, ennek a módosítónak a hasznosságát látni fogjuk, amikor megismerjük a többszálú feldolgozást.

Módosító átmeneti- azt mondja, hogy bizonyos mezőket figyelmen kívül kell hagyni az objektum szerializálása során. Ezek a mezők általában köztes értékeket tárolnak.

Módosító illó- többszálú feldolgozáshoz használják. Ha egy változó módosító mezőt több szál használ és módosít, ez a módosító biztosítja, hogy a mező sorra megváltozzon, és ne legyen összetéveszthető vele.

Módosító anyanyelvi mielőtt a metódus deklarációja azt jelzi, hogy a metódus egy másik programozási nyelven íródott. Általában C-ben.

Módosító strictfp- Az IEEE 754 szabvány szerinti lebegőpontos és dupla (lebegőpontos) típusú műveletek elvégzését biztosítja, vagy még egyszerűbben garantálja, hogy egy módszeren belül a számítások eredménye minden platformon azonos lesz.

A módosítóról még nem beszéltem absztrakt... Röviden mesélek róla, mert az objektum-orientált programozás alapjainak ismerete nélkül nem látom értelmét beszélni róla.

Az absztrakt módosítóval rendelkező osztály nem példányosítható. Ennek egyetlen célja a bővítés. Egy absztrakt osztály egyaránt tartalmazhat absztrakt és közönséges metódusokat.

Az absztrakt módosítóról bővebben az OOP cikkben fogunk beszélni.

Ezzel a módosítókról szóló cikk befejeződik. Sok szó nem esett róluk. De ez annak köszönhető, hogy még nincsenek OOP koncepcióink. Néhány cikkben kibővítjük a módosítókat, és kitöltjük az üres helyeket.

Amit az inicializáláskor ad hozzá az értékek megváltoztatásához. A Java nyelv sokféle módosítóval rendelkezik, a főbbek a következők:

• hozzáférés módosítók;
• A hozzáféréshez nem használt osztály-, metódus-, változó- és adatfolyam-módosítók.

Ahhoz, hogy módosítót használhasson a Java nyelven, bele kell foglalnia a kulcsszót egy osztály, metódus vagy változó definíciójába. A módosítónak az utasítás többi része előtt kell lennie, amint az a következő példákban látható:

Nyilvános osztály className (// ...) privát logikai myFlag; statikus utolsó kettős hét = 9,5; védett statikus végső int BOXWIDTH = 42; public static void main (String arguments) (// metódus törzse)

Hozzáférés módosítók

A Java számos hozzáférés-módosítót biztosít az osztályok, változók, metódusok és konstruktorok hozzáférési szintjének beállításához. Négy hozzáférési pont van:

• Látható a csomagban (alapértelmezett és nincs szükség módosításra).
• Csak az osztály számára látható (privát).
• Mindenki számára látható (nyilvános).
• Látható a csomag és az összes alosztály számára (védett).

Az alapértelmezett hozzáférésmódosító nem kulcsszó

Alapértelmezett hozzáférés-módosító- azt jelenti, hogy nem deklarálunk kifejezetten hozzáférés-módosítót a Java-ban egy osztályhoz, mezőhöz, metódushoz stb.

A hozzáférés-vezérlési módosító nélkül deklarált változó vagy metódus ugyanabban a csomagban bármely más osztály számára elérhető. Az interfész mezői implicit módon nyilvánosak, statikusak, véglegesek, az interfész metódusai pedig alapértelmezés szerint nyilvánosak.

Példa

Változók és metódusok deklarálhatók Java-ban minden módosító nélkül, amint az a következő példában látható:

Karakterlánc verzió = "1.5.1"; logikai processOrder () (igaz;)

A privát hozzáférés módosítója

Privát módosító- a Java-ban privátként deklarált metódusok, változók és konstruktorok csak magán a deklarált osztályon belül érhetők el.

A privát hozzáférés módosítója a leginkább korlátozó hozzáférési szint. Az osztály és az interfészek nem lehetnek privátak.

A privátként deklarált változók az osztályon kívül is elérhetők, ha a fogadó nyilvános metódusok jelen vannak az osztályban (lásd alább a példát és a magyarázatot).

A privát módosító használata a Java-ban az adatok elrejtésének fő módja.

Példa

A következő osztály privát hozzáférés-vezérlést használ:

Nyilvános osztály Logger (privát String formátum; public String getFormat () (vissza this.format;) public void setFormat (String formátum) (this.format = formátum;))

Itt változó formátum osztály Logger privát, így más osztályok nem tudják közvetlenül megszerezni és beállítani az értékét.

Ezért, hogy ez a változó mindenki számára elérhető legyen, két nyilvános metódust definiáltunk: getFormat () amely visszaadja az értéket formátum, és setFormat (karakterlánc) amely meghatározza az értékét.

Nyilvános hozzáférés módosító

Nyilvános módosító- osztály, metódus, konstruktor, interfész stb. nyilvánosnak nyilvánított bármely más osztályból elérhető. Ezért a nyilvános osztályon belül deklarált mezők, metódusok, blokkok bármely, a Java univerzumhoz tartozó osztályból elérhetők.

Ha azonban egy nyilvános osztályt egy másik csomagban próbálunk elérni, akkor a nyilvános osztályt importálni kell.

Az osztály öröklődése miatt a Java-ban egy osztály összes nyilvános metódusát és változóját az alosztályai öröklik.

Példa

A következő funkció nyilvános hozzáférés-vezérlést használ:

Nyilvános statikus void main (karakterlánc argumentumok) (// ...)

Módszer fő () nyilvánosnak kell lennie. Ellenkező esetben a java értelmező nem hívhatja meg az osztály futtatására.

Védett hozzáférés módosító

Védett módosító- a szuperosztályban védettnek nyilvánított változókhoz, metódusokhoz és konstruktorokhoz csak egy másik csomag alosztályai vagy egy védett osztálycsomag bármely osztálya férhetnek hozzá.

A Java védett hozzáférés-módosítója nem alkalmazható osztályra és interfészekre. A metódusok és mezők védetté nyilváníthatók, azonban az interfész metódusai és mezői nem deklarálhatók védettnek.

A védett hozzáférés lehetővé teszi az alosztály számára, hogy segédmetódusokat vagy változókat használjon, megakadályozva, hogy egy nem kapcsolódó osztály megpróbálja használni.

Példa

A következő szülőosztály védett hozzáférés-vezérlést használ, így a gyermekosztálya felülírja a metódust openSpeaker ():

Class AudioPlayer (védett logikai openSpeaker (Speaker sp) (// megvalósítás részletei)) osztály StreamingAudioPlayer (logikai openSpeaker (Speaker sp) (// megvalósítás részletei))

Sőt, ha definiálunk egy módszert openSpeaker () védettnek, akkor az AudioPlayeren kívül semmilyen más osztályból nem lesz elérhető. Ha nyilvánosnak definiáljuk, akkor mindenki számára elérhetővé válik. De az a szándékunk, hogy ezt a módszert csak az alosztálynak tegyük ki, ezért használtuk a védett módosítót.

Hozzáférés-szabályozás és öröklési szabályok

A Java következő szabályai érvényesek az örökölt metódusokra:

• A szuperosztályban nyilvánosnak nyilvánított metódusoknak is nyilvánosaknak kell lenniük minden alosztályban.
• A szuperosztályban védettnek nyilvánított módszereknek vagy védettnek kell lenniük, vagy alosztályaikban nyilvánosaknak kell lenniük; nem lehetnek magánszemélyek.
• A magánjellegűnek nyilvánított módszerek nem öröklődnek mindenki számára, ezért nincs rájuk vonatkozó szabály.

A hozzáféréshez nem használt osztály-, metódus-, változó- és adatfolyam-módosítók

A Java számos módosítót biztosít nem a hozzáféréshez, hanem sok más funkció megvalósításához:

• módosító statikus metódusok és osztályváltozók létrehozására szolgál;
• módosító végső osztályok, metódusok és változók megvalósításának befejezésére szolgál;
• módosító absztrakt absztrakt osztályok és metódusok létrehozásához szükséges;
• módosítók szinkronizáltés illó Java-ban használják folyamokhoz.

Statikus módosító

Statikus módosító- metódusok és osztályváltozók létrehozására szolgál.

Statikus változók

A statikus kulcsszó olyan változók létrehozására szolgál, amelyek az osztályhoz létrehozott példányoktól függetlenül léteznek. A Java statikus változójának csak egy példánya létezik, az osztály példányainak számától függetlenül.

A statikus változókat osztályváltozóknak is nevezik. Java nyelven a helyi változók nem deklarálhatók statikusak.

Statikus módszerek

A static kulcsszó olyan metódusok létrehozására szolgál, amelyek az osztályhoz létrehozott példányoktól függetlenül léteznek.

A Java-ban a statikus metódusok vagy statikus metódusok nem használnak egyetlen osztályobjektum példányváltozóját sem, hanem definiálva vannak. A statikus módszerek az összes adatot paraméterekből veszik, és ezen paraméterek egy részét a rendszer változókra való hivatkozás nélkül értékeli ki.

Egy osztály változói és metódusai az osztálynévvel, majd egy ponttal és a változó vagy metódus nevével érhetők el.

Példa

A Java statikus módosítója osztálymetódusok és változók létrehozására szolgál, amint az a következő példában látható:

Nyilvános osztály Példányszámláló (private static int numInstances = 0; védett statikus int getCount () (return numInstances;) private static void addInstance () (numInstances ++;) InstanceCounter () (InstanceCounter.addInstance ();) public static void main ( Karakterlánc argumentumok ) (System.out.println ("Since" + InstanceCounter.getCount () + "példány"); for (int i = 0; i

A következő kimenetet kapod:

0 példánytól kezdve 500 példány jött létre

Végső módosító

Végső módosító- osztályok, metódusok és változók megvalósításának befejezésére szolgál.

Végső változók

Egy végső változó csak egyszer inicializálható. A véglegesnek nyilvánított referenciaváltozó soha nem rendelhető hozzá más objektumra való hivatkozáshoz.

Az objektumon belüli adatok azonban módosíthatók. Így az objektum állapota módosítható, de a referencia nem.

A Java változóinál a végső módosítót gyakran használják a static mellett, hogy egy osztályváltozót konstanssá tegyenek.

Példa

public class Teszt (végső int érték = 10; // Az alábbiakban példák találhatók konstans deklarációkra: public static final int BOXWIDTH = 6; static final String TITLE = "(! LANG: Manager"; public void changeValue(){ value = 12; //будет получена ошибка } } !}

Végső módszerek

A végső metódust egyik alosztály sem bírálhatja felül. Ahogy korábban említettük, a Java-ban a végső módosító megakadályozza, hogy egy metódus megváltozzon az alosztályban.

A módszer véglegessé tételének fő célja az, hogy a módszer tartalma ne változzon oldalra.

Példa

Az osztálydeklaráció utolsó módosítóját használó metódus deklarációja a következő példában látható:

Nyilvános osztály teszt (public final void changeName () (// metódus törzse))

Végső osztály

A végsőként deklarált osztály használatának fő célja a Java-ban az osztály alosztályozásának megakadályozása. Ha egy osztály véglegesnek van megjelölve, akkor egyetlen osztály sem örökölhet funkciót a végső osztálytól.

Példa

nyilvános záró óra Teszt (// osztálytest)

Absztrakt módosító

Absztrakt módosító- absztrakt osztályok és metódusok létrehozására szolgál.

Absztrakt osztály

Az absztrakt osztály nem tud példányosítani. Ha egy osztályt absztraktnak nyilvánítanak, akkor az egyetlen célja a kiterjesztése.

Egy osztály nem lehet egyszerre absztrakt és végleges, mivel egy végső osztály nem bővíthető. Ha az osztály absztrakt metódusokat tartalmaz, akkor azt absztraktnak kell nyilvánítani. Ellenkező esetben fordítási hiba keletkezik.

Egy absztrakt osztály egyaránt tartalmazhat absztrakt és közönséges metódusokat.

Példa

absztrakt osztály Caravan (private double price; private String model; private String year; public abstract void goFast (); // absztrakt metódus public abstract void changeColor ();)

Absztrakt módszer

Az absztrakt metódus bármely implementációval deklarált metódus. A metódus (implementáció) törzsét az alosztály adja. Az absztrakt módszerek soha nem lehetnek véglegesek vagy szigorúak.

Minden absztrakt osztályt kiterjesztő osztálynak meg kell valósítania a szuperosztály összes absztrakt metódusát, kivéve, ha az alosztály egy absztrakt osztály.

Ha egy Java osztály egy vagy több absztrakt metódust tartalmaz, akkor az osztályt absztraktnak kell nyilvánítani. Egy absztrakt osztálynak nem kell absztrakt metódusokat tartalmaznia.

Egy absztrakt módszer pontosvesszővel végződik. Példa: nyilvános absztrakt minta ();

Példa

public abstract class SuperClass (absztrakt void m (); // absztrakt metódus) class SubClass kiterjeszti a SuperClass-t (// megvalósítja az absztrakt metódust void m () (.........))

Szinkronizált módosító

Szinkronizált módosító

A szinkronizált kulcsszó azt jelzi, hogy egy metódust egyszerre csak egy szál érheti el. Java-ban a szinkronizált módosító a négy hozzáférési szint módosító bármelyikével alkalmazható.

Példa

nyilvános szinkronizált érvénytelen showRészletek () (.......)

Átmeneti módosító

Egy tranziensként megjelölt példányváltozó arra utasítja a Java virtuális gépet (JVM), hogy hagyja ki a megadott változót az azt tartalmazó objektum szerializálásakor.

Ez a módosító szerepel az utasításban, amely a változó előző osztályának vagy adattípusának változóját hozza létre.

Példa

nyilvános tranziens int limit = 55; // nem marad fenn public int b; // megmarad

Illékony módosító

Illékony módosító- Java-ban használják folyamokhoz.

A Java-ban az illékony módosító segítségével tudatja a JVM-mel, hogy a változó hozzáférési szálnak mindig össze kell kapcsolnia a változó saját másolatát a memóriában lévő fő másolattal.

Egy illékony változó elérése szinkronizálja a memóriában lévő összes gyorsítótárazott másolt változót. A volatile csak objektum vagy privát típusú példányváltozókra alkalmazható. Az illékony objektum hivatkozás nulla lehet.

Példa

public class MyRunnable implements Runnable (private volatile boolean active; public void run () (aktív = igaz; while (aktív) (// 1. sor // itt valami kód)) public void stop () (aktív = false; / / sor 2))

Általában a run () egy szálon kerül meghívásra (első alkalommal a Runnable in Java-ban), a stop () pedig egy másik szálból. Ha az 1. sor gyorsítótárazott aktív értéket használ, akkor a hurok nem állhat le mindaddig, amíg a 2. sorban be nem állítja az aktív hamis értéket.

A következő leckében a Java nyelvben használt alapvető operátorokat tárgyaljuk. Ez a rész áttekintést nyújt arról, hogyan használhatja ezeket az alkalmazásfejlesztés során.

Lehetőség van szabályozni, hogy a program mely részei érhetik el az osztály tagjait. A hozzáférés-szabályozás segít megelőzni a visszaéléseket. Nem mindig kívánatos egyetlen változóhoz vagy osztálymetódushoz férni, amelynek csak magán az osztályon belül kellene működnie.

A hozzáférés módja meg van határozva hozzáférés módosító, amelyet a deklaráláskor adunk hozzá. Négy van belőlük:

• magán
• nyilvános (nyitva)
• védett
• alapértelmezett hozzáférés, ha nincs jelen módosító

Példák módosító deklarációkra (mindig elsőnek kell lennie):

Nyilvános int i; privát kettős j, k; private int createMethod (int a) (...); nyilvános osztály macska ()

Mint látható, a módosító változóra, metódusra, osztályra alkalmazható.

nyilvános

A kulcsszó használatakor nyilvános tájékoztatja, hogy a következő osztálytag deklaráció mindenki számára elérhető a projekt bármely más kódjáról.

Tegyük fel, hogy az osztály így van deklarálva nyilvános, és két módszere van. Egy magán, második - nyilvános... Hozzáférhet az osztályteremhez és a a második módszerrel, de nem az elsőre, pedig maga az osztály nyitva van.

magán

Kulcsszó magán azt jelenti, hogy egy osztály tagjához nem adnak hozzáférést senki másnak, csak az adott osztály metódusait. Más osztályok ugyanabban a csomagban sem férhetnek hozzá a privát tagokhoz.

Minden osztálysegítő metódust a következőképpen kell deklarálni magán hogy véletlenül ne hívják őket a csomagban. Ugyanez vonatkozik az osztályon belüli privát mezőkre is.

védett

Kulcsszó védett az öröklődés fogalmához kapcsolódik, amelyben egy már meglévő (alap)osztályhoz új tagok kerülnek hozzáadásra, miközben az eredeti megvalósítás változatlan marad. Módosíthatja a már meglévő osztálytagok viselkedését is. Ha új osztályt szeretne létrehozni egy meglévő alapján, használja a kulcsszót kiterjed.

Ha egy új csomag létrehozása egy másik csomagban lévő osztályból származó öröklődést használ, az új osztály csak az eredeti csomag nyilvános tagjaihoz fér hozzá. Néha az alaposztály létrehozójának hozzáférést kell adnia egy adott metódushoz a származtatott osztályoknak, de mindenki más elől be kell zárnia. Ezekben az esetekben a kulcsszót használják védett... A specifikáló védett hozzáférést is biztosít a csomagon belül, pl. Az ezzel a specifikációval rendelkező tagok ugyanabban a csomagban elérhetők más osztályok számára is.

Alapértelmezés szerint, ha nincs jelen módosító, egy osztálytag nyilvánosnak minősül a saját csomagjában, de nem érhető el a csomagon kívüli kódolás számára. Ha a projektben minden osztály ugyanabban a csomagban van, akkor lényegében a módosító nélküli változó publikus ( nyilvános).

Vegyünk egy kitalált osztályt SillySensor

Nyilvános osztály SillySensor (privát int sensorData; nyilvános SillySensor () (sensorData = 0;) privát void kalibrálás (int iSeed) (// kód a kalibrációhoz) védett void seedCalibration (int iSeed) (kalibrálás (iSeed);) public int getSensorData ( ) (// Ellenőrizze az érzékelőt itt adja vissza a sensorData-t;))

Az osztályt a következőképpen deklaráltuk nyilvánosés más osztályokban is elérhető. Az osztálynak van egy változója sensorData, amely csak az osztályában (privát) érhető el. A konstruktor más osztályokban is elérhető ( nyilvános). Módszer kalibrál () csak az osztályon belül működik ( magán). Módszer magkalibrálás () osztályában vagy alosztályában elérhető ( védett). Módszer getSensorData () elérhető más osztályokban ( nyilvános).

Módosító osztály
A Modifier osztály minden módosítót kódol,
típusdeklarációkban használt, űrlapon
állandók:
ABSZTRAKT, VÉGLEGES, INTERFÉSZ, NATÍV,
MAGÁN, VÉDETT, NYILVÁNOS, STATIKUS,
SZIGORÚ, SZIBKRONIZÁLT, TRANZIDENT,
ILLÓ.
Mindegyik konstansnak van egy kérési metódusa az űrlapon
isMod (int módosító) (itt a Mod a fentiek egyike
keresztnevek, például isPublic),
ami igazat ad vissza, ha a módosító
mod szerepel a típusdeklarációban.

Nézzünk egy példát. Legyen
mező nyilatkozat
nyilvános statikus végső int s = 10;
akkor a metódus által visszaadott érték
getModifiers a megfelelő objektumhoz
a Field osztály fog kinézni
Módosító.NYILVÁNOS | Módosító.STATIKUS |
Módosító.FINAL
Bemutatjuk a strictfp módosítót
állandó SZIGORÚ.
Módszerek – Lekérdezések használhatók
következő űrlapot

Modifier.isPrivate (field.getModifiers ());
ez egyenértékű a következő feltétellel
(field.getModifiers () & Modifier.PRIVATE)! = 0
Terep osztály
A Field osztály részeként metódusok valósulnak meg,
amely lehetővé teszi az információ kérését
mezőtípust, valamint olvassa el és állítsa be
jelentése.
Nézzük meg a Field osztály néhány metódusát
1.getType () - osztály objektumot ad vissza
Az aktuális mező típusának megfelelő osztály.
Például egy int típusú mezőre azt kapjuk
int.class.

2. Methods set and get - lehetővé teszi az olvasást
a mező aktuális értékét, és állítson be egy újat is.
Nézzünk egy példát:
public static void printField (O objektum,
String name) dob
NoSuchFieldException,
IllegalAccessException (
Mezőmező = o.getClass () GetField (név);
Rövid érték = (Rövid) mező.get (o);
System.out.println (érték);
}
Azok. a get metódus azt az értéket adja vissza, amellyel
a megfelelő mezőre vagy objektumra utal
osztály - héj.
Egy példa a set módszer használatára így néz ki:

public static void setField (O objektum, Karakterlánc neve,
rövid nv) dobások
NoSuchFieldException,
IllegalAccessException (
Mezőmező = o.getClass () GetField (név);
field.set (o, new Short (nv));
}
Az nv tárolása egy adott objektum mezőjében
wrapper osztályokat kell használnia.
Vannak olyan módszerek is, amelyeknek megvan a formája
getPrimitiveType (mint a getInt) és
setPrimitiveType. Ezek a módszerek képesek
használja az osztály mezőinek megváltoztatására,
amelynek primitív típusa van. Például,
field.setShort (o, nv);

Módszer osztály
A Method osztály eszközei - lehetővé teszik a beszerzést
teljes körű tájékoztatást
egy bizonyos osztály metódus deklarációi,
és hívja be ezeket a módszereket
az adott objektumok kontextusa.
Tekintsük a Method osztály metódusait.
1.public osztály getReturnType () - visszatér
a típusnak megfelelő Class objektumot
az aktuális metódus által visszaadott érték.
Ha a visszatérés helyett írja be:
a metódus deklaráció egy szolgáltatást határoz meg
a szó érvénytelen, a szóban forgó metódus visszatér
void.class objektum.

2.public Class getParameterTypes () - visszatér

a deklarációban megadott paramétereket
a jelenlegi módszer. Az objektumok egy tömbbe kerülnek a címen
a paraméterek felsorolásának sorrendjében
módszer deklaráció. Ha a módszer nem rendelkezik
paramétereket, üres tömböt ad vissza.
3.public Class getExceptionTypes () - visszatér
típusoknak megfelelő Class objektumok tömbje
mondatban meghatározott kivételek
deklarációt dob ​​az aktuális metódusról. Objektumok
abban a sorrendben kerülnek be a tömbbe
a kivételek fajtáinak nevei szerepelnek
módszer deklaráció.

4. nyilvános objektum meghívása (Object onThis, Object args)
IllegalAccessExceptiont dob,
IllegalArgumentException,
InvocationTargetException
Meghívja az aktuális objektum által azonosított metódust
Módszer egy onThis objektum kontextusában hozzárendeléssel
az args tömb által átadott argumentumok értékei.
A nem statikus módszereknél a megvalósítás megválasztása
a tényleges típus alapján hajtják végre
az onThis paraméter által azonosított objektum. Mert
statikus metódusok ezt nem fogadják el
figyelmet, és nulla lehet.
Az args tömb hosszának meg kell egyeznie egy számmal
paramétereket a metódus deklarációjában, és a tömbelemek objektumtípusainak hozzárendelhetőnek kell lenniük
a megfelelő típusú metódusparaméterek - in
különben kivételt dobnak
IIjogi érvKivétel.

10.

Ha a tárgy összetétele meghatározza
onThis, nincs típus, tag
melyik a jelenlegi módszer,
kivételt dobnak
IllegalArgumentException.
Ha onEz nulla, a metódus pedig nem
statikus, típus kivételt dob
NullPointerException.
Ha a meghívott metódus végrehajtása
rendellenesen véget ér, kidobják
az InvocationTargetException típusú kivétel.

11.

Nézzünk egy példát. Hívjunk eszközzel
tükrözési metódus return str.indexOf (".", 8)
akkor van
próbáld ki (
Сlass strClass = str.getClass ();
Method indexM = strClass.getMethod ("indexOf",
new Class (string.class, int.class));
Objektum eredménye = indexM.invoke (str, új objektum (
".", új lnteger (8)));
return ((egész) eredmény) .intValue ();
}
fogás (NoSuchMethodException e) (…… ..)
fogás (invocationTargetException e) (…… ..)
fogás (illegalAccessException e) (……)

12.

Konstruktor osztály
Új példányok (objektumok) létrehozása
típusú módszer használható
a Class objektum újdonsága,
ennek a típusnak felel meg.
A metódus argumentumok nélkül hívja meg a konstruktort,
típushoz tartozó, és referenciát ad vissza
az Object osztály újonnan létrehozott objektumára,
amelyet kifejezetten át kell alakítani
szükséges típus.
Nézzünk egy példát.

13.

statikus kettős tesztAdatok = (0,3, 1,3e-2, 7,9, 3,17);

próbáld ki (
for (int arg = 0; arg< args.length; arg++){
Karakterlánc neve = args;
Class classFor = Class.forName (név);
SortDupla szortírozó =
(SortDouble) classFor.newInstance ();
SortMetrics metrikák = sorter.sort (testData);
System.out.println (név + ":" + metrikák);
for (int i = 0; i< testData.length; i++)
System.out.println ("" + tesztadatok [i]);))
fogás (e kivétel) (System.err.println (e);))

14.

Newlnstance módszer, ha helytelen
alkalmazás képes kidobni nagy
különböző kivételobjektumok száma
típusok.
InstantiationException – ha osztály, objektum
amelyet létre kell hozni, nem rendelkezik
argumentum nélküli konstruktor, ill
absztraktként definiálva, vagy in
valóban egy interfész,
vagy a létrehozási eljárás végrehajtása
az objektum bármely más számára megszakad
okokból.
IllegalAccessException – ha az osztály vagy annak
nem érhető el argumentumkonstruktor.

15.

Biztonsági kivétel – ha érvényes szabályzat
a biztonság tiltja az új objektumok létrehozását
ExceptionInitializerError – Dobott, amikor
az osztály inicializálása.
A többi metódus a Constructor osztályban van definiálva.
nyilvános osztály getParameterTypes ()

a paraméterek típusainak megfelelő
az aktuális konstruktőri nyilatkozatban meghatározott.
nyilvános osztály getExceptionTypes ()
Osztály objektumok tömbjét adja vissza,
a kivételek típusainak megfelelő, hogy
a nyilatkozat throws záradékában beállítva
a jelenlegi kivitelező.

16.

public Object newlnstance (Object args)
InstantiationExceptiont dob,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
Az áram által biztosított konstruktort használja
egy Constructor objektum létrehozásához és inicializálásához
az osztály új példánya, amelyben a konstruktor
jelentette ki, átadva a megadott érveket.
Hivatkozást ad vissza az újonnan létrehozott és
inicializált objektum. Args hossza
meg kell egyeznie a paraméterek számával
egy konstruktor deklarációt, és a tömbelemek objektumtípusainak hozzárendelhetőnek kell lenniük
a megfelelő típusú konstruktor paraméterek -
különben kivételt dobnak
IllegalArgumentException.

17.

Nézzünk egy példát:
osztály Saját osztály (
privát int a;
nyilvános Saját osztály (int k) (a = k;)
nyilvános int függvény (int a, int b) (vissza a + b;)
}
nyilvános osztály Fő (
public static void main (String args) (
próbáld ki (
String name = "Saját osztály";
Class mycl = Class.forName (név);
d osztály = (int.osztály);
Constructor c = mycl.getConstructor (d);
Myclass ob = (Myclass) c.newInstance (új objektum (
új egész szám (10)));
System.out.println (ob.func (3,5)); )
fogás (e kivétel) ();
}}

18.

AccessibleObject osztály
A Field, Constructor és Method osztályok
az AccessibleObject osztályból származik,
amely lehetővé teszi annak megoldását ill
tiltsa meg a szintfeljáró táblák ellenőrzését
olyan nyelveken, mint a nyilvános és a privát.
Az AccessibleObject osztálynak vannak metódusai
1.public void setAccessible (boolean flag)
Beállítja az objektum hozzáférési jelzőt
az érv értéke szerint: igaz
azt jelenti, hogy a tárgy már nem engedelmeskedik
szinten meghatározott hozzáférési szabályok
nyelv (és mindig elérhető lesz), hamis
kényszeríti a tárgyat az adott fenntartására
hozzáférési szint.
Ha a jogosultság megváltoztatni a hozzáférési jelzőt
nem elég, típus kivételt dobnak
Biztonsági kivétel

19.

2.nyilvános statikus
void setAccessible (AccessibleObject tömb,
logikai zászló)
Lehetővé teszi a hozzáférési jelző beállítását
tömbként átadott objektumok.
Ha a feldolgozás során a következő
Az objektum típus kivételt dob
SecurityException objektumok találhatók
a korábbi tömbben tárolja az újonnan beállított
hozzáférési szint értékek és minden más
az objektumok ugyanabban az állapotban maradnak.
3.public logikai isAccessible ()
A hozzáférési jelző aktuális értékét adja vissza
a tárgyhoz

20.

Tömb osztály
A tömbosztályt egy tömb létrehozására használják
reflexió segítségével.
A tömbök létrehozására használt módszernek két formája van
újPéldány.
public Object newlnstance (Class compType, int long)
Hivatkozást ad vissza egy új, compType típusú tömbre
adott hossz hossz.
public Object new Instance (Class compType, int dim)
Hivatkozást ad vissza egy új típusú többdimenziós tömbre
compType, amelynek méreteit értékek adják meg
a paramétertömb elemei dim.
Ha a dim üres vagy hosszabb, mint
megengedett méretek száma (általában 255),

llegalArgumentException.

21.

Nézzünk néhány példát.
1. példa Alkossunk egy byte típusú tömböt
bájt ba = (byte)
Array.newlnstance (byte.class, 13);
Ez ugyanaz, mint
bájt ba = új bájt;
2. példa
int dims = (4, 4);
dupla mátrix = (kettős)
Array.newlnstance (double.class, dims);
Ez ugyanaz, mint
kettős mátrix = új kettős;

22.

Az Array osztály get and set metódusokkal rendelkezik.
Legyen adott egy xa tömb int típusú értékekből; azután
Az xa [i] kifejezés megegyezik:
Egész n = Array.get (xa, i)
A tömbelemhez a következőképpen rendelhet értéket:
xa [i] = 23; ugyanaz mint
Array.set (xa, i, new Integer (23));
Csomag osztály
A Class osztály getPackage metódusának meghívása lehetővé teszi
kapja meg a Package osztályú objektumot
-t tartalmazó csomag leírása
osztály (maga a Package osztály a csomagban található
java.lang).
A Package objektum getName () metódusa tér vissza
az aktuális csomag teljes neve.

23.

Proxy osztály
A Proxy osztály lehetővé teszi a dinamikus létrehozást
osztályok, amelyek egyet vagy többet valósítanak meg
interfészek.
Tegyük fel, hogy van egy A osztály,
egyes interfészek megvalósítása.
Java gép futás közben lehet
proxy osztályt generál az adott számára
A osztályú, azaz egy osztály, ami
Az összes A osztály interfészt megvalósítja, de
felváltja ezek összes metódusának meghívását
interfészek az invoke metódus meghívásához,
az InvocationHandler felület, a
amellyel meghatározhatja a sajátját
végrehajtás.

24.

Proxyosztályt hoz létre metódushívás segítségével
Proxy.getProxyClass, amely elfogadja a ClassLoader és
interfészek tömbjét, és egy objektumot ad vissza
class java.lang.Class amely betöltve van
a ClassLoaderben átadott, és az átadott tömbben valósítja meg
interfészek.
A továbbított paraméterekre számos korlátozás vonatkozik:
1. Az interfész tömbben lévő összes objektumnak olyannak kell lennie
interfészek. Nem lehetnek osztályok ill
primitívek.
2. Az interfész tömb nem tartalmazhat két egyformát
tárgyakat.
3. Az interfészek tömbben lévő összes interfésznek olyannak kell lennie
a metódusnak átadott ClassLoader tölti be
getProxyClass.
4. Minden nem nyilvános interfészt meg kell határozni
ugyanabban a csomagban, egyébként a generált proxy osztály
nem lesz képes mindegyiket végrehajtani.

25.

5. Két interfész nem tartalmazhat
módszer azonos nevű és
paraméter aláírása, de eltérő
visszaküldési típusok.
6. Az interfészek tömb hossza korlátozott
65535 interfészek. Nincs Java osztály
nem valósítható meg 65535-nél többet
interfészek.

26.

Dinamikus proxy osztály tulajdonságai
1. A proxy osztály nyilvános, feltéve
végleges és nem elvont.
2. Az alapértelmezett proxyosztálynév nem
meghatározva, de a Proxy-nál kezdődik. Minden
Proxy karakterrel kezdődő névtér
proxy osztályok számára fenntartva
(A Java legújabb verzióiban erre nincs szükség.)
3. A proxy osztály innen örökli
java.lang.reflect.Proxy.
4. A proxy osztály minden interfészt megvalósít,
átadáskor, az átadás sorrendjében.

27.

5. Ha a proxy osztály nem nyilvános
felületet, akkor ugyanabban a csomagban generálódik
amelyben ez a nagyon nem nyilvános
felület. Általában olyan csomag, amelyben
a proxy osztály definiálatlanul jön létre.
6. A Proxy.isProxyClass metódus true értéket ad vissza ehhez
-val létrehozott osztályok
Proxy.getProxyClass és objektumosztályok esetén
a Proxy.newProxyInstance és
hamis egyébként.
Ezt a módszert használja az alrendszer
Java biztonság, és ezt meg kell értened
az imént örökölt osztály
java.lang.reflect.Proxy hamis értéket ad vissza.

28.

A proxy osztály létrehozott példányának tulajdonságai a következők:
1. A proxy osztály objektuma minden interfészre leadásra kerül,
át az interfész tömbben. Ha az IDemo az egyik
az átadott interfészek közül, majd a művelet proxypéldányát
Az IDemo mindig igazat és az (IDemo) proxy műveletet adja vissza
helyesen fog teljesülni.
2. Statikus metódus Proxy.getInvocationHandler
visszaadja a létrehozáskor átadott híváskezelőt
a proxy osztály egy példánya. Ha átkerül az adotthoz
A metódusobjektum tehát nem egy proxyosztály példánya
egy IllegalArgumentException kivétel kerül kidobásra.
3. A híváskezelő osztály valósítja meg az interfészt
InvocationHandler, amelyben az invoke metódus definiálva van,
a következő aláírással:
nyilvános objektum meghívása (Object proxy, Method metódus,
Tárgy args) dobja Dobható

29.

Nézzünk egy példát:
csomag javaapplication3;
felület fiók (
dupla getBalance ();
érvénytelen változásEgyenleg (int összeg);
üres százalékok (dupla per);)
osztály Saját fiók valósítja meg a fiókot (
privát kettős mérleg;
nyilvános Saját fiók () (egyenleg = 0,0;)
nyilvános dupla getBalance () (visszatérő egyenleg;)
public void changeEgyenleg (int. összeg) (
egyenleg + = összeg;)
nyilvános üres százalék (dupla per) (
egyenleg + = egyenleg * / 100; ); )

30.

osztályú MyAccountProxy implementációk
InvocationHandler (
privát számla ac;
nyilvános MyAccountProxy (Account Acc) (ac = acc;)
nyilvános statikus számla új példány (da számla) (
return (Account) Proxy.newProxyInstance (
da.getClass (). getClassLoader (),
da.getClass (). getInterfaces (),
új MyAccountProxy (da));
}

31.

nyilvános objektum meghívása (Object proxy,
Metódus módszer, objektum args)
dobható (
if (method.getName () == "százalék") (
double d = ((Dupla) args) .doubleValue ();
ha (d<0) d=0;
ha (d> 30) d = 30;
args = new Double (d);

más (
return method.invoke (ac, args); )
}
}

32.

nyilvános osztály Fő (
public static void main (String args) (
Saját fiók ma = új Saját fiók ();
fiók
a = (Fiók) MyAccountProxy.newPéldány (ma);
a.changeBalance (150);

a. százalék (20);
System.out.println (a.getBalance ());
a. százalék (35);
System.out.println (a.getBalance ());))

33.

Osztályok betöltése
A futásidejű rendszer a következőképpen tölti be az osztályokat
az irántuk való igény megjelenése.
A rendszerindítási eljárások funkcionális jellemzői
osztályok alapvetően attól függnek
Java virtuális gépek implementációi, de in
a legtöbb esetben osztályokat találni,
az alkalmazás megcímezte, de nem töltötte be
a végrehajtó rendszer a mechanizmust alkalmazza
nézze meg az osztály keresési útvonalát.
Olyan alkalmazás létrehozásához, amely képes
más módon töltse be az osztályokat, mint
alapértelmezés szerint meg kell adnia
használja a ClassLoader osztály objektumát,
képes megszerezni a bájtkódot a kívánt megvalósításához
osztályt, és töltse be a futási környezetbe
rendszerek.

34.

A ClassLoader osztály egy absztrakt osztály.
Saját osztálybetöltő létrehozásához,
olyan osztályt kell létrehozni, amelyből öröklődik
ClassLoader és felülírási módszer
védett osztály findClass (String név) dob
ClassNotFoundException
Ami megkeresi az adott osztály bájtkódját
nevű nevet, és betölti az adatokat a környezetbe
a virtuális gép egy Class objektum visszaadásával,
a talált osztályt képviselve.
A betöltő objektum képes delegálni
jogosultság betölteni az osztályokat a "szülőhöz"
a szülő osztály betöltő.
A "szülő" osztálybetöltő lehet
argumentumként megadva az osztálykonstruktornak
ClassLoader.

35.

védett osztálybetöltő ()
Implicit módon létrehoz egy ClassLoader objektumot
"szülőként" használva
classloader rendszerbetöltő
(amit beszerezhet
hívja meg a getSystemClassLoader metódust).
védett ClassLoader (ClassLoader szülő)
segítségével létrehoz egy ClassLoader objektumot
a megadott "szülő" osztálybetöltő.
A ClassLoader osztály fő része
a loadClass módszer

36.

public Сlass loadClass (karakterlánc neve) dob
ClassNotFoundException
az adott osztályhoz tartozó Class objektumot adja vissza
nevet, és opcionálisan betölti ezt
Osztály. Ha az osztály nem tölthető be,
típus kivételét dobják
ClassNotFoundException.
A metódus által kínált osztálybetöltési séma
A loadClass az alapértelmezett, és általában nem
felülírva így néz ki:
1.ellenőrzés metódus hívásával
findLoadedClass of class ClassLoader, nem
hogy a megadott osztály korábban betöltődött-e; részeként
A ClassLoader objektumtáblázatot biztosít
Osztály az összes eszközzel betöltött osztályhoz
az aktuális osztálybetöltő; ha az osztály volt
korábban betöltve, findLoadedClass metódus
hivatkozást ad vissza egy meglévő osztály objektumra;

37.

2.ha az osztály nem lett betöltve, akkor meghívásra kerül
loadClass a "szülő" betöltő
osztályok; ha az aktuális rendszerbetöltő nem
"szülővel" rendelkezik, használatos
rendszerosztály betöltő;
3. ha az osztály még mindig nincs betöltve,
a findClass metódust csinálásnak nevezzük
osztály keresése és betöltése.
Ezért szükséges a végrehajtás
a következő módszerek natív verziói
Osztálybetöltő:

38.

védett szinkronizált osztály
loadClass (karakterlánc neve, logikai feloldás)

védett osztály findClass (karakterlánc neve)
ClassNotFoundExceptiont dob
védett java.net.URL forrás keresése (karakterlánc neve)
védett java.util.Enumeration
A findResources (karakterlánc neve) IOExceptiont dob
(A ClassLoader absztrakt osztály képviseli
csak a loadClass metódus megvalósítása alapján
védett módszerekről - findLoadedClass és findClass).

39.

Nézzünk egy példát.
class PlayerLoader kiterjeszti a ClassLoader (
public Class findClass (String név) dob
ClassNotFoundException (
próbáld ki (
byte buf = bytesForClass (név);
return defineClass (név, buf, 0, buf.length);
}
fogás (IOKivétel e) (
dob új ClassNotFoundException (e.toString ());
}
}
// ... Metódus deklarációk bytesForClass és mások
mód
}

40.

A findClass módszer általában kettőt tesz
funkciókat.
Először is észlelnie kell a bájtkódot
az adott osztályból, és tárolja egy tömbben
byte típusú - ez a kötelezettség a példában
a bytesForСlass metódushoz van rendelve.
Másodszor, az alkalmazott módszert használja
defineСlass a tényleges végrehajtásához
a bájtkód által meghatározott osztály betöltése.
A defineСlass metódusnak van formája

41.

védett végső osztály defineClass (karakterlánc neve,
bájt adat, int offset, int hosszúság) dob
ClassFormatError
A megadott nevű osztály Class objektumát adja vissza
név; az osztály bináris reprezentációja átadásra kerül
tömb adatként.
Csak bájtokat használnak az osztály betöltésére,
az adattömb indexekkel ellátott elemei tartalmazzák
offset to offset + hossz. Ha bájt a megadotttól
rés nem egyezik a szükséges formátummal
osztályleírás, a kivétel objektum dobásra kerül
ClassFormatError típusú.
A metódus felelős az objektumra való hivatkozás fenntartásáért
Osztály betöltött osztályhoz a betöltött táblában
a findLoadedClass metódussal megtekintett osztályok.

42.

Tekintsük a bytesForClass metódust.
Protected byte bytesForClass (String name) dob
lOException, ClassNotFoundException (
FileInputStream in = null;
próbáld ki (


if (hossz == 0) dob új ClassNotFoundException (név);
bájt buf = új bájt;

return buf;
}
végül (
if (in! = null) in.close ();
}
}

43.

Így a teljes kód így néz ki:
import java.lang.reflect *;
import java.io. *;
class MyClassLoader kiterjeszti a ClassLoader (
nyilvános osztályfindClass (String név) dob
ClassNotFoundException (
byte buf = ReadFromBuffer (név);
if (név.egyenlő ("Sajátfelület1")) (

) else if (buf == null) (
return findSystemClass (név);
) más (
return defineClass (név, buf, 0, buf.length);
}
}

44.

védett bájt ReadFromBuffer (String név) dob
ClassNotFoundException (
FileInputStream in = null;
próbáld ki (
in = new FileInputStream (név + ".osztály");
int hossz = in.elérhető (); // elérhető bájtok száma
ha (hossz == 0) dobás
új ClassNotFoundException (név);
bájt buf = új bájt;
in.read (buf); // Olvasási bájtok
return buf;
}
elfogás (FileNotFoundException e) (null visszaadás;)
elfogás (IOException e) (null visszaadás;)
végül (
try (if (in! = null) in.close ();)
fogás (IOKivétel e) ()
}
}

45.

védett szinkronizált osztály
loadClass (String név, logikai feloldás) dob
ClassNotFoundException (
Osztály eredménye = findClass (név);
if (felold) solveClass (eredmény);
visszatérési eredmény;
}
}

46.

nyilvános osztály Main1 (
public static void main (String args) (
próbáld ki (
String name = "Saját osztály";
ClassLoader ld = új MyClassLoader ();
Class cl = Class.forName (név, igaz, ld);
Konstruktor s = cl.getConstructor (int.osztály);
Saját felület 1
ob = (Sajátfelület1) s.newInstance (
új Egész szám (8));
System.out.println (ob.func (3,5));
) fogás (e kivétel) ();
}
}

47.

nyilvános felület MyInterface1 (
public int func (int a, int b);
}
public class A Myclass megvalósítja a MyInterface1 (
privát int a;
nyilvános Saját osztály (int k) (a = k;)
nyilvános int függvény (int a, int b) (vissza a + b;)