Wat is het verschil tussen openbaar, beschermd, pakket-privé en privé in Java?

	Klasse	Pakket	Subklasse (zelfde pkg)	Subklasse (diff pkg)	Wereld
public	+	+	+	+	+
protected	+	+	+	+
geen wijziging	+	+	+
private	+

---

Antwoord 2, autoriteit 9%

(Voorbehoud: ik ben geen Java-programmeur, ik ben een Perl-programmeur. Perl heeft geen formele beveiligingen, daarom begrijp ik het probleem misschien zo goed 🙂 )

Privé

Zoals je zou denken, kan alleen de klassewaarin het is gedeclareerd het zien.

Pakket Privé

Het kan alleen worden gezien en gebruikt door het pakketwaarin het is gedeclareerd. Dit is de standaard in Java (wat sommigen als een fout zien).

Beveiligd

Pakket Privé + kan worden bekeken door subklassen of pakketleden.

Openbaar

Iedereen kan het zien.

Gepubliceerd

Zichtbaar buiten de code die ik beheer. (Hoewel het geen Java-syntaxis is, is het belangrijk voor deze discussie).

C++ definieert een extra niveau genaamd “vriend” en hoe minder je daarvan weet, hoe beter.

Wanneer moet je wat gebruiken? Het hele idee is inkapseling om informatie te verbergen. U wilt de details van hoe iets wordt gedaan zoveel mogelijk verbergen voor uw gebruikers. Waarom? Want dan kun je ze later wijzigen en niemands code breken. Hiermee kun je bugs optimaliseren, refactoren, herontwerpen en oplossen zonder je zorgen te hoeven maken dat iemand die code gebruikt die je zojuist hebt gereviseerd.

Dus de vuistregel is om dingen alleen zo zichtbaar te maken als ze moeten zijn. Begin met privé en voeg alleen meer zichtbaarheid toe als dat nodig is. Maak alleen openbaar wat absoluut noodzakelijk is voor de gebruiker om te weten, elk detail dat u openbaar maakt, verkrampt uw vermogen om het systeem opnieuw te ontwerpen.

Als je wilt dat gebruikers hun gedrag kunnen aanpassen, in plaats van internals openbaar te maken zodat ze ze kunnen negeren, is het vaak een beter idee om die lef in een object te schuiven en die interface openbaar te maken. Zo kunnen ze eenvoudig een nieuw object inpluggen. Als u bijvoorbeeld een cd-speler aan het schrijven was en u wilt dat de “zoek informatie over deze cd”-bit aanpasbaar is, in plaats van die methoden openbaar te maken, zou u al die functionaliteit in een eigen object stoppen en alleen uw object getter/setter openbaar maken . Op deze manier gierig zijn over het blootleggen van je lef moedigt een goede compositie en scheiding van zorgen aan

Persoonlijk houd ik het bij ‘privé’ en ‘openbaar’. Veel OO-talen hebben dat gewoon. “Beschermd” kan handig zijn, maar het is echt een cheat. Zodra een interface meer dan privé is, heb je er geen controle meer over en moet je in de code van anderen gaan zoeken om toepassingen te vinden.

Hier komt het idee van “gepubliceerd” om de hoek kijken. Het veranderen van een interface (refactoring) vereist dat je alle code vindt die het gebruikt en dat ook verandert. Als de interface privé is, geen probleem. Als het beveiligd is, moet je al je subklassen gaan zoeken. Als het openbaar is, moet je alle code zoeken die jouw code gebruikt. Soms is dit mogelijk, bijvoorbeeld als u werkt aan bedrijfscode die alleen voor intern gebruik is, het maakt niet uit of een interface openbaar is. U kunt alle code uit de bedrijfsrepository halen. Maar als een interface is “gepubliceerd”, als er code is die het gebruikt buiten je controle, dan ben je afgedroogd. U moet die interface ondersteunen, anders riskeert u code te breken. Zelfs beveiligde interfaces kunnen als gepubliceerd worden beschouwd (daarom houd ik me niet bezig met beschermd).

Veel talen vinden de hiërarchische aard van openbaar/beschermd/privé te beperkend en niet in overeenstemming met de werkelijkheid. Daartoe is er het concept van een trait class, maar dat is een andere show.

---

Antwoord 3, autoriteit 8%

Hier is een betere versie van de tabel, die ook een kolom voor modules bevat.

Uitleg

• Een privélid (i) is alleentoegankelijk binnen dezelfde klasse als is aangegeven.

• Een lid met geen toegangsmodifier(j) is alleen toegankelijk binnen klassen in hetzelfde pakket.

• Een beschermdlid (k) is toegankelijk binnen alle klassen in hetzelfde pakket enbinnen subklassen in andere pakketten.

