Ce modificatori de acces există în java. Modificatori de acces

Aici vom încerca să acoperim aproape toate cazurile de utilizare a modificatorilor de acces. Singurele excepții sunt utilizarea lor pentru imbricate ( cuibărit) și intern ( interior), precum și pentru interfețe, deoarece nu am luat încă în considerare aceste subiecte.

Clasele și pachetele utilizate împreună cu modificatorii de acces servesc drept mijloace de încapsulare, adică un mijloc de a ascunde detaliile implementării în spatele unei interfețe simple.

Modificatorii de acces pot fi aplicați atât claselor, cât și membrilor acestora - câmpuri și metode. În total, există patru modificatori de acces și aici vom face o scurtă descriere a acestora, apoi îi vom lua în considerare în detaliu.

• public- orice componentă declarată ca public, accesibil din orice cod
• protejat- permite accesul la componentă în cadrul pachetului și al claselor de descendenți
• privat- permite accesul la componentele din clasă
• Mod implicit(fără cuvânt cheie) - permite accesul la componentele din pachet

Clasele moștenite sunt clase moștenite dintr-o clasă. Nu am studiat încă moștenirea.

Acces la cursuri

În mod implicit, clasele de nivel superior sunt disponibile în pachetul în care sunt definite.... Cu toate acestea, dacă clasa de nivel superior este declarată ca public apoi este disponibil peste tot (sau oriunde pachetul în sine este disponibil). Am limitat această afirmație la clase de nivel superior, deoarece clasele pot fi declarate ca membri ai altor clase. Deoarece aceste clase interioare sunt membre ale clasei, ele respectă regulile de control al accesului la membrii clasei..

Accesarea membrilor clasei

Membrii clasei sunt întotdeauna disponibili în interiorul corpului clasei. Mod implicit membrii clasei sunt disponibili și în pachetul în care este definită clasa.

Modificator public

Pentru o clasă care nu este imbricată, poate fi specificat doar unul din cele două niveluri de acces posibile: dat Mod implicitși public . Când clasa este declarată ca public, ar trebui să fie singurul public clasa declarată în fișier și numele fișierului trebuie să se potrivească cu numele clasei.

Cum public pot fi declarate clase, câmpuri, metode și constructori.

Modificator protejat

Vom arunca o privire mai atentă asupra acestui modificator în subiectul moștenirii clasei. Dacă moștenirea nu este utilizată, atunci acest modificator funcționează la fel ca modificatorul implicit.

Singurul lucru care poate fi spus pe scurt acum este că componentele declarate ca protejat va avea acces orice clasă de copii din orice pachet sau orice clasă din același pachet.

Cum protejat pot fi declarate câmpuri, metode, constructori, clase imbricate și interfețe imbricate.

protejat .

Modificator privat

Acesta este cel mai restrictiv modificator în ceea ce privește restricția de acces. Articole declarate ca privat sunt accesibile numai în cadrul aceleiași clase și nimănui din afara clasei.

Cum privat pot fi declarate câmpuri, metode, constructori, clase imbricate și interfețe imbricate.

Clasele și interfețele de nivel superior nu pot fi declarate ca fiind privat .

Practic, modificatorii de acces sunt un subiect simplu, dar vom reveni la ei mai târziu. În timp ce era doar o cunoștință. Și acum o mică practică ...

Am creat clasele Mod02.java, DefMod.java, ProMod.java și PrvMod.java care aparțin pachetului pro.java.pkg002, precum și clasa PubMod.java, care aparține pachetului pro.java.pkg003. Apoi, voi oferi doar capturi de ecran ale acestor clase și rezultatul programului:

Vom vorbi despre modificatori: ce sunt modificatori, scopuri, modificatori pentru clase, câmpuri, metode. Cred că nu va fi plictisitor.

Modificatori în Java Sunt cuvinte cheie care oferă o clasă, un câmp de clasă sau o metodă anumite proprietăți.

Pentru a indica vizibilitatea unei clase a metodelor și câmpurilor sale, există 4 modificatori de acces:

• privat membrii clasei sunt accesibile numai în cadrul clasei;
• package-private sau implicit (implicit) membrii clasei sunt vizibili în interiorul pachetului;
• protejat membrii clasei sunt disponibili în cadrul pachetului și în clase derivate;
• public membrii clasei sunt disponibili tuturor.

Dacă vă amintiți, la final, când am importat deja clasa Cat, am avut încă o eroare de compilare.

Lucrul este că nu am înregistrat niciun modificator de acces la câmpurile și metodele noastre și au o proprietate implicită (membrii clasei sunt vizibili în pachet). Pentru a remedia eroarea de compilare pentru codul nostru și pentru a-l rula în cele din urmă, trebuie să ne facem publice constructorul și metodele. Apoi pot fi apelate din alte pachete.

S-ar putea să începi să te întrebi: la ce servește toate acestea? De ce nu faceți codul vizibil din orice pachet sau clasă, dar trebuie să diferențiați accesul? Aceste întrebări vor dispărea singure când va veni momentul să scriem proiecte complexe și greoaie. Acum, când scriem aplicații a căror funcționalitate este limitată la una sau două clase, se pare că nu are sens să limităm ceva.

Imaginați-vă că aveți o clasă care afișează un obiect de produs. De exemplu o mașină. Mașina poate avea un preț. Ați creat un câmp de preț și multe alte câmpuri, o grămadă de metode care sunt responsabile pentru funcționalitate. Totul pare a fi bun. Mașina dvs. de clasă face parte dintr-un proiect uriaș și toată lumea este fericită. Dar să spunem că cineva, din greșeală sau intenționat, a instanțiat clasa de mașini și a stabilit un preț negativ. Cum poate un produs să aibă un preț negativ? Acesta este un exemplu foarte primitiv și este puțin probabil să se întâmple în viața reală, dar cred că ideea este clară. Uneori trebuie să oferiți acces nu direct, ci prin anumite metode. Este posibil ca codul să fie responsabil pentru funcționalitatea altor coduri și să nu doriți ca cineva să schimbe și să editeze o parte a dvs. Pentru toate acestea, există o restricție de acces.

Constructorii, metodele și câmpurile pot avea orice modificator de acces. O clasă poate fi publică sau implicită și poate fi o singură clasă publică într-un singur fișier.

Deocamdată, vor fi destui despre modificatorii de acces. În articolul „Programare orientată pe obiecte” vom vorbi despre ele mai detaliat, dar acum să vorbim despre alți modificatori dintre care, apropo, există o mulțime.

