Modificatori de nivel de acces java. Vizibilitate. specificatorii de acces. Modificator de acces deschis -public

Limbajul Java oferă mulți modificatori împărțiți în următoarele categorii:

modificator de acces
Modificator fără acces

Un modificator este folosit pentru a defini o clasă, o metodă sau o variabilă, de obicei în fruntea unei instrucțiuni. Prin următorul exemplu pentru ilustrare:

public class className ( // ... ) private boolean myFlag; săptămâni duble finale statice = 9,5; protejat static final int BOXWIDTH = 42; public static void main(Argumente șir) ( // 方法体 )

Modificator de control acces

Java, puteți utiliza caractere de control al accesului pentru a proteja accesul la clase, variabile, metode și constructori. Java acceptă patru permisiuni diferite.

Implicit, cunoscut și ca implicit în mod implicit, vizibil în același pachet, nu utilizați niciun modificator.

Privat la specificat privat modificator vizibil în cadrul aceleiași clase.

Da, pentru a indica general modificator vizibil pentru toate clasele.

protejat, în protejat modificatorul specifică faptul că toate clasele și subclasele din același pachet sunt vizibile.

Modificator de acces implicit - nu utilizați niciun cuvânt cheie

Utilizați variabile și metode declarate în modificatorul de acces implicit pentru o clasă din același pachet vizibil. O interfață în care variabilele sunt implicit declarate ca final public static și o interfață în care metoda de accesare implicită este publică.

Declarația din exemplul următor, variabilele și metodele nu pot folosi niciun modificator.

Versiune șir = „1.5.1”; boolean processOrder() ( returnează adevărat; )

Modificator de acces privat -privat

Modificatorul de acces privat, este cel mai restrictiv nivel de acces, este declarat ca metode private, variabile și aparține clasei constructoare care pot fi doar accesate, dar clasele și interfețele nu pot fi declarate private.

Variabilele declarate ca tip de acces privat pot fi accesate numai în afara clasei prin metoda public getter a clasei.

Modificatorul de acces privat este folosit în primul rând pentru a proteja detaliile implementării și datele din spatele clasei.

Următoarele clase folosesc modificatorul de acces privat:

Logger de clasă publică ( format String privat; String public getFormat() ( returnează this.format; ) public void setFormat(Format String) ( this.format = format; ) )

De exemplu, formatul de variabilă al clasei Logger este o variabilă privată, astfel încât alte clase nu pot obține și stabili în mod direct valoarea variabilei. Pentru a putea lucra cu o altă variabilă de clasă, se definesc două metode publice: GetFormat() (format de valoare returnată) și SetFormat(String) (setare de format)

Modificator de acces deschis -public

Este declarat ca clase publice, metode, constructori, iar interfețele pot fi orice alt tip de acces.

Dacă mai multe vizite reciproce ale claselor publice în pachete diferite, trebuie să importați pachetul de clasă publică corespunzător localizat permanent. Deoarece moștenirea clasei, o clasă a tuturor metodelor și variabilelor publice poate fi moștenită de subclasele sale.

Următoarele caracteristici utilizează controlul accesului public:

Public static void main(Argumente șir) ( // ... )

Metoda principală a programului Java () trebuie setată în mod public, altfel interpretul Java nu va putea rula clasa.

Modificatori de acces protejați protejați

Declarate ca variabile protejate, metodele și constructorii din același pachet pot fi orice alt tip de acces și pot fi accesate în pachete diferite pe subclase.

Un modificator de acces protejat nu poate fi modificat de clase și interfețe, metodele și variabilele membre pot fi declarate protejate, dar variabilele și metodele membre ale interfețelor nu pot fi declarate protejate.

modificator Subclasele pot accesa metode și variabile declarate protejate, astfel încât să putem proteja clasele care nu au legătură folosind aceste metode și variabile.

Următoarea clasă părinte utilizează un modificator de acces protejat care subclasele suprascrie metoda openSpeaker() a clasei părinte.

Clasa AudioPlayer ( protected boolean openSpeaker(Speaker sp) ( // 实现细节 ) ) clasa StreamingAudioPlayer ( boolean openSpeaker(Speaker sp) ( // 实现细节 ) )

Dacă metoda openSpeaker() este declarată privată, atunci, pe lângă clasa AudioPlayer, nu poate accesa metoda. Dacă openSpeaker() este declarat public, atunci toate clasele au capacitatea de a accesa metoda. Dacă vrem să facem procesul vizibil pentru subclasele clasei, atunci metoda este declarată protejată.

Controlul accesului și moștenirea

Rețineți că următoarele metode au moștenit reguli:

Clasa părinte declarată ca metode publice în subclasă trebuie să fie și ea publică.

Class Parent este declarată ca metodă protejată într-o subclasă, sau declarată ca protejată sau declarată public. Nu poți fi declarat privat.

Clasa părinte declarată ca metodă privată nu poate fi moștenită.

Modificator fără acces

Pentru a realiza o serie de alte caracteristici, Java oferă și o serie de modificatori fără acces.

Modificatorul static este folosit pentru a crea metode de clasă și variabile de clasă.

Modificatorul final folosit pentru a decora clase, metode și variabile, clasa modificată finală nu poate fi moștenită, metoda clasei modificată nu poate fi moștenită suprascrisă, variabilele constante modificate nu pot fi modificate.

Modificatorul abstract este folosit pentru a crea clase abstracte și metode abstracte.

Modificatori sincroni și volatili, în principal pentru programarea fluxurilor.

Modificator static

Variabile statice:

Cuvântul cheie static este folosit pentru a declara variabile statice care nu depind de un obiect, indiferent de câte obiecte de instanță ale clasei, este doar o copie a variabilei statice. Variabilele statice sunt cunoscute și ca variabile de clasă. Variabilele locale nu pot fi declarate ca variabile statice.

Metode statice:

Cuvântul cheie static este folosit pentru a declara un obiect independent de o metodă statică. Metodele statice nu pot folosi o clasă de variabile non-statice. Metodă statică pentru a obține date din lista de parametri și apoi a calcula datele.

Accesul la variabilele și metodele de clasă poate fi utilizat direct cu accesul classname.variablename și classname.methodname.

În exemplul următor, un modificator static este folosit pentru a crea metode de clasă și variabile de clasă.

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 de caractere ) ( System.out.println ("Începând cu " + InstanceCounter.getCount() + " instanțe"); pentru (int i = 0; i< 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }

Exemple de operațiuni de editare de mai sus rezultă după cum urmează:

A început cu 0 instanțe Creat 500 de instanțe

Clasificator final

Variabile finale:

Variabilele finale pot fi inițializate explicit și sunt inițializate o singură dată. Un director este declarat ca obiectele frunză nu pot indica un alt obiect. Dar scopul final este locul în care datele pot fi modificate. Aceasta este referința finală la un obiect care nu poate fi schimbat, dar a cărui valoare poate fi modificată.

Modificatorul final este de obicei folosit împreună pentru a crea o constantă de clasă modificatoare statică.

Clasa publică Test (valoare int final = 10; // 下面是声明常量的实例 public static final int BOXWIDTH = 6; static final String TITLE = "(!LANG:Manager"; public void changeValue(){ value = 12; //将输出一个错误 } } !}

Metoda finală

Metodele clasei de destinație sunt moștenite de subclase, dar nu pot fi modificate de subclase.

Scopul principal al unei metode este de a preveni modificarea declarației finale a metodei.

După cum se va arăta mai jos, folosind metodele de terminare a modificatorului de declarație.

Public class Test( public final void changeName()( // 方法体 ) )

categorie finală

Clasele finale nu pot fi moștenite, nicio clasă nu poate moșteni niciuna dintre caracteristicile unei clase finale.

Test de clasă finală publică ( // 类体 )

Modificator abstract

Clasa abstracte:

O clasă abstractă nu poate fi folosită pentru a instanția un obiect, singurul scop al unei instrucțiuni este să abstragă o clasă pentru extinderea viitoare a acelei clase.

Clasa nu poate fi schimbată abstract și final. Dacă clasa conține metode abstracte, clasa trebuie să fie declarată ca o clasă abstractă, în caz contrar, o eroare de compilator.

O clasă abstractă poate conține metode abstracte și metode non-abstracte.

Clasa abstractă Caravan (preț dublu privat; model String privat; anul String privat; abstract public void goFast(); //抽象方法 public abstract void changeColor(); )

Metoda abstractă

Nicio metodă nu este o implementare de metodă abstractă, o implementare de metodă concretă oferită de subclase. Metodele abstracte nu pot fi declarate ca finale și stricte.

Orice subclasă care moștenește o clasă abstractă trebuie să implementeze toate metodele abstracte ale clasei părinte, cu excepția cazului în care subclasa este o clasă abstractă.

Dacă o clasă conține un număr de metode abstracte, clasa trebuie să fie declarată ca o clasă abstractă. O clasă abstractă nu poate conține metode abstracte.

O declarație de metodă abstractă se termină cu punct și virgulă, de exemplu: model abstract public ();

Clasa abstractă publică SuperClass( abstract void m(); //抽象方法 ) clasa SubClass extinde SuperClass( //实现抽象方法 void m()( ......... ) )

Modificator sincron

Metoda de cuvinte cheie sincronă pentru a declara în același timp un singur acces la fir. Modificatorul sincron poate fi aplicat la patru modificatori de acces.

public synchronized void showDetails()( ....... )

Modificator de tranziție

Obiectul serializat conține variabile tranzitorii de instanță Java Virtual Machine (JVM) modificate pentru a omite acea variabilă particulară.

Modificatorul este inclus în definiția variabilelor de instrucțiuni pentru clasele de preprocesare de tipuri de date și variabile.

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

Modificatori volatili

O variabilă membru modificată volatilă de fiecare dată când este accesată, firele de execuție sunt forțate să recitească valoarea variabilei membru din memoria partajată. De asemenea, atunci când variabilele membre se modifică, firul de execuție este forțat să modifice valoarea scrisă înapoi în memoria partajată. Deci, în orice moment, două fire diferite văd întotdeauna aceeași valoare a unei variabile membre.

Clasa publică MyRunnable implementează Runnable ( boolean volatil privat activ; public void run() ( activ = adevărat; while (activ) // 第一行 ( // 代码 )) public void stop() ( activ = fals; // 第二行))

În circumstanțe normale, un fir de execuție apelează metoda Run () (într-un fir deschis Runnable) într-un alt thread apelează metoda stop (). Dacă valoarea activă în prima linie este folosit tampon al doilea rând când bucla activă este falsă nu se oprește.

Cu toate acestea, în codul de mai sus, folosim un activ volatil modificat, astfel încât bucla se va opri.

Pe care îl adăugați în timpul inițializării pentru a schimba valori. Limbajul Java are o gamă largă de modificatori, principalii sunt:

modificatori de acces;
modificatorii de clasă, metodă, variabilă și fire nu sunt utilizați pentru acces.

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

public class className ( // ... ) private boolean myFlag; săptămâni duble finale statice = 9,5; protejat static final int BOXWIDTH = 42; public static void main(Argumente șir) ( // corpul metodei )

Modificatori de acces

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

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

Modificator de acces implicit - fără 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ă pentru orice altă clasă 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 exemplul următor:

Versiune șir = „1.5.1”; boolean processOrder() ( returnează adevărat; )

modificator 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 ca private pot fi accesate în afara clasei dacă metodele publice care le primesc sunt prezente în clasă (vezi exemplul și explicația de mai jos).

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

Exemplu

Următoarea clasă utilizează controlul accesului privat:

Logger de clasă publică ( format String privat; String public getFormat() ( returnează this.format; ) public void setFormat(Format String) ( this.format = format; ) )

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

Deci, pentru a face această variabilă disponibilă tuturor, am definit două metode publice: getFormat(), care returnează o valoare format, Și setFormat(Șir), care îi stabilește valoarea.

modificator de acces public

modificator public- clasa, metoda, constructorul, interfata etc. declarat ca public poate fi accesat din orice altă clasă. Prin urmare, câmpurile, metodele, blocurile declarate în interiorul clasei publice pot fi accesate din orice clasă aparținând „universului” Java.

Totuși, 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 void main(Argumente șir) ( // ... )

Metodă principal() trebuie să fie public. În caz contrar, nu poate fi apelat de la 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 de orice clasă din pachetul de clasă protejată.

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

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

Exemplu

Următoarea clasă părinte utilizează controlul accesului protejat, astfel încât clasa sa fiișă suprascrie metoda openSpeaker():

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

Totuși, dacă definim o metodă openSpeaker() ca fiind protejat, nu va fi accesibil din altă clasă decât AudioPlayer. Dacă îl definim public, atunci va deveni disponibil pentru toată lumea. Dar intenția noastră este să expunem această metodă doar subclasei, motiv pentru care am folosit modificatorul protejat.

Reguli de control al accesului și moștenire

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

Metodele declarate publice într-o superclasă trebuie, de asemenea, să fie publice în toate subclasele.
Metodele declarate protejate într-o superclasă trebuie fie protejate, fie publice în subclase; nu pot fi private.
Metodele declarate ca private nu sunt moștenite de toată lumea, așa că nu există o regulă pentru ele.

Modificatorii de clasă, metodă, variabilă și fir de execuție nu sunt utilizaț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 utilizat pentru a finaliza implementarea claselor, metodelor și variabilelor;
modificator abstract necesare pentru a crea clase și metode abstracte;
modificatori sincronizateȘi volatil sunt folosite în Java pentru fire.

modificator static

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

variabile statice

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

Variabilele statice sunt cunoscute și ca variabile de clasă. În Java, variabilele locale nu pot fi declarate statice.

metode statice

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

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

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

Exemplu

Modificatorul static din Java este folosit pentru a crea metode de clasă și variabile, așa cum se arată în exemplul următor:

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 de caractere ) ( System.out.println ("Începând de la " + InstanceCounter.getCount() + " instanță"); pentru (int i = 0; i

Se va obtine urmatorul rezultat:

Pornind de la instanța 0 S-au creat 500 de instanțe

modificator final

modificator final- folosit pentru finalizarea implementării claselor, metodelor și variabilelor.

variabile finale

O variabilă finală poate fi inițializată o singură dată. O variabilă de referință declarată ca finală nu poate fi niciodată atribuită 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 variabilele în Java, modificatorul final este adesea folosit cu static pentru a face o variabilă de clasă o constantă.

Exemplu

public class Test( valoarea int final = 10; // Iată 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 înlocuită de nicio subclasă. După cum am menționat mai devreme, în Java, modificatorul final împiedică modificarea unei metode de către o subclasă.

Intenția principală de a face o metodă finală ar fi ca conținutul metodei să nu fie schimbat în paralel.

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 finală este de a preveni subclasarea clasei. Dacă o clasă este marcată finală, atunci nicio clasă nu poate moșteni nicio funcție din clasa finală.

Exemplu

Proba finală publică la clasă ( // corpul clasei )

modificator abstract

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

clasa abstractă

Clasa abstractă nu poate fi instanțiată. Dacă o clasă este declarată abstractă, atunci singurul ei scop este extinderea.

O clasă nu poate fi atât abstractă, cât și finală, deoarece o clasă finală nu poate fi extinsă. Dacă o clasă 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 String privat; anul String privat; public abstract void goFast(); //metoda abstractă public abstract void changeColor(); )

metoda abstracta

O metodă abstractă este o metodă declarată cu orice implementare. Corpul metodei (implementarea) este furnizat de subclasă. Metodele abstracte nu pot fi niciodată definitive 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 să fie declarată abstractă. O clasă abstractă nu este necesară pentru a conține metode abstracte.

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

Exemplu

clasa publică abstractă SuperClass( abstract void m(); //metoda abstractă ) clasa SubClass extinde SuperClass( // implementează metoda abstractă void m()( ......... ) )

modificator sincronizat

modificator sincronizat

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

Exemplu

public synchronized void showDetails()( ....... )

modificator tranzitoriu

O variabilă de instanță marcată tranzitorie indică mașinii virtuale Java (JVM) să ignore variabila anume atunci când serializează obiectul care o conține.

Acest modificator este inclus în instrucțiune, care creează o variabilă din clasa sau tipul de date predecesor al variabilei.

Exemplu

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

modificator volatil

modificator volatil- sunt folosite în Java pentru fire.

În Java, modificatorul volatil este folosit pentru a informa JVM-ul că un fir de acces la variabilă ar trebui să îmbine întotdeauna propria copie a variabilei cu copia principală din memorie.

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

Exemplu

clasă publică MyRunnable implementează Runnable( private volatile boolean activ; public void run()( activ = adevărat; while (activ)( // linia 1 // ceva cod aici) ) public void stop()( activ = fals; // linia 2))

De obicei, run() este apelat pe un fir (aceasta este prima dată când începeți să utilizați Runnable în Java) și stop() este apelat pe un alt thread. Dacă valoarea activă din cache este utilizată pe linia 1, atunci bucla nu se poate opri până când nu setați activ la 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 privire de ansamblu asupra modului în care le puteți utiliza în timpul dezvoltării aplicației.

Aici vom încerca să luăm în considerare aproape toate cazurile de utilizare a modificatorilor de acces. Singura excepție este utilizarea lor pentru imbricat ( cuibărit) și intern ( interior), precum și pentru interfețe, deoarece încă nu am luat în considerare aceste subiecte.

Clasele și pachetele, utilizate împreună cu modificatorii de acces, servesc ca mijloc de încapsulare, adică un mijloc de a ascunde detaliile de implementare î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. Există în total patru modificatori de acces și aici vom oferi o scurtă descriere a acestora, apoi îi vom analiza pe fiecare în detaliu.

public- orice componentă declarată ca public, accesibil din orice cod
protejat- permite accesul la componenta din pachet si clase descendentilor
privat- permite accesul la componentele din cadrul clasei
Mod implicit(fără cuvânt cheie) - permite accesul la componentele din pachet

Clasele descendente sunt clase moștenite dintr-o clasă. Moștenirea pe care nu am studiat-o încă.

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, atunci este disponibil peste tot (sau oriunde este disponibil pachetul în sine). Am limitat această declarație la clasele de nivel superior, deoarece clasele pot fi declarate ca membri ai altor clase. Deoarece aceste clase interioare sunt membri ai clasei, ele sunt supuse regulilor de control al accesului pentru membrii clasei..

Acces la membrii clasei

Membrii clasei sunt întotdeauna disponibili în cadrul corpului clasei. Mod implicit membrii clasei sunt de asemenea disponibili în pachetul în care este definită clasa.

modificator public

Pentru o clasă neimbricată, poate fi specificat doar unul dintre 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, iar numele fișierului trebuie să se potrivească cu numele clasei.

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

modificator protejat

Vom discuta acest modificator în detaliu în subiectul moștenirii clasei. Dacă moștenirea nu este folosită, atunci acest modificator funcționează, la fel ca modificatorul implicit.

Singurul lucru care poate fi spus acum pe scurt este că pentru componentele declarate ca protejat, va avea acces orice clasa 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 de acces. Elemente declarate ca privat disponibil numai în cadrul aceleiași clase și nu pentru oricine din afara clasei.

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

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

În esență, modificatorii de acces sunt un subiect simplu, dar vom reveni la el mai târziu. Deocamdată a fost doar o introducere. Și acum pentru puțină practică...

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

Ultima actualizare: 03.10.2019

Toți membrii unei clase - câmpuri, metode, proprietăți - toți au modificatori de acces. Modificatorii de acces vă permit să setați domeniul permis pentru membrii clasei. Adică, modificatorii de acces definesc contextul în care poate fi utilizată o anumită variabilă sau metodă. În subiectele anterioare, am întâlnit-o deja când am declarat că câmpurile de clasă sunt publice (adică cu modificatorul public).

C# folosește următorii modificatori de acces:

public : public, clasă publică sau membru al clasei. Un astfel de membru al clasei este accesibil de oriunde în cod, precum și din alte programe și ansambluri.

privat : clasă privată sau membru al clasei. Reprezintă exact opusul modificatorului public. O astfel de clasă privată sau membru al clasei este accesibil numai din codul din aceeași clasă sau context.

protected : Un astfel de membru al clasei este accesibil de oriunde în clasa curentă sau în clasele derivate. În acest caz, clasele derivate pot fi localizate în alte ansambluri.

intern: O clasă și membrii clasei cu un modificator similar sunt accesibile de oriunde în cod în același ansamblu, dar nu sunt accesibile altor programe și ansambluri (cum este cazul modificatorului public).

intern protejat: combină funcționalitatea a doi modificatori. Clasele și membrii clasei cu acest modificator sunt accesibile din ansamblul curent și din clasele derivate.

private protected : un astfel de membru al clasei este accesibil de oriunde în clasa curentă sau în clasele derivate care sunt definite în același ansamblu.

Putem seta în mod explicit modificatorul de acces, de exemplu:

Statul de clasă protejată privată (internă int a; protected void Print() ( Console.WriteLine($"a = (a)"); ) )

Sau nu putem preciza:

Stare clasă ( int a; void Print() ( Console.WriteLine($"a = (a)"); ) )

Dacă nu este definit niciun modificator de acces pentru câmpuri și metode, atunci modificatorul privat este aplicat implicit.

Clasele și structurile declarate fără un modificator au acces intern implicit.

Toate clasele și structurile definite direct în spațiile de nume și care nu sunt imbricate în alte clase pot avea doar modificatori publici sau interni.

Să ne uităm la un exemplu și să creăm următoarea clasă State:

Clasa publică State ( // nu contează dacă private int defaultVar; int defaultVar; // câmpul este accesibil numai din clasa curentă private int privateVar; // accesibil din clasa curentă și clasele derivate care sunt definite în același project protected private int protectedPrivateVar; // accesibil din clasa curentă și din clasele derivate protected int protectedVar; // disponibil oriunde în proiectul curent internal int internalVar; // disponibil oriunde în proiectul curent și din clasele derivate din alte proiecte protejate intern int protectedInternalVar; // disponibil în oriunde în program, precum și pentru alte programe și ansambluri public int publicVar; // implicit are modificatorul private void defaultMethod() => Console.WriteLine($"defaultVar = (defaultVar)" ); // metoda este disponibilă numai din clasa curentă private void privateMethod() => Console.WriteLine($"privateVar = (privateVar)"); // accesibilă din clasa curentă și clasele derivate care sunt definite în același clauză proiect protejat private void protectedPrivateMethod() => Console.WriteLine($"protectedPrivateVar = (protectedPrivateVar)"); // accesibil din clasa curentă și clasele derivate protected void protectedMethod()=> Console.WriteLine($"protectedVar = (protectedVar)"); // disponibil oriunde în proiectul curent intern void internalMethod() => Console.WriteLine($"internalVar = (internalVar)"); // accesibil oriunde în proiectul curent și din clasele derivate din alte proiecte protected internal void protectedInternalMethod() => Console.WriteLine($"protectedInternalVar = (protectedInternalVar)"); // disponibil oriunde în program, precum și pentru alte programe și ansambluri public void publicMethod() => Console.WriteLine($"publicVar = (publicVar)"); )

Deoarece clasa State este declarată cu modificatorul public, aceasta va fi accesibilă de oriunde în program, precum și din alte programe și ansambluri. Clasa State are cinci câmpuri pentru fiecare nivel de acces. Plus o variabilă nemodificată care este privată în mod implicit.

Există, de asemenea, șase metode care vor afișa pe ecran valorile câmpurilor de clasă. Vă rugăm să rețineți că, deoarece toți modificatorii vă permit să utilizați membrii clasei în cadrul acestei clase, atunci toate variabilele de clasă, inclusiv cele private, sunt disponibile pentru toate metodele sale, deoarece toate sunt în contextul clasei State.

Acum să vedem cum putem folosi variabilele noastre de clasă în program (adică în metoda Main a clasei Program), dacă clasele State și Program sunt în același proiect:

Class Program ( static void Main(string args) ( State state1 = new State (); // nu vom putea atribui o valoare variabilei defaultVar, // deoarece are un modificator privat și clasa Program nu vede it // Și mediul nu vede această linie subliniată ca fiind incorectă state1.defaultVar = 5; //Eroare, nu poate fi accesată // același lucru este valabil și pentru variabila privateVar state1.privateVar = 5; // Eroare, nu poate fi accesată // atribuirea valoarea variabilei protectedPrivateVar nu va funcționa, // deoarece clasa Program nu este o clasă care moștenește din clasa State state1.protectedPrivateVar =5; // Eroare, nu poate fi accesată // atribuirea unei valori variabilei protectedVar va eșua, de asemenea, // deoarece clasa Program nu este o clasă care moștenește din clasa State state1.protectedVar = 5; // Eroare, nu poate fi accesată // variabila internalVar cu modificatorul intern este disponibilă de oriunde în proiectul curent // îi poate atribui în siguranță o valoare state1.internalVar = 5; // variabila protectedInternalVar este, de asemenea, accesibilă de oriunde în starea curentă a proiectului1.protectedInternalVar = 5; // variabila publicVar este public state1.publicVar = 5; ) )

Astfel, am putut seta doar variabilele internalVar, protectedInternalVar și publicVar, deoarece modificatorii lor ne permit să le folosim în acest context.

Același lucru este valabil și pentru metode:

Program de clasă ( static void Main(șir argumente) ( State state1 = new State(); state1.defaultMethod(); //Eroare, nu poate fi accesat state1.privateMethod(); // Eroare, nu poate fi accesat state1.protectedPrivateMethod() ; // Eroare, nu poate fi accesată state1.protectedMethod(); // Eroare, nu poate fi accesată state1.internalMethod(); // ok state1.protectedInternalMethod(); // ok state1.publicMethod(); // ok ) )

Aici, doar trei metode s-au dovedit a fi disponibile pentru noi: internalMethod, protectedInternalMethod, publicMethod, care au modificatorii internal, protected internal, public, respectiv.

Datorită unui astfel de sistem de modificatori de acces, este posibilă ascunderea unor aspecte ale implementării clasei de alte părți ale programului.

În ciuda faptului că modificatorii publici și interni sunt similari ca efect, au o mare diferență. Clasele și membrii clasei cu modificatorul public vor fi disponibile și pentru alte programe, dacă clasa dată este plasată într-o bibliotecă dinamică dll și apoi utilizată în aceste programe.