• Een openbaarlid (l) is toegankelijk voor alle klassen (tenzij het lid is van een moduledie het pakket waarin het is gedeclareerd niet exporteert).

---

Welke modifier te kiezen?

Access modifiers is een hulpmiddel waarmee u kunt voorkomen dat u per ongeluk inkapseling verbreekt^(*). Vraag jezelf af of je van plan bent het lid iets te zijn dat intern is voor de klas, het pakket, de klassenhiërarchie of helemaal niet, en kies dienovereenkomstig het toegangsniveau.

Voorbeelden:

• Een veld long internalCountermoet waarschijnlijk privé zijn omdat het veranderlijk is en een implementatiedetail is.
• Een klasse die alleen in een fabrieksklasse (in hetzelfde pakket) zou moeten worden geïnstantieerd, zou een constructor met pakketbeperking moeten hebben, omdat het niet mogelijk zou moeten zijn om deze rechtstreeks van buiten het pakket aan te roepen.
• Een interne void beforeRender()methode die vlak voor het renderen wordt aangeroepen en als hook in subklassen wordt gebruikt, moet worden beschermd.
• Een void saveGame(File dst)-methode die wordt aangeroepen vanuit de GUI-code moet openbaar zijn.

^{(*) Wat is inkapseling precies?}

---

Antwoord 4, autoriteit 4%

____________________________________________________________________
                | highest precedence <---------> lowest precedence
*———————————————+———————————————+———————————+———————————————+———————
 \ xCanBeSeenBy | this          | any class | this subclass | any
  \__________   | class         | in same   | in another    | class
             \  | nonsubbed     | package   | package       |    
Modifier of x \ |               |           |               |       
————————————————*———————————————+———————————+———————————————+———————
public          |       ✔       |     ✔     |       ✔       |   ✔  
————————————————+———————————————+———————————+———————————————+———————
protected       |       ✔       |     ✔     |       ✔       |   ✘   
————————————————+———————————————+———————————+———————————————+———————
package-private |               |           |               |
(no modifier)   |       ✔       |     ✔     |       ✘       |   ✘   
————————————————+———————————————+———————————+———————————————+———————
private         |       ✔       |     ✘     |       ✘       |   ✘    
____________________________________________________________________

---

5, Autoriteit 3%

eenvoudige regel. Begin met het verklaren van alles privé. En dan vooruitgang in de richting van het publiek, aangezien de behoeften zich voordoen en ontwerpen.

Vraag jezelf bij het blootstellen van leden als u representatiekeuzes of abstractie-keuzes blootlegt. De eerste is iets dat u wilt vermijden, omdat het te veel afhankelijkheden op de daadwerkelijke weergave zal introduceren in plaats van op het waarneembare gedrag ervan.

Als algemene regel probeer ik te voorkomen dat de implementaties van de methode worden vermijd door te subcassing; Het is te gemakkelijk om de logica op te schakelen. Verklaar abstracte beschermde methoden als u van plan bent om te worden overschreven.

Gebruik ook de annotatie annotatie bij het overschrijven om dingen te behouden wanneer u een refactor hebt.

---

6

In zeer kort

• public: Toegankelijk voor overal.
• protected: Toegankelijk voor de klassen van hetzelfde pakket en de subclasses die in elk pakket verblijven.
• Standaard (geen aangegeven modifier): toegankelijk via de klassen van hetzelfde pakket.
• private: alleen toegankelijk binnen dezelfde klas.

---

7

De meest onbegrepen toegangsmodificator in Java is protected. We weten dat het vergelijkbaar is met de standaardmodificator met één uitzondering waarin subklassen het kunnen zien. Maar hoe? Hier is een voorbeeld dat hopelijk de verwarring verduidelijkt:

• Neem aan dat we 2 klassen hebben; Fatheren Son, elk in een eigen pakket:

  package fatherpackage;
  public class Father
  {
  }
  -------------------------------------------
  package sonpackage;
  public class Son extends Father
  {
  }
  

• Laten we een beschermde methode toevoegen foo()NAAR Father.

  package fatherpackage;
  public class Father
  {
      protected void foo(){}
  }
  