Acum următorul modificator este static... Poate fi folosit în fața unei metode, câmpuri și chiar a unei clase atunci când vrem să declarăm o clasă imbricată. În Java, puteți scrie clase în alte clase și, dacă modificatorul dinaintea clasei din clasă este static, atunci o astfel de clasă se numește imbricată, dacă există un alt modificator sau implicit, atunci o astfel de clasă se numește internă. Va exista un articol separat despre clasele imbricate și interioare, deoarece totul nu este atât de simplu acolo.

Modificatorul static din fața unei metode sau câmpuri indică faptul că nu aparțin unei instanțe din această clasă. Ce înseamnă acest lucru pentru noi? Când am descris un câmp sau o metodă de clasă ca fiind static, acesta poate fi apelat fără a utiliza o instanță a clasei. Adică, în locul acestei construcții: Pisică pisică = Pisică nouă (); cat.method (), puteți scrie doar Cat.method (). Cu condiția ca metoda să fie declarată statică. Variabilele statice sunt aceleași pentru toate obiectele clasei. Au un singur link.

modificatori de clasă publică (

static int anotherStaticField = 5;

public static void myStaticMethod () (

someField = "Câmpul meu";

// nonStaticField = ""; eroare de compilare

// câmpurile nestatice nu pot fi utilizate

// în metode statice

public void myNonStaticMethod () (

anotherStaticField = 4; // pot fi folosite câmpuri statice

// în metode nestatice

// metoda principală are și un modificator static

new Modificators () .myNonStaticMethod ();

Modificators.myStaticMethod (); // apelează metode și câmpuri statice

// prin classname.method

Un alt lucru important de remarcat despre modificatorii statici este că câmpurile statice sunt inițializate la timpul de încărcare a clasei. Adesea, în diferite tipuri de teste Java, puteți găsi următorul cod:

Întrebare: ce va fi afișat pe consolă? Trebuie amintit că blocul static va fi afișat mai întâi în orice scenariu. Următorul va fi blocul implicit. Apoi, uită-te la ecranul consolei:

Următorul modificator pe care îl vom analiza va fi final.

Cred că cuvântul final vorbește de la sine. Prin aplicarea modificatorului final, spuneți că câmpurile nu pot fi modificate, metodele sunt suprascrise și clasele nu pot fi moștenite (va exista un articol separat despre moștenire). Acest modificator se aplică doar claselor, metodelor și variabilelor (de asemenea, variabilelor locale).

Vom vorbi despre modificatorul final la metode și clase în articolul OOP.

În continuare, vor exista modificatori care nu vor fi foarte clari pentru începători sau pentru cei care citesc de la zero această serie de articole. Și, deși încă nu vă pot explica totul (datorită faptului că nu cunoașteți materialul însoțitor), vă sfătuiesc totuși să vă familiarizați cu ele. Când vine timpul să utilizați acești modificatori, veți înțelege deja majoritatea termenilor folosiți mai jos.

Modificator sincronizat- indică faptul că metoda poate fi utilizată de un singur fir la un moment dat. Deși este posibil ca acest lucru să nu vă spună nimic, utilitatea acestui modificator va fi văzută pe măsură ce aflăm despre multithreading.

Modificator tranzitoriu- spune că unele câmpuri ar trebui ignorate în timpul serializării obiectelor. De obicei, aceste câmpuri stochează valori intermediare.

Modificator volatil- folosit la multi-threading. Când un câmp cu modificatorul volatil va fi utilizat și schimbat de mai multe fire, acest modificator asigură că câmpul se va schimba la rândul său și nu va exista confuzie cu acesta.

Modificator nativînainte ca declarația metodei să indice că metoda este scrisă într-un alt limbaj de programare. De obicei în C.

Modificator strictfp- Oferă performanța operațiunilor pe numere de tip float și dublu (virgulă mobilă) în conformitate cu standardul IEEE 754. Sau, mai simplu, garantează că în cadrul unei metode rezultatele calculelor vor fi aceleași pe toate platformele.

Nu am vorbit încă despre modificator abstract... Vă voi spune despre asta pe scurt, pentru că, fără cunoștința elementelor de bază ale programării orientate pe obiecte, nu am rost să vorbesc despre asta.

O clasă care are modificatorul abstract nu poate fi instanțiată. Singurul scop pentru aceasta este extinderea. O clasă abstractă poate conține atât metode abstracte, cât și metode obișnuite.

Vom vorbi mai multe despre modificatorul abstract în articolul OOP.

Aceasta încheie articolul despre modificatori. Nu s-au spus multe despre ele. Dar acest lucru se datorează faptului că nu avem încă concepte OOP. În câteva alte articole, vom adăuga cunoștințe despre modificatori și vom completa spațiile libere.

Pe care îl adăugați la inițializare pentru a modifica valorile. Limbajul Java are o gamă largă de modificatori, principalele sunt:

• modificatori de acces;
• modificatori de clasă, metodă, variabilă și flux care nu sunt folosiți pentru acces.

Pentru a utiliza un modificator în Java, trebuie să includeți cuvântul cheie al acestuia în definiția unei clase, metode sau variabile. Modificatorul trebuie să fie în fața restului instrucțiunii, așa cum se arată în următoarele exemple:

Clasa publică className (// ...) private boolean myFlag; săptămâni duble finale statice = 9,5; static static int intins BOXWIDTH = 42; public static void main (String arguments) (// corpul metodei)

Modificatori de acces

Java oferă o serie de modificatori de acces pentru a seta nivelurile de acces pentru clase, variabile, metode și constructori. Există patru puncte de acces:

• Vizibil în pachet (implicit și nu este necesar modificator).
• Vizibil numai pentru clasă (privat).
• Vizibil pentru toți (public).
• Vizibil pentru pachet și toate subclasele (protejate).

Modificatorul de acces implicit nu este un cuvânt cheie

Modificator de acces implicit- înseamnă că nu declarăm în mod explicit un modificator de acces în Java pentru o clasă, câmp, metodă etc.

O variabilă sau o metodă declarată fără un modificator de control al accesului este disponibilă oricărei alte clase din același pachet. Câmpurile dintr-o interfață sunt implicit publice, statice, finale, iar metodele dintr-o interfață sunt publice în mod implicit.

Exemplu

Variabilele și metodele pot fi declarate în Java fără modificatori, așa cum se arată în următorul exemplu:

Versiunea șir = "1.5.1"; boolean processOrder () (return true;)

Modificatorul de acces privat

Modificator privat- metodele, variabilele și constructorii care sunt declarați private în Java pot fi accesate numai în cadrul clasei declarate.

Modificatorul de acces privat este cel mai restrictiv nivel de acces. Clasa și interfețele nu pot fi private.

Variabilele declarate private pot fi accesate în afara clasei dacă metodele publice primitoare sunt prezente în clasă (a se vedea mai jos un exemplu și o explicație).

Utilizarea modificatorului privat în Java este principala modalitate de a ascunde datele.

Exemplu

Următoarea clasă folosește controlul accesului privat:

Public class Logger (format de șir privat; șir public getFormat () (returnează this.format;) public void setFormat (format de șir) (this.format = format;))

Aici variabilă format clasă Logger este privat, deci nu există nicio modalitate prin care alte clase să obțină și să își stabilească valoarea direct.

Astfel, pentru a pune această variabilă la dispoziția tuturor, am definit două metode publice: getFormat () care returnează valoarea format, și setFormat (String) care își stabilește valoarea.

Modificator de acces public

Modificator public- clasă, metodă, constructor, interfață etc. public declarat poate fi accesat din orice altă clasă. Prin urmare, câmpurile, metodele, blocurile declarate în interiorul unei clase publice pot fi accesate din orice clasă aparținând universului Java.

Cu toate acestea, dacă încercăm să accesăm o clasă publică într-un alt pachet, atunci clasa publică trebuie importată.

Datorită moștenirii clasei, în Java toate metodele și variabilele publice ale unei clase sunt moștenite de subclasele sale.

Exemplu

Următoarea funcție utilizează controlul accesului public:

Public static main main (String arguments) (// ...)

Metodă main () trebuie să fie public. În caz contrar, nu poate fi apelat de către interpretul Java pentru a rula clasa.

Modificator de acces protejat

Modificator protejat- variabilele, metodele și constructorii care sunt declarați protejați într-o superclasă pot fi accesate numai de subclasele dintr-un alt pachet sau pentru orice clasă dintr-un pachet de clase protejate.

Modificatorul de acces protejat din Java nu poate fi aplicat clasei și interfețelor. Metodele și câmpurile pot fi declarate protejate, totuși metodele și câmpurile dintr-o interfață nu pot fi declarate protejate.

Accesul protejat oferă unei subclase posibilitatea de a utiliza o metodă sau o variabilă de ajutor, împiedicând o clasă fără legătură să încerce să o folosească.

Exemplu

Următoarea clasă părinte folosește controale de acces protejate, astfel încât clasa sa copil să suprascrie metoda openSpeaker ():

Clasa AudioPlayer (openSpeaker boolean protejat (Speaker sp) (// detalii implementare)) clasa StreamingAudioPlayer (openSpeaker boolean (Speaker sp) (// detalii implementare))

Mai mult, dacă definim o metodă openSpeaker () așa cum este protejat, atunci acesta nu va fi accesibil din alte clase decât AudioPlayer. Dacă îl definim ca fiind public, atunci acesta va deveni disponibil pentru toată lumea. Dar intenția noastră este să expunem această metodă numai subclasei, motiv pentru care am folosit modificatorul protejat.

Controlul accesului și reguli de moștenire

Următoarele reguli în Java se aplică metodelor moștenite:

• Metodele declarate publice într-o superclasă trebuie să fie publice și în toate subclasele.
• Metodele care sunt declarate protejate într-o superclasă trebuie fie protejate, fie publice în subclasele lor; nu pot fi private.
• Metodele declarate private nu sunt moștenite pentru toată lumea, deci nu există nicio regulă pentru acestea.

Modificatori de clasă, metodă, variabilă și flux care nu sunt folosiți pentru acces

Java oferă o serie de modificatori nu pentru acces, ci pentru implementarea multor alte funcționalități:

• modificator static folosit pentru a crea metode și variabile de clasă;
• modificator final utilizate pentru a finaliza implementarea claselor, metodelor și variabilelor;
• modificator abstract necesare pentru crearea de clase și metode abstracte;
• modificatori sincronizatși volatil folosit în Java pentru fluxuri.

Modificator static

Modificator static- folosit pentru a crea metode și variabile de clasă.

Variabile statice

Cuvântul cheie static este utilizat pentru a crea variabile care vor exista independent de orice instanțe create pentru clasă. Există o singură copie a unei variabile statice în Java, indiferent de numărul de instanțe ale clasei.

Variabilele statice sunt, de asemenea, cunoscute sub numele de variabile de clasă. În Java, variabilele locale nu pot fi declarate statice.

Metode statice

Cuvântul cheie static este utilizat pentru a crea metode care vor exista independent de orice instanțe create pentru clasă.

În Java, metodele statice sau metodele statice nu utilizează nicio variabilă de instanță a niciunui obiect de clasă, sunt definite. Metodele statice iau toate datele din parametri și unii dintre acești parametri sunt evaluați fără referire la variabile.

Variabilele și metodele unei clase pot fi accesate folosind numele clasei urmat de un punct și numele variabilei sau metodei.

Exemplu

Modificatorul static din Java este utilizat pentru a crea metode și variabile de clasă, așa cum se arată în următorul exemplu:

Clasa publică InstanceCounter (private static int numInstances = 0; protected static int getCount () (return numInstances;) private static void addInstance () (numInstances ++;) InstanceCounter () (InstanceCounter.addInstance ();) public static void main ( Argumente șir) (System.out.println ("Începând de la" + InstanceCounter.getCount () + "instanță"); pentru (int i = 0; i

Veți obține următoarea ieșire:

Începând de la 0 instanță S-au creat 500 de instanțe

Modificator final

Modificator final- folosit pentru a finaliza implementarea claselor, metodelor și variabilelor.

Variabile finale

O variabilă finală poate fi inițializată o singură dată. O variabilă de referință declarată finală nu poate fi atribuită niciodată pentru a se referi la un alt obiect.

Cu toate acestea, datele din interiorul obiectului pot fi modificate. Astfel, starea obiectului poate fi modificată, dar nu și referința.

Cu variabile în Java, modificatorul final este adesea folosit cu static pentru a face o variabilă de clasă o constantă.

Exemplu

public class Test (valoarea finală int = 10; // Mai jos sunt exemple de declarații constante: public static final int BOXWIDTH = 6; static final String TITLE = "(! LANG: Manager"; public void changeValue(){ value = 12; //будет получена ошибка } } !}

Metode finale

Metoda finală nu poate fi anulată de nicio subclasă. După cum sa menționat mai devreme, în Java, modificatorul final împiedică schimbarea unei metode în subclasă.

Principala intenție de a face metoda finală este ca conținutul metodei să nu fie schimbat în lateral.

Exemplu

Declarația unei metode care utilizează modificatorul final într-o declarație de clasă este prezentată în următorul exemplu:

Public class Test (public final void changeName () (// corpul metodei))

Clasa finală

Scopul principal în Java al utilizării unei clase declarate ca fiind final este de a împiedica subclasarea clasei. Dacă o clasă este marcată ca finală, atunci nicio clasă nu poate moșteni nicio funcție din clasa finală.

Exemplu

test final public de clasă (// corpul clasei)

Modificator abstract

Modificator abstract- folosit pentru a crea clase și metode abstracte.

Clasa abstractă

Clasa abstractă nu poate instanția. Dacă o clasă este declarată abstractă, atunci singurul său scop este extinderea.

O clasă nu poate fi atât abstractă, cât și finală, deoarece o clasă finală nu poate fi extinsă. Dacă clasa conține metode abstracte, atunci trebuie declarată abstractă. În caz contrar, va fi generată o eroare de compilare.

O clasă abstractă poate conține atât metode abstracte, cât și metode obișnuite.

Exemplu

clasa abstractă Caravan (preț dublu privat; model de șir privat; anul de șir privat; public abstract void goFast (); // metodă abstractă public abstract void changeColor ();)

Metoda abstractă

O metodă abstractă este o metodă declarată cu orice implementare. Corpul metodei (implementare) este furnizat de subclasă. Metodele abstracte nu pot fi niciodată finale sau stricte.

Orice clasă care extinde o clasă abstractă trebuie să implementeze toate metodele abstracte ale superclasei, cu excepția cazului în care subclasa este o clasă abstractă.

Dacă o clasă în Java conține una sau mai multe metode abstracte, atunci clasa trebuie declarată abstractă. O clasă abstractă nu trebuie să conțină metode abstracte.

O metodă abstractă se încheie cu punct și virgulă. Exemplu: eșantion public abstract ();

Exemplu

public abstract class SuperClass (abstract void m (); // abstract method) class SubClass extinde SuperClass (// implementează abstract method void m () (.........))

Modificator sincronizat

Modificator sincronizat

Cuvântul cheie sincronizat este utilizat pentru a indica faptul că o metodă poate fi accesată doar de un fir la rând. În Java, modificatorul sincronizat poate fi aplicat cu oricare dintre cei patru modificatori ai nivelului de acces.

Exemplu

public sincronizat public showDetails () (.......)

Modificator tranzitoriu

O variabilă de instanță marcată ca tranzitorie instruiește mașina virtuală Java (JVM) să sări peste variabila specificată atunci când serializează obiectul care o conține.

Acest modificator este inclus în instrucțiune, care creează o variabilă a clasei precedente sau a tipului de date al variabilei.

Exemplu

limită publică tranzitorie de int = 55; // nu va persista public int b; // va persista

Modificator volatil

Modificator volatil- folosit în Java pentru fluxuri.

În Java, modificatorul volatil este utilizat pentru a informa JVM că firul de acces variabil trebuie să concateneze întotdeauna propria copie a variabilei cu copia master în memorie.

Accesarea unei variabile volatile sincronizează toate variabilele copiate în memoria cache. Volatile pot fi aplicate numai variabilelor de instanță care sunt de tip obiect sau private. O referință la un obiect volatil poate fi nulă.

Exemplu

public class MyRunnable implementează Runnable (private volatile boolean active; public void run () (active = true; while (active) (// line 1 // some code here)) public void stop () (active = false; / / line 2))

De obicei, run () este apelat pe un fir (pentru prima dată folosind Runnable în Java), iar stop () este apelat dintr-un alt fir. Dacă linia 1 folosește o valoare activă în cache, atunci bucla nu se poate opri până când nu setați activul fals pe linia 2.

În lecția următoare, vom discuta despre operatorii de bază utilizați în limbajul Java. Această secțiune vă va oferi o prezentare generală a modului în care le puteți utiliza în timpul dezvoltării aplicației.

Este posibil să controlați ce părți ale programului pot accesa membrii clasei. Controlul accesului ajută la prevenirea abuzului. Nu este întotdeauna de dorit să aveți acces la o singură variabilă sau metodă de clasă care ar trebui să funcționeze numai în cadrul clasei în sine.

Metoda de acces este determinată modificator de acces, care se adaugă la declarare. Există patru dintre ele:

• privat
• public (deschis)
• protejat
• acces implicit atunci când nu este prezent niciun modificator

Exemple de declarații modificatoare (trebuie să fie întotdeauna pe primul loc):

Public int i; dublu privat j, k; private int createMethod (int a) (...); clasa publica Cat ()

După cum puteți vedea, modificatorul este aplicabil unei variabile, metode, clase.

public

Când utilizați cuvântul cheie public informați că următoarea declarație de membru al clasei este disponibilă pentru toată lumea din orice alt cod din proiectul dvs.

Să presupunem că clasa este declarată ca public, și are două metode. unu privat, al doilea - public... Veți avea acces la clasă și la al doilea metoda, dar nu la prima, chiar dacă clasa în sine este deschisă.

privat

Cuvânt cheie privatînseamnă că accesul la un membru al unei clase nu este dat altcuiva decât metodele acelei clase. Nici celelalte clase din același pachet nu pot accesa membrii privați.

Toate metodele de ajutor de clasă trebuie declarate ca privat pentru a preveni apelarea lor accidentală în pachet. Același lucru se aplică câmpurilor private din cadrul unei clase.

protejat

Cuvânt cheie protejat este legat de conceptul de moștenire, în care noi membri sunt adăugați la o clasă (de bază) deja existentă, în timp ce implementarea inițială rămâne neschimbată. De asemenea, puteți schimba comportamentul membrilor clasei deja existenți. Pentru a crea o nouă clasă bazată pe una existentă, utilizați cuvântul cheie se extinde.

Dacă crearea unui pachet nou utilizează moștenirea dintr-o clasă dintr-un alt pachet, noua clasă obține acces doar la membrii publici din pachetul original. Uneori, creatorul unei clase de bază trebuie să dea acces la o anumită metodă claselor derivate, dar să o închidă de la oricine altcineva. În aceste cazuri, este utilizat cuvântul cheie protejat... Specificatorul protejat oferă, de asemenea, acces în cadrul pachetului, adică membrii cu acest specificator sunt disponibili pentru alte clase din același pachet.

În mod implicit, dacă nu este prezent un modificator, un membru al clasei este considerat public în cadrul propriului pachet, dar nu este disponibil pentru cod în afara acelui pachet. Dacă toate clasele din proiectul dvs. se află în același pachet, atunci în esență variabila fără modificator este publică ( public).

Luați în considerare o clasă fictivă SillySensor

Clasa publică SillySensor (private int sensorData; public SillySensor () (sensorData = 0;) private void calibrate (int iSeed) (// cod pentru calibrare) seed void protejat Calibration (int iSeed) (calibrate (iSeed);) public int getSensorData ( ) (// Verifică senzorul aici returnează senzorDate;))

Clasa este declarată ca publicși este disponibil în alte clase. Clasa are o variabilă sensorData, care este disponibil numai în clasa sa (privat). Constructorul este disponibil în alte clase ( public). Metodă calibra () funcționează numai în interiorul clasei ( privat). Metodă seedCalibration () disponibil în clasa sau subclasa sa ( protejat). Metodă getSensorData () disponibil în alte clase ( public).

Clasa modificator
Clasa Modifier codifică toți modificatorii,
utilizat în declarațiile de tip, în formular
constante:
REZUMAT, FINAL, INTERFAȚĂ, NATIVĂ,
PRIVAT, PROTEJAT, PUBLIC, STATIC,
STRICT, SIBRONIZAT, TRANSIDENT,
VOLATIL.
Fiecare dintre constante are o metodă de solicitare a formularului
isMod (modificator int) (aici Mod este unul dintre cele de mai sus
nume date, de exemplu, isPublic),
care returnează adevărat dacă modificatorul
mod este prezent în declarația de tip.

Să vedem un exemplu. Să existe
declarație de teren
public static final int s = 10;
apoi valoarea returnată de metodă
getModifiers al obiectului corespunzător
clasa Field va arăta ca.
Modificator.PUBLIC | Modificator.STATIC |
Modificator.FINALĂ
Este introdus modificatorul strictfp
STRICT constant.
Metode - interogările pot fi utilizate în
urmând formularul

Modifier.isPrivate (field.getModifiers ());
acest lucru este echivalent cu următoarea condiție
(field.getModifiers () & Modifier.PRIVATE)! = 0
Clasa de teren
Ca parte a clasei Field, sunt implementate metode,
permițând solicitarea de informații despre
tipul câmpului, precum și citirea și setarea acestuia
sens.
Să luăm în considerare câteva metode din clasa Field
1.getType () - returnează un obiect de clasă
Clasa corespunzătoare tipului câmpului curent.
De exemplu, pentru un câmp de tip int, obținem
clasa int.

2. Metodele setate și obținute - vă permit să citiți
valoarea curentă a câmpului și, de asemenea, setați una nouă.
Să luăm în considerare un exemplu:
public static nul printField (Obiectul o,
Numele șirului) aruncă
NoSuchFieldException,
IllegalAccessException (
Câmp câmp = o.getClass (). GetField (nume);
Valoare scurtă (câmp scurt) câmp.get (o);
System.out.println (valoare);
}
Acestea. metoda get returnează valoarea prin care
se referă la câmpul sau obiectul corespunzător
clasa - coajă.
Un exemplu de utilizare a metodei set arată astfel:

public static void setField (Obiectul o, Numele șirului,
nv scurte) aruncă
NoSuchFieldException,
IllegalAccessException (
Câmp câmp = o.getClass (). GetField (nume);
field.set (o, nou Short (nv));
}
Pentru a stoca nv într-un câmp al unui obiect dat
trebuie să utilizați clase de împachetare.
Există, de asemenea, metode care au forma
getPrimitiveType (cum ar fi getInt) și
setPrimitiveType. Aceste metode pot
folosiți pentru a schimba câmpurile dintr-o clasă,
având un tip primitiv. De exemplu,
field.setShort (o, nv);

Clasa metodei
Instrumente din clasa Metodă - vă permit să obțineți
informații complete cu privire la
declarații de metodă ale unei anumite clase,
și apelează aceste metode
contextul obiectelor date.
Luați în considerare metodele clasei Method.
1. Clasa publică getReturnType () - returnează
obiectul Class corespunzător tipului
valoarea returnată de metoda curentă.
Dacă în loc de tipul retur introduceți
declarația metodei specifică un serviciu
cuvântul este nul, metoda în cauză va reveni
obiect void.class.

2. clasa publică getParameterTypes () - returnează

parametrii care sunt specificați în declarație
metoda actuală. Obiectele sunt introduse într-o matrice la
în ordinea în care sunt enumerați parametrii
declararea metodei. Dacă metoda nu are
parametrii, o matrice goală este returnată.
3. Clasa publică getExceptionTypes () - returnează
o matrice de obiecte Class corespunzătoare tipurilor
excepții care sunt specificate în propoziție
aruncă declarația metodei curente. Obiecte
sunt introduse în matrice în ordinea în care
numele tipurilor de excepții sunt listate în
declararea metodei.

4. Invocarea obiectului public (Object onThis, Object args)
aruncă IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
Apelează metoda identificată de obiectul curent
Metodă, în contextul unui obiect onThis cu o atribuire
valorile argumentelor transmise de matricea args.
Pentru metodele nestatice, alegerea implementării
efectuate pe baza tipului propriu-zis
obiectul identificat de parametrul onThis. Pentru
metode statice pe Acest lucru nu este acceptat în
atenție și poate fi nulă.
Lungimea matricei args trebuie să fie aceeași cu un număr
parametrii din declarația metodei și tipurile de obiecte ale elementelor matrice trebuie să poată fi atribuite
tipurile corespunzătoare de parametri ai metodei - în
în caz contrar, se va arunca o excepție
IIlegalArgumentException.

10.

Dacă s-a determinat compoziția obiectului
onThis, nici un tip, membru
care este metoda actuală,
se aruncă o excepție
IllegalArgumentException.
Dacă este activat, acest lucru este nul, iar metoda nu
static, se aruncă o excepție de tip
NullPointerException.
Dacă executarea metodei apelate
se termină anormal, este aruncat
o excepție de tip InvocationTargetException.

11.

Să vedem un exemplu. Să sunăm prin mijloace
metoda de reflecție return str.indexOf (".", 8)
atunci noi avem
încerca (
Сlass strClass = str.getClass ();
Metoda indexM = strClass.getMethod ("indexOf",
new Class (string.class, int.class));
Rezultatul obiectului = indexM.invoke (str, obiect nou (
".", lnteger nou (8)));
return ((Integer) result) .intValue ();
}
catch (NoSuchMethodException e) (…… ..)
catch (invocationTargetException e) (…… ..)
catch (illegalAccessException e) (……)

12.

Clasa constructor
Pentru a crea noi instanțe (obiecte)
se poate folosi metoda tipului
newlnstance a obiectului Class,
corespunzătoare acestui tip.
Metoda apelează constructorul fără argumente,
aparținând tipului și returnează o referință
la un obiect nou creat din clasa Object,
care trebuie convertit explicit la
tipul necesar.
Să vedem un exemplu.

13.

dublu test static Date = (0.3,1.3e-2, 7.9, 3.17);

încerca (
for (int arg = 0; arg< args.length; arg++){
String name = args;
Clasa classFor = Class.forName (nume);
SortDouble sorter =
(SortDouble) classFor.newInstance ();
Metrice SortMetrics = sorter.sort (testData);
System.out.println (nume + ":" + valori)
pentru (int i = 0; i< testData.length; i++)
System.out.println („" + testData [i]);))
catch (Excepția e) (System.err.println (e);))

14.

Metoda Newlnstance când este incorectă
aplicația este capabilă să arunce mari
numărul de obiecte de excepție din diferite
tipuri.
InstantiationException - dacă clasă, obiect
care ar trebui creat nu posedă
un constructor fără argumente sau
definit ca abstract sau în
este într-adevăr o interfață,
sau efectuarea procedurii de creare
obiectul este întrerupt pentru orice altul
motive.
IllegalAccessException - dacă clasa este fie a sa
nu este disponibil niciun constructor de argumente.

15.

SecurityException - dacă este validă politica
securitatea interzice crearea de obiecte noi
ExceptionInInitializerError - Aruncat când
initializarea clasei.
Alte metode sunt definite în clasa Constructor.
public Сlass getParameterTypes ()

corespunzătoare tipurilor de parametri care
specificate în declarația curentă a constructorului.
public Class getExceptionTypes ()
Returnează o matrice de obiecte de clasă,
corespunzătoare tipurilor de excepții care
stabilit în clauza aruncărilor declarației
constructorul actual.

16.

public Object newlnstance (Object args)
aruncă InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
Folosește constructorul oferit de curent
un obiect Constructor pentru a crea și inițializa
o nouă instanță a clasei în care constructorul
declarat, trecând argumentele date.
Returnează un link către nou-creat și
un obiect inițializat. Args lungime
trebuie să corespundă numărului de parametri din
o declarație constructor, iar tipurile de obiecte ale elementelor matrice trebuie să poată fi atribuite
tipurile corespunzătoare de parametri constructori -
în caz contrar, se va arunca o excepție
IllegalArgumentException.

17.

Să luăm în considerare un exemplu:
clasa Myclass (
private int a;
Myclas public (int k) (a = k;)
public int funcții (int a, int b) (returnează a + b;)
}
public class Main (
public static main main (String args) (
încerca (
String name = "Myclass";
Clasa mycl = Class.forName (nume);
Clasa d = (clasa int.);
Constructor c = mycl.getConstructor (d);
Myclass ob = (Myclass) c.newInstance (obiect nou (
nou întreg (10)));
System.out.println (ob.func (3,5)); )
catch (Excepția e) ();
}}

18.

Clasa AccessibleObject
Clasele Field, Constructor și Method sunt
derivat din clasa AccessibleObject,
ceea ce face posibilă rezolvarea sau
interzice verificarea semnelor de acces la nivel
limbi precum public și privat.
Clasa AccessibleObject are metode
1. set de goluri publice Accesibil (steag boolean)
Setează semnalizatorul de acces la obiect
după valoarea argumentului: adevărat
înseamnă că obiectul nu se mai supune
reguli de acces stabilite la nivel
limba (și va fi întotdeauna disponibilă), un fals
forțează obiectul să mențină ceea ce este dat
nivel de acces.
Dacă autoritatea de a schimba steagul de acces
nu suficient, se aruncă o excepție de tip
SecurityException

19.

2. statice publice
void setAccessible (matrice AccessibleObject,
steag boolean)
Vă permite să setați steagul de acces la
obiecte trecute ca matrice.
Dacă în timpul procesării următoarei
obiectul aruncă o excepție de tip
Obiecte SecurityException localizate
în matrice mai devreme, stocați setul nou
valorile nivelului de acces și toate celelalte
obiectele rămân în aceeași stare.
3. booleanul public este accesibil ()
Returnează valoarea curentă a steagului de acces
la obiect

20.

Clasa matrice
Clasa matrice este utilizată pentru a crea o matrice
prin intermediul reflectării.
Există două forme ale metodei utilizate pentru a crea tablouri
newInstance.
public Object newlnstance (Class compType, int length)
Returnează o referință la o nouă matrice de tip compType
lungimea dată.
public Object newInstance (Clasa compType, int dim)
Returnează o referință la o nouă matrice multidimensională de tip
compType ale cărui dimensiuni sunt date de valori
elementele matricei de parametri dim.
Dacă dim este gol sau mai lung de
numărul permis de dimensiuni (de obicei 255),

llegalArgumentException.

21.

Să ne uităm la câteva exemple.
Exemplul 1. Să formăm o matrice de octet de tip
octet ba = (octet)
Array.newlnstance (byte.class, 13);
Aceasta este la fel ca
byte ba = octet nou;
Exemplul 2.
int dims = (4, 4);
matrice dublă = (dublă)
Array.newlnstance (double.class, dims);
Aceasta este la fel ca
matrice dubla = new double;

22.

Clasa Array are metode get și set.
Să se dea o matrice xa de valori de tip int; atunci
expresia xa [i] se va potrivi cu:
Întreg n = Array.get (xa, i)
Puteți atribui o valoare unui element de matrice ca acesta:
xa [i] = 23; este la fel ca
Array.set (xa, i, nou întreg (23));
Clasa pachetului
Apelarea metodei getPackage din clasa Class permite
obține un obiect din clasa Pachet care conține
descrierea pachetului care conține fișierul
class (clasa Package în sine se află în pachet
java.lang).
Metoda getName () a obiectului Package returnează
numele complet al pachetului curent.

23.

Clasa proxy
Clasa Proxy vă permite să creați dinamic
clase care implementează una sau mai multe
interfețe.
Să presupunem că există o clasă A,
implementarea unor interfețe.
Mașina Java în timpul rulării poate
genera clasa proxy pentru data
clasa A, adică o clasă care
implementează toate interfețele din clasa A, dar
înlocuiește apelarea tuturor metodelor acestora
interfețe pentru apelarea metodei invoke,
interfața InvocationHandler, pentru
pe care le puteți defini
implementare.

24.

Creează o clasă proxy utilizând o metodă de apel
Proxy.getProxyClass care acceptă un ClassLoader și
o serie de interfețe și returnează un obiect
class java.lang.Class care este încărcat cu
a trecutului în ClassLoader și implementează trecerea în matrice
interfețe.
Există o serie de restricții cu privire la parametrii transmiși:
1. Toate obiectele din matricea de interfețe trebuie să fie
interfețe. Nu pot fi clase sau
primitive.
2. Nu pot exista două interfețe identice în matricea de interfețe.
obiecte.
3. Toate interfețele din matricea de interfețe trebuie să fie
încărcat de ClassLoader care este trecut la metodă
getProxyClass.
4. Trebuie definite toate interfețele non-publice
în același pachet, altfel clasa proxy generată
nu le va putea implementa pe toate.

25.

5. Nu pot conține două interfețe
metoda cu același nume și
semnătura parametrului, dar cu diferite
tipuri de returnare.
6. Lungimea matricei de interfețe este limitată
65535 interfețe. Fără clasă Java
nu poate implementa mai mult de 65535
interfețe.

26.

Proprietăți dinamice ale clasei proxy
1. Clasa proxy este publică, furnizată
este finală și nu este abstractă.
2. Numele implicit al clasei de proxy nu este
definit, dar începe de la Proxy. Tot
spațiu de nume începând cu Proxy
rezervat pentru clasele de proxy
(Acest lucru nu este necesar în versiunile recente de Java.)
3. Clasa proxy moștenește de la
java.lang.reflect.Proxy.
4. Clasa proxy implementează toate interfețele,
transferat la creație, în ordinea transferului.

27.

5. Dacă clasa proxy implementează un non-public
interfață, atunci va fi generată în pachet
în care acest lucru foarte nepublic
interfață. În general, un pachet în care
clasa proxy va fi generată nedefinită.
6. Metoda Proxy.isProxyClass returnează true pentru
clase create cu
Proxy.getProxyClass și pentru clasele de obiecte,
creat cu Proxy.newProxyInstance și
fals altfel.
Această metodă este utilizată de subsistem
Securitate Java și trebuie să înțelegeți acest lucru pentru
o clasă tocmai moștenită din
java.lang.reflect.Proxy va returna false.

28.

Proprietățile instanței create din clasa proxy sunt după cum urmează:
1. Obiectul clasei proxy este aruncat pe toate interfețele,
trecut în matricea de interfețe. Dacă IDemo este unul dintre
a interfețelor trecute, apoi instanța proxy a operației
IDemo va returna întotdeauna true și operațiunea proxy (IDemo)
se va finaliza corect.
2. Metoda statică Proxy.getInvocationHandler
returnează gestionarul de apeluri care a trecut la creație
o instanță a clasei proxy. Dacă este transferat la date
obiectul method nu este o instanță a unei clase proxy, atunci
va fi aruncată o excepție IllegalArgumentException.
3. Clasa de gestionare a apelurilor implementează interfața
InvocationHandler în care este definită metoda de invocare,
având următoarea semnătură:
invocare obiect public (proxy obiect, metodă metodă,
Argumente obiect) aruncă Aruncabil

29.

Să luăm în considerare un exemplu:
pachet javaapplication3;
cont de interfață (
getBalance dublu ();
void changeBalance (suma int);
procente nule (dublu per);)
class MyAccount implementează Contul (
echilibru dublu privat;
public MyAccount () (sold = 0,0;)
public dublu getBalance () (sold de returnare;)
public void changeBalance (int sum) (
sold + = suma;)
procente de vid public (dublu per) (
sold + = sold * per / 100; ); )

30.

instrumentele clasei MyAccountProxy
InvocationHandler (
cont privat ac;
public MyAccountProxy (Account acc) (ac = acc;)
Cont static public newInstance (Cont da) (
return (Cont) Proxy.newProxyInstance (
da.getClass (). getClassLoader (),
da.getClass (). getInterfaces (),
nou MyAccountProxy (da));
}

31.

public Object invoke (obiect proxy,
Metoda metodei, argumente obiect)
aruncă aruncabil (
if (method.getName () == "procente") (
double d = ((Double) args) .doubleValue ();
dacă (d<0) d=0;
dacă (d> 30) d = 30;
args = new Double (d);

altceva (
return method.invoke (ac, args); )
}
}

32.

public class Main (
public static main main (String args) (
MyAccount ma = new MyAccount ();
Cont
a = (Cont) MyAccountProxy.newInstance (ma);
a.changeBalance (150);

a. procentele (20);
System.out.println (a.getBalance ());
a. procentele (35);
System.out.println (a.getBalance ());))

33.

Se încarcă cursurile
Sistemul de runtime încarcă clase ca
apariția nevoii pentru ei.
Caracteristici funcționale ale procedurilor de boot
clasele depind în esență de
implementări de mașini virtuale Java, dar în
în cele mai multe cazuri pentru a găsi clase,
adresată de aplicație, dar neîncărcată
de către sistemul de executare se aplică mecanismul
vizualizați calea de căutare a clasei.
Pentru a crea o aplicație care este capabilă
clasele de încărcare în alte moduri decât
furnizat în mod implicit, ar trebui
folosiți un obiect din clasa ClassLoader,
capabil să obțină bytecode-ul pentru implementarea doritului
clasă și încărcați-l în mediul de execuție
sisteme.

34.

Clasa ClassLoader este o clasă abstractă.
Pentru a vă crea propriul încărcător de clasă,
este necesar să se creeze o clasă care moștenește din
Metoda ClassLoader și override
Clasa protejată findClass (String name) aruncă
ClassNotFoundException
Care găsește codul secundar al clasei cu cel dat
nume denumit și încarcă datele în mediu
mașina virtuală prin returnarea unui obiect de clasă,
reprezentând clasa găsită.
Obiectul încărcător poate delega
autoritatea de a încărca clasele în „părinte”
încărcătorul de clase părinte.
Programul de încărcare „părinte” poate fi
dat ca argument constructorului clasei
ClassLoader.

35.

protejat ClassLoader ()
Creează implicit un obiect ClassLoader
folosind ca „părinte”
clasă încărcător sistem încărcător
(care poate fi obținut prin
apelează metoda getSystemClassLoader).
ClassLoader protejat (părinte ClassLoader)
Creează un obiect ClassLoader folosind
încărcătorul de clasă „părinte” specificat.
Partea principală a clasei ClassLoader
este metoda loadClass

36.

public Сlass loadClass (String name) aruncă
ClassNotFoundException
returnează obiectul Class pentru clasa cu date
nume și opțional încarcă acest lucru
Clasă. Dacă clasa nu poate fi încărcată,
se aruncă o excepție de tip
ClassNotFoundException.
Schema de încărcare a clasei oferită de metodă
loadClass este implicit și de obicei nu
suprascris arată astfel:
1. verificați apelând o metodă
findLoadedClass din clasa ClassLoader, nu
dacă clasa specificată a fost încărcată înainte; ca parte din
ClassLoader oferă un tabel de obiecte
Clasa pentru toate clasele încărcate prin mijloace
încărcătorul de clasă curent; dacă clasa era
încărcat înainte, metoda findLoadedClass
va returna o referință la un obiect de clasă existent;

37.

2. dacă clasa nu a fost încărcată, se numește
loadClass a încărcătorului „părinte”
clase; dacă bootloader-ul curent nu este
posedă un „părinte”, este folosit
încărcător de clasă de sistem;
3. dacă clasa nu este încă încărcată,
metoda findClass se numește doing
căutarea și încărcarea unei clase.
Astfel, este necesar să se implementeze
versiuni native ale următoarelor metode
ClassLoader:

38.

Clasa sincronizată protejată
loadClass (Nume șir, rezolvare booleană)

clasă protejată findClass (numele șirului)
aruncă ClassNotFoundException
protejat java.net.URL findResource (numele șirului)
protejat java.util.Enumeration
findResources (String name) aruncă IOException
(Clasa abstractă ClassLoader reprezintă
numai implementarea metodei loadClass bazată pe
privind metodele protejate - findLoadedClass și findClass).

39.

Să vedem un exemplu.
class PlayerLoader extinde ClassLoader (
public Class findClass (String name) aruncă
ClassNotFoundException (
încerca (
byte buf = bytesForClass (nume);
returnează defineClass (nume, buf, 0, buf.length);
}
catch (IOException e) (
aruncă o nouă ClassNotFoundException (e.toString ());
}
}
// ... Metodă declarații bytesForClass și altele
metode
}

40.

Metoda findClass face de obicei două
funcții.
În primul rând, trebuie să detecteze codul secundar
din clasa dată și stocați-o într-o matrice
de tip octet - această datorie în exemplu
atribuit metodei bytesForСlass.
În al doilea rând, folosește metoda aplicată
defineСlass pentru a executa actualul
încărcarea clasei definite de bytecode.
Metoda defineСlass are forma

41.

clasa finală protejată defineClass (numele șirului,
date octet, offset int, lungime int) aruncă
ClassFormatError
Returnează obiectul Class pentru clasa cu numele dat
Nume; reprezentarea binară a clasei este transmisă la
ca o matrice de date.
Doar octeți sunt folosiți pentru a încărca clasa,
conținute în elementele matricei de date cu indici
offset la offset + lungime. Dacă octeți din specificați
gap nu corespund formatului cerut
descrierea clasei, obiectul excepție este aruncat
de tip ClassFormatError.
Metoda este responsabilă pentru menținerea referinței la obiect
Clasa pentru clasa încărcată în tabelul încărcat
clase vizualizate de metoda findLoadedClass.

42.

Luați în considerare metoda bytesForClass.
octeți octeți protejați ForClass (String name) aruncă
lOException, ClassNotFoundException (
FileInputStream in = nul;
încerca (


if (lungime == 0) aruncă o nouă ClassNotFoundException (nume);
octet buf = octet nou;

return buf;
}
in cele din urma (
if (in! = nul) in.close ();
}
}

43.

Astfel, codul complet arată ca:
import java.lang.reflect. *;
import java.io. *;
clasa MyClassLoader extinde ClassLoader (
clasa publicaaruncă findClass (String name)
ClassNotFoundException (
octet buf = ReadFromBuffer (nume);
if (name.equals ("MyInterface1")) (

) else if (buf == null) (
returnează findSystemClass (nume);
) altceva (
returnează defineClass (nume, buf, 0, buf.length);
}
}

44.

octeți protejați ReadFromBuffer (numele șirului)
ClassNotFoundException (
FileInputStream in = nul;
încerca (
in = new FileInputStream (nume + ".class");
lungime int = in.available (); // numărul de octeți disponibili
if (lungime == 0) aruncare
new ClassNotFoundException (nume);
octet buf = octet nou;
în.citire (buf); // Citiți octeți
return buf;
}
catch (FileNotFoundException e) (returnare nulă)
catch (IOException e) (return nul;)
in cele din urma (
try (if (in! = null) in.close ();)
catch (IOException e) ()
}
}

45.

Clasa sincronizată protejată
loadClass (String name, boolean resolve) aruncă
ClassNotFoundException (
Rezultatul clasei = findClass (nume);
if (resolve) resolveClass (result);
rezultatul returului;
}
}

46.

clasa publica Main1 (
public static main main (String args) (
încerca (
String name = "Myclass";
ClassLoader ld = new MyClassLoader ();
Clasa cl = Class.forName (nume, adevărat, ld);
Constructor s = cl.getConstructor (int.class);
MyInterface1
ob = (MyInterface1) s.newInstance (
nou întreg (8));
System.out.println (ob.func (3,5));
) catch (Excepția e) ();
}
}

47.

interfață publică MyInterface1 (
public int func (int a, int b);
}
public class Myclass implementează MyInterface1 (
private int a;
Myclas public (int k) (a = k;)
public int funcții (int a, int b) (returnează a + b;)