• De methode foo()kan worden opgeroepen in 4 contexten:

  1. Binnen een klasse die zich in hetzelfde pakket bevindt waar foo()is gedefinieerd (fatherpackage):

     package fatherpackage;
     public class SomeClass
     {
         public void someMethod(Father f, Son s)
         {
             f.foo();
             s.foo();
         }
     }
     

  2. Binnen een subklasse, op het huidige exemplaar via thisof super:

     package sonpackage;
     public class Son extends Father
     {
         public void sonMethod()
         {
             this.foo();
             super.foo();
         }
     }
     

  3. Op een referentie waarvan het type dezelfde klasse is:

     package fatherpackage;
     public class Father
     {
         public void fatherMethod(Father f)
         {
             f.foo(); // valid even if foo() is private
         }
     }
     -------------------------------------------
     package sonpackage;
     public class Son extends Father
     {
         public void sonMethod(Son s)
         {
             s.foo();
         }
     }
     

  4. Op een referentie waarvan het type de bovenliggende klasse is en het is inhet pakket waar foo()is gedefinieerd (fatherpackage) [Dit kan worden opgenomen in context nr. 1]:

     package fatherpackage;
     public class Son extends Father
     {
         public void sonMethod(Father f)
         {
             f.foo();
         }
     }
     

• De volgende situaties zijn niet geldig.

  1. Op een referentie waarvan het type de bovenliggende klasse is en het is buitenhet pakket waar foo()is gedefinieerd (fatherpackage):

     package sonpackage;
     public class Son extends Father
     {
         public void sonMethod(Father f)
         {
             f.foo(); // compilation error
         }
     }
     

  2. Een niet-subklasse binnen een pakket van een subklasse (een subklasse erft de beschermde leden van zijn bovenliggende en maakt ze privé voor niet-subklassen):

     package sonpackage;
     public class SomeClass
     {
         public void someMethod(Son s) throws Exception
         {
             s.foo(); // compilation error
         }
     }
     

---

Antwoord 8

Privé

• Methoden, variabelen en constructors

Methoden, variabelen en constructors die privé zijn verklaard, zijn alleen toegankelijk binnen de gedeclareerde klasse zelf.

• Klasse en interface

De modifier voor privétoegang is het meest beperkende toegangsniveau. Klasse en interfaces kunnen niet privé zijn.

Opmerking

Variabelen die privé zijn verklaard, zijn toegankelijk buiten de klasse als er openbare gettermethoden in de klasse aanwezig zijn.
Variabelen, methoden en constructors die in een superklasse beschermd zijn verklaard, zijn alleen toegankelijk voor de subklassen in een ander pakket of een klasse binnen het pakket van de klasse van de beschermde leden.

---

Beveiligd

• Klasse en interface

De beveiligde toegangsmodifier kan niet worden toegepast op klassen en interfaces.

Methoden, velden kunnen beschermd worden verklaard, maar methoden en velden in een interface kunnen niet beschermd worden verklaard.

Opmerking

Beveiligde toegang geeft de subklasse de kans om de helpermethode of -variabele te gebruiken, terwijl wordt voorkomen dat een niet-gerelateerde klasse deze probeert te gebruiken.

---

Openbaar

Een klasse, methode, constructor, interface enz. die openbaar is verklaard, is toegankelijk vanuit elke andere klasse.

Daarom zijn velden, methoden en blokken die in een openbare klasse zijn gedeclareerd, toegankelijk vanuit elke klasse die tot de Java Universe behoort.

• Verschillende pakketten

Als de openbare klasse die we proberen te openen zich echter in een ander pakket bevindt, moet de openbare klasse nog steeds worden geïmporteerd.

Vanwege klasse-overerving worden alle openbare methoden en variabelen van een klasse overgenomen door zijn subklassen.

---

Standaard -Geen zoekwoord:

Standaard toegangsmodifier betekent dat we niet expliciet een toegangsmodifier declareren voor een klasse, veld, methode, etc.

• Binnen dezelfde pakketten

Een variabele of methode die is gedeclareerd zonder enige modificatie voor toegangscontrole is beschikbaar voor elke andere klasse in hetzelfde pakket. De velden in een interface zijn impliciet openbaar statisch definitief en de methoden in een interface zijn standaard openbaar.

Opmerking

We kunnen de statische velden niet overschrijven. Als u probeert te overschrijven, wordt er geen fout weergegeven
maar het werkt niet wat wij behalve.

Verwante antwoorden

• Statische methoden in Java overschrijven

Referentielinks

http://docs.oracle.com/javase/tutorial/ java/javaOO/accesscontrol.html
http://www.tutorialspoint.com/java/java_access_modifiers.htm

---

Antwoord 9

Het verschil is te vinden in de links die al zijn gegeven, maar welke je moet gebruiken, komt meestal neer op het “principe van de minste kennis”. Sta alleen de minste zichtbaarheid toe die nodig is.

---

Antwoord 10

Privé: alleen beperkte toegang tot de les

Standaard (geen wijziging): beperkte toegang tot klasse en pakket

Beveiligd: beperkte toegang tot klasse, pakket en subklassen (zowel binnen als buiten pakket)

Openbaar: Toegankelijk voor klasse, pakket (alle) en subklassen… Kortom, overal.

---

Antwoord 11

Toegangsmodificaties in Java.

Java-toegangsmodifiers worden gebruikt om toegangscontrole in Java te bieden.

1. Standaard:

Alleen toegankelijk voor de lessen in hetzelfde pakket.

Bijvoorbeeld

// Saved in file A.java
package pack;
class A{
  void msg(){System.out.println("Hello");}
}
// Saved in file B.java
package mypack;
import pack.*;
class B{
  public static void main(String args[]){
   A obj = new A(); // Compile Time Error
   obj.msg(); // Compile Time Error
  }
}

Deze toegang is beperkter dan openbaar en beschermd, maar minder beperkt dan privé.

2. Openbaar

Overal toegankelijk. (Globale toegang)

Bijvoorbeeld

// Saved in file A.java
package pack;
public class A{
  public void msg(){System.out.println("Hello");}
}
// Saved in file B.java
package mypack;
import pack.*;
class B{
  public static void main(String args[]){
    A obj = new A();
    obj.msg();
  }
}

Uitvoer:Hallo

3. Privé

Alleen toegankelijk binnen dezelfde klas.

Als je probeert toegang te krijgen tot privé-leden van de ene klasse in een andere, krijg je een compileerfout. Bijvoorbeeld,

class A{
  private int data = 40;
  private void msg(){System.out.println("Hello java");}
}
public class Simple{
  public static void main(String args[]){
    A obj = new A();
    System.out.println(obj.data); // Compile Time Error
    obj.msg(); // Compile Time Error
  }
}

4. Beveiligd

Alleen toegankelijk voor de klassen in hetzelfde pakket en voor de subklassen

Bijvoorbeeld

// Saved in file A.java
package pack;
public class A{
  protected void msg(){System.out.println("Hello");}
}
// Saved in file B.java
package mypack;
import pack.*;
class B extends A{
  public static void main(String args[]){
    B obj = new B();
    obj.msg();
  }
}

Uitgang: Hallo

---

12

Toegangsmodifiers zijn er om de toegang op verschillende niveaus te beperken.

Public: Het is eigenlijk zo eenvoudig als je toegang hebt van elke klas of dat in hetzelfde pakket is of niet.

Om toegang te krijgen als u in hetzelfde pakket bent, kunt u rechtstreeks openen, maar als u in een ander pakket bent, kunt u een voorwerp van de klasse maken.

Standaard: Het is toegankelijk in hetzelfde pakket van een van de klasse van het pakket.

Om toegang te krijgen tot u kunt een voorwerp van de klasse maken. Maar u hebt geen toegang tot deze variabele buiten het pakket.

Beschermd: U hebt toegang tot variabelen in hetzelfde pakket, evenals subklasse in een ander pakket.
Dus eigenlijk is het standaard + geërfd gedrag.

Om toegang te krijgen tot het beveiligde veld dat is gedefinieerd in de basisklasse, kunt u een object van kinderles maken.

privé: Het kan toegang hebben in dezelfde klasse.

In niet-statische methoden kunt u rechtstreeks toegang krijgen vanwege dit referentie (ook in constructors) maar om toegang te krijgen in statische methoden die u nodig hebt om voorwerp van de klasse te maken.

---

13

• Public – Toegankelijk vanaf overal in de toepassing.

• Standaard – Toegankelijk vanaf het pakket.

• Beschermd – toegankelijk vanaf pakket- en subklassen in een ander pakket.
  Ook

• Private – Alleen toegankelijk vanuit de klas.

---

14

Zichtbaar voor het pakket. De standaard. Er zijn geen modificaties nodig.

Alleen zichtbaar voor de klas (privé).

Zichtbaar voor de wereld (openbaar).

Zichtbaar voor het pakket en alle subklassen (beveiligd).

Variabelen en methoden kunnen worden gedeclareerd zonder aangeroepen modifiers. Standaardvoorbeelden:

String name = "john";
public int age(){
    return age;
}

Privétoegangsmodifier – privé:

Methoden, variabelen en constructors die privé zijn verklaard, zijn alleen toegankelijk binnen de gedeclareerde klasse zelf. De modifier voor privétoegang is het meest beperkende toegangsniveau. Klasse en interfaces kunnen niet privé zijn.

Variabelen die privé zijn verklaard, zijn toegankelijk buiten de klasse als er openbare gettermethoden in de klasse aanwezig zijn.

Het gebruik van de privé-modifier is de belangrijkste manier waarop een object zichzelf inkapselt en gegevens voor de buitenwereld verbergt.

Voorbeelden:

Public class Details{
    private String name;
    public void setName(String n){
        this.name = n;
    }
    public String getName(){
        return this.name;
    }
}

Aanpasser voor openbare toegang – openbaar:

Een klasse, methode, constructor, interface, enz. die openbaar is verklaard, is toegankelijk vanuit elke andere klasse. Daarom kunnen velden, methoden en blokken die binnen een openbare klasse zijn gedeclareerd, worden geopend vanuit elke klasse die tot het Java-universum behoort.

Als de openbare klasse die we proberen te openen zich echter in een ander pakket bevindt, moet de openbare klasse nog steeds worden geïmporteerd.

Vanwege klasse-overerving worden alle openbare methoden en variabelen van een klasse overgenomen door zijn subklassen.

Voorbeeld:

public void cal(){
}

Beveiligde toegangsmodifier – beschermd:

Variabelen, methoden en constructors die in een superklasse beschermd zijn verklaard, zijn alleen toegankelijk voor de subklassen in een ander pakket of een klasse binnen het pakket van de klasse van de beschermde leden.

De beveiligde toegangsmodifier kan niet worden toegepast op klassen en interfaces. Methoden, velden kunnen beschermd worden verklaard, maar methoden en velden in een interface kunnen niet beschermd worden verklaard.

Beveiligde toegang geeft de subklasse de kans om de helpermethode of -variabele te gebruiken, terwijl wordt voorkomen dat een niet-gerelateerde klasse deze probeert te gebruiken.

class Van{
    protected boolean speed(){
    }
}
class Car{
    boolean speed(){
    }
}

---

Antwoord 15

Deze pagina schrijft goed over de beschermde & standaard toegangsmodifier

….
Beveiligd: Beveiligde toegangsmodifier is een beetje lastig en je kunt zeggen dat het een superset is van de standaard toegangsmodifier. Beveiligde leden zijn hetzelfde als de standaardleden wat betreft de toegang tot hetzelfde pakket. Het verschil is dat de beschermde leden ook toegankelijk zijn voor de subklassen van de klasse waarin het lid is gedeclareerd, die buiten het pakket vallen waarin de bovenliggende klasse aanwezig is.

Maar deze beschermde leden worden “buiten het pakket alleen via erfenis” toegankelijk “. I.E kunt u toegang krijgen tot een beschermd lid van een klasse in zijn subklasse die in een ander pakket rechtstreeks aanwezig is alsof het lid in de subklasse zelf aanwezig is. Maar dat beschermde deel is niet toegankelijk in de subklasse buiten het pakket met behulp van de referentie van de oudercategorie.
….

---

16

Het antwoord van David biedt de betekenis van elke toegangsmodificator. Wat betreft bij het gebruik van elk, zou ik voorstellen om publiek alle klassen en de methoden van elke klasse te maken die bedoeld zijn voor extern gebruik (de API) en al het andere privé.

In de loop van de tijd zult u een gevoel ontwikkelen voor wanneer u een aantal klassenpakket wilt maken en wanneer u bepaalde methoden beschermd voor gebruik in subclasses kunt declareren.

---

17

Java-toegang wijzigt

Access-modifier kan van toepassing zijn op class, field^{[ Over]} , method. Probeer dit toegang te krijgen, te subclass of negeren.

• Toegang tot fieldof methodis via een class.
• Erfenis en open gesloten principe .
  • Opvolger class(subklasse) Toegangsmodificator kan elke zijn.
  • Opvolger method(OVERRIDE) Toegangsmodificator moet het hetzelfde zijn of deze uitbreiden

Hoogste niveauklasse (eerste niveau) kan publicen defaultzijn. Nested class^[Over] kan een van hen hebben

packageis niet van toepassing op pakkethiërarchie

[Swift access modifiers]

---

Antwoord 18

Opmerking: Dit is slechts een aanvullingvoor het geaccepteerde antwoord.

Dit is gerelateerd aan Java Access Modifiers.

Van Java Access Modifiers:

Een Java-toegangsmodifier specificeert welke klassen toegang hebben tot een gegeven
klasse en zijn velden, constructors en methoden. Toegangsmodifiers kunnen:
afzonderlijk worden gespecificeerd voor een klasse, zijn constructors, velden en
methoden. Java-toegangsmodifiers worden soms ook dagelijks genoemd
spraak als Java-toegangsspecificaties, maar de juiste naam is Java-toegang
modificatoren. Klassen, velden, constructors en methoden kunnen een van:
vier verschillende Java-toegangsmodifiers:

• Lijstitem
• privé
• standaard (pakket)
• beschermd
• openbaar

Van Toegang voor leden van een klas beheren:

Toegangsniveau-modifiers bepalen of andere klassen a . kunnen gebruiken
bepaald veld of een bepaalde methode aanroepen. Er zijn twee niveaus:
van toegangscontrole:

• Op het hoogste niveau: openbaar of privépakket (geen expliciete wijziging).
• Op ledenniveau: openbaar, privé, beveiligd of pakketprivé (geen expliciete wijziging).

Een klasse kan worden gedeclareerd met de modifier public, in welk geval dat
class is overal zichtbaar voor alle klassen. Als een klasse geen modifier heeft
(de standaard, ook bekend als pakket-privé), het is alleen zichtbaar
binnen zijn eigen pakket

De volgende tabel toont de toegang tot leden die door elk van hen is toegestaan
modificatie.

╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ Modifier    ║ Class ║ Package ║ Subclass ║ World ║
╠═════════════╬═══════╬═════════╬══════════╬═══════╣
║ public      ║ Y     ║ Y       ║ Y        ║ Y     ║
║ protected   ║ Y     ║ Y       ║ Y        ║ N     ║
║ no modifier ║ Y     ║ Y       ║ N        ║ N     ║
║ private     ║ Y     ║ N       ║ N        ║ N     ║
╚═════════════╩═══════╩═════════╩══════════╩═══════╝

De eerste gegevenskolom geeft aan of de klasse zelf toegang heeft tot
het lid gedefinieerd door het toegangsniveau. Zoals je kunt zien, altijd een les
heeft toegang tot zijn eigen leden. De tweede kolom geeft aan of:
klassen in hetzelfde pakket als de klas (ongeacht hun
ouderschap) toegang hebben tot het lid. De derde kolom geeft aan:
of subklassen van de klasse die buiten dit pakket zijn gedeclareerd,
toegang tot het lid. De vierde kolom geeft aan of alle klassen
toegang hebben tot het lid.

Toegangsniveaus zijn op twee manieren van invloed op u. Ten eerste, wanneer je klassen gebruikt die
uit een andere bron komen, zoals de klassen in het Java-platform,
toegangsniveaus bepalen welke leden van die klassen van jou zijn
klassen kunnen gebruiken. Ten tweede, als je een les schrijft, moet je beslissen
welk toegangsniveau elke lidvariabele en elke methode in je klas
zou moeten hebben.

---

Antwoord 19

Public Protected Default en privé zijn toegangsmodificaties.

Ze zijn bedoeld om in te kapselen, of om de inhoud van de klas te verbergen en te tonen.

1. Klasse kan openbaar of standaard zijn
2. Lesgroepleden kunnen openbaar, beschermd, standaard of privé zijn.

Privé is niet toegankelijk buiten de les
Standaard is alleen toegankelijk in het pakket.
Beschermd in pakket en elke klasse die het uitbreidt.
Publiek is open voor iedereen.

Normaal gesproken zijn lidvariabelen privé gedefinieerd, maar lidmethoden zijn openbaar.

---

Antwoord 20

Vaak heb ik me gerealiseerd dat het onthouden van de basisconcepten van elke taal mogelijk kan worden gemaakt door real-world analogieën te creëren. Hier is mijn analogie voor het begrijpen van toegangsmodifiers in Java:

Laten we aannemen dat je student bent aan een universiteit en dat je een vriend hebt die je dit weekend komt bezoeken. Stel dat er een groot standbeeld van de oprichter van de universiteit in het midden van de campus staat.

• Als je hem naar de campus brengt, is dit standbeeld het eerste dat jij en je vriend zien. Dit betekent dat iedereen die op de campus loopt, zonder toestemming van de universiteit naar het beeld kan kijken. Dit maakt het beeld als OPENBAAR.

• Vervolgens wil je je vriend meenemen naar je slaapzaal, maar daarvoor moet je hem registreren als bezoeker. Dit betekent dat hij een toegangspas krijgt (dezelfde als die van jou) om in verschillende gebouwen op de campus te komen. Dit zou zijn toegangskaart als BESCHERMDmaken.

• Je vriend wil inloggen op de campus-WiFi, maar heeft geen inloggegevens om dit te doen. De enige manier waarop hij online kan komen, is als u uw login met hem deelt. (Houd er rekening mee dat elke student die naar de universiteit gaat ook over deze inloggegevens beschikt). Dit zou uw inloggegevens als GEEN MODIFIERmaken.

• Ten slotte wil je vriend(in) je voortgangsrapport voor het semester lezen dat op de website is geplaatst. Elke student heeft echter zijn eigen persoonlijke login om toegang te krijgen tot dit gedeelte van de campuswebsite. Dit zou deze inloggegevens als PRIVATEmaken.

Hopelijk helpt dit!

---

Antwoord 21

Met deze afbeelding krijgt u gemakkelijk inzicht in de basisverschillen tussen openbare, privé-, beveiligde en standaardtoegangsmodifiers. De standaardmodifier vindt automatisch plaats wanneer je geen ant access modifiers in je code declareert.

---

Antwoord 22

Als je aan toegangsmodifiers denkt, denk er dan zo aan (geldt voor zowel variabelenals methoden):

public–> overal bereikbaar
private–> alleen toegankelijk binnen dezelfde klasse waar het is gedeclareerd

Nu ontstaat er verwarring als het gaat om defaulten protected

default–> Er is geen sleutelwoord voor toegangsmodificatie aanwezig. Dit betekent dat het strikt beschikbaar is binnen het pakket van de klas. Nergensbuiten dat pakket is het toegankelijk.

protected–> Iets minder strikt dan defaulten afgezien van dezelfde pakketklassen is het toegankelijk voor subklassen buiten het pakketdat het is gedeclareerd.

---

Antwoord 23

Mijn twee cent 🙂

privé:

class ->een klasse op het hoogste niveau kan niet privé zijn. innerlijke klassen kunnen privé zijn die toegankelijk zijn vanuit dezelfde klas.

instantievariabele ->alleen toegankelijk in de klas. Geen toegang buiten de klas.

pakket-privé:

class ->een klasse op het hoogste niveau kan pakketprivé zijn. Het is alleen toegankelijk vanuit hetzelfde pakket. Niet uit subpakket, niet uit extern pakket.

instantievariabele ->toegankelijk vanuit hetzelfde pakket. Niet uit subpakket, niet uit extern pakket.

beschermd:

klasse ->een klasse op het hoogste niveau kan niet worden beschermd.

instantievariabele ->Alleen toegankelijk in hetzelfde pakket of subpakket. Kan alleen buiten het pakket worden geopend tijdens het verlengen van de les.

openbaar:

class ->toegankelijk vanuit pakket/subpakket/ander pakket

instantievariabele ->toegankelijk vanuit pakket/subpakket/ander pakket

Hier is een gedetailleerd antwoord

https://github.com /junto06/java-4-beginners/blob/master/basics/access-modifier.md

---

Antwoord 24

Het draait allemaal om inkapseling(of zoals Joe Phillips zei, minste kennis).

Begin met de meest beperkende (privé) en kijk of je later minder beperkende modifiers nodig hebt.

We gebruiken allemaal modifiers voor methoden en leden, zoals privé, openbaar, … maar één ding dat te weinig ontwikkelaars doen, is pakketten gebruiken om de code logisch organiseren.

Bijvoorbeeld:
U kunt gevoelige beveiligingsmethoden in een ‘beveiligingspakket’ stoppen.
Plaats vervolgens een openbare klasse die toegang heeft tot een deel van de beveiligingsgerelateerde code in dit pakket, maar houd andere beveiligingsklassen pakket privé.
Andere ontwikkelaars zullen dus alleen de publiek beschikbare klasse van buiten dit pakket kunnen gebruiken (tenzij ze de modifier wijzigen).
Dit is geen beveiligingsfunctie, maar zal het gebruik begeleiden.

Outside world -> Package (SecurityEntryClass ---> Package private classes)

Een ander ding is dat klassen die veel van elkaar afhankelijk zijn, in hetzelfde pakket terecht kunnen komen en uiteindelijk kunnen worden aangepast of samengevoegd als de afhankelijkheid te sterk is.

Als je daarentegen alles als publicinstelt, is het niet duidelijk wat wel of niet moet worden benaderd, wat kan leiden tot het schrijven van veel javadoc (wat niets afdwingt via de compiler …).

---

Antwoord 25

In het volgende blokdiagram wordt uitgelegd hoe gegevensleden van basisklasseworden overgeërfdwanneer de afgeleide klassetoegangsmodus privéis .

Opmerking: het declareren van gegevensleden met een specificatie voor privétoegang staat bekend als het verbergen van gegevens.

Bron: Toegangsspecificaties – Privé, Openbaar en Beschermd

---

Antwoord 26

• openbaar

  Als een klaslid openbaar is verklaard, is het overal toegankelijk

• beschermd

  Als een klasserelement wordt gedeclareerd met het beveiligeerde trefwoord, dan is het toegankelijk vanuit dezelfde klasse-leden, buitenklasse-leden binnen hetzelfde pakket en erfde klasleden. Als een klasserelement wordt beveiligd, kan het niet toegankelijk zijn van externe pakketklasse, tenzij de externe verpakte klasse wordt geërfd, d.w.z. verlengt de andere pakket superclass. Maar een beschermd klasselement is altijd beschikbaar voor dezelfde pakketklassen die het niet uitmaakt van weer dat dezelfde pakketklasse wordt geërfd of niet

• Standaard

  In Java Standaard is geen toegangsmodificatorwoord. Als een klasserelement wordt gedeclareerd zonder toegangsmodifiersleutelwoord, wordt het in dit geval als standaardlid beschouwd. Het standaardklasse-lid is altijd beschikbaar voor leden van dezelfde pakketklasse. Maar het lid van de buitenpakket kan geen toegang krijgen tot de leden van de standaardklasse, zelfs als buitenklassen subklassen zijn, in tegenstelling tot beschermde leden

• particulier

  Als een klasselement wordt gedeclareerd met het beveiligeerde trefwoord, is het in dit geval alleen beschikbaar voor dezelfde klasse-leden

---

27

Toegangspecifatiers in Java:
Er zijn 4 toegangspecifatoren in Java, namelijk privé, pakket-privé (standaard), beschermd en publiek in het vergroten van de toegangsvolgorde.

privé :
Wanneer u een klasse ontwikkelt en u wilt dat lid van deze klasse niet buiten deze klasse wordt blootgesteld, moet u het als privé verklaren. Particuliere leden zijn alleen toegankelijk in de les waar ze worden gedefinieerd, d.w.z. insluitende klasse. particuliere leden zijn toegankelijk op ‘deze’ referentie en ook op andere gevallen van klasse die deze leden omsluiten, maar alleen binnen de definitie van deze klasse.

Package-private (standaard) :
Deze toegangspeciferen biedt toegang die is opgegeven door private toegangspeciferer naast toegang die hieronder wordt beschreven.

Wanneer u een pakket ontwikkelt en daarom een ​​klasse (zeg klasse1) hierbinnen, kunt u standaard gebruiken (hoeft u niet expliciet te worden vermeld) toegangspeciferie, om lid te worden gesteld binnen de klas, aan andere klassen binnen uw (hetzelfde) pakket. In deze andere klassen (binnen hetzelfde pakket) hebt u toegang tot deze standaardleden op basis van klasse1. Ook hebt u toegang tot deze standaardorganen binnen subklassen van klasse1, zeggen Class2 (in deze verwijzing of op basis van klasse1 of op basis van klasse2).

In principe, binnen in hetzelfde pakket kunt u toegang krijgen tot standaardleden op basis van de klasse direct of op ‘dit’ referentie in subklassen.

beschermd :
Deze toegangspeciferie biedt toegang die is opgegeven door pakket-private toegangspeciferie naast toegang die hieronder wordt beschreven.

Wanneer u een paar verpakking ontwikkelt en daarom een ​​klasse (Say Cl Class1) hierbinnen, moet u een beschermde toegangspecifieer gebruiken voor gegevenselement binnen Klasse1 als u niet wilt dat dit lid buiten uw pakket is toegankelijk (zeg in pakket van de consument van uw pakket IE-client die uw API’s gebruikt) in het algemeen, maar u wilt een uitzondering maken en alleen toegang tot dit lid toestaan ​​als client schrijft de klasse Say Class2 die klasse 1 verlengt. Dus in het algemeen zullen beschermde leden toegankelijk zijn op ‘deze’ referentie in afgeleide klassen d.w.z. klasse2 en ook op expliciete instanties van klasse2.

Let op:

1. U kunt geen toegang tot geërfd beschermd lid van Class1
   Klasse2, als u probeert toegang te krijgen tot expliciete instantie van klasse1,
   Hoewel het erin wordt geërfd.
2. Wanneer u een andere klasse Class3 in hetzelfde / verschillende pakket schrijft
   die klasse2 verlengt, is beschermd lid van Class1 toegankelijk
   op deze referentie en ook op expliciete instantie van klasse3. Dit zal
   Wees waar voor elke hiërarchie die is uitgebreid, d.w.z. beschermd lid
   zal nog steeds toegankelijk zijn op deze referentie of dit exemplaar van extended
   klas. Merk op dat in Class3, als u een instantie van Class2 maakt,
   je hebt echter geen toegang tot beschermd lid van Class1
   het is geërfd.

Het komt er dus op neer dat beschermde leden toegankelijk zijn in andere pakketten, alleen als een klasse uit dit andere pakket een klasse uitbreidt die dit beschermde lid omsluit en beschermd lid wordt benaderd op ‘deze’ referentie of expliciete gevallen van uitgebreide klasse, binnen de definitie van uitgebreide klasse.

openbaar: deze toegangsspecificatie biedt toegang die is gespecificeerd door een beveiligde toegangsspecificatie naast de hieronder beschreven toegang.

Als u een pakket ontwikkelt en dus een klasse (zeg Class1) erin, dan moet u de specificatie voor openbare toegang gebruiken voor gegevenslid binnen Class1 als u wilt dat dit lid toegankelijk is in andere pakketten op instantie van Class1 die in sommige is gemaakt klasse van ander pakket. In principe moet deze toegangsspecificatie worden gebruikt wanneer u van plan bent uw gegevenslid zonder enige voorwaarde aan de wereld bloot te stellen.