Was ist der Unterschied zwischen public, protected, package-privat und privat in Java?

StackOverflow https://stackoverflow.com/questions/215497

Frage

In Java gibt es klare Regeln auf jede der zugriffsmodifizierer, nämlich der Standard (package private) public, protected und private, wobei class und interface und den Umgang mit der Vererbung?

War es hilfreich?

Lösung

Die offiziellen Tutorial von Nutzen zu Ihnen sein kann . 

            │ Class │ Package │ Subclass │ Subclass │ World
            │       │         │(same pkg)│(diff pkg)│ 
────────────┼───────┼─────────┼──────────┼──────────┼────────
public      │   +   │    +    │    +     │     +    │   +     
────────────┼───────┼─────────┼──────────┼──────────┼────────
protected   │   +   │    +    │    +     │     +    │         
────────────┼───────┼─────────┼──────────┼──────────┼────────
no modifier │   +   │    +    │    +     │          │    
────────────┼───────┼─────────┼──────────┼──────────┼────────
private     │   +   │         │          │          │    

 + : accessible         blank : not accessible

Andere Tipps

(Vorab: Ich bin kein Java-Programmierer, ich bin ein Perl-Programmierer Perl hat keinen formalen Schutz, die vielleicht, warum ich das Problem so gut :) verstehen.)

Privat

Wie man denken würde, nur die Klasse , in der sie deklariert ist, kann es sehen.

Paket Privat

Kann nur durch das Paket in der sie deklariert wurde gesehen und genutzt werden. Dies ist die Standardeinstellung in Java (was einige als Fehler sehen).

Geschützte

Package Privat + kann durch Subklassen oder Verpackungsteil gesehen werden.

öffentliche

Jeder kann es sehen.

Veröffentlicht

Visible außerhalb des Codes I steuern. (Obwohl nicht Java-Syntax, es ist wichtig, für diese Diskussion).

C ++ definiert eine zusätzliche Ebene als „Freund“ und je weniger Sie wissen, dass das besser.

Wenn Sie verwenden sollten, was? Die ganze Idee ist Kapselung Informationen zu verbergen. So viel wie möglich wollen Sie das Detail verbergen, wie etwas von den Benutzern durchgeführt wird. Warum? Denn dann können Sie sie später ändern und nicht jemand den Code brechen. Auf diese Weise können Sie optimieren, Umgestalten, Redesign und Fehler beheben, ohne Angst, dass jemand diesen Code wurde mit einfach überholt.

So, Faustregel, um die Dinge nur so sichtbar wie sie sein müssen. Beginnen Sie mit privaten und nur mehr Sichtbarkeit nach Bedarf hinzufügen. Nur öffentlich macht das, was unbedingt für den Benutzer notwendig ist, zu wissen, jedes Detail Sie öffentliche Krämpfe Ihre Fähigkeit, machen das System neu zu gestalten.

Wenn Sie Benutzer in der Lage sein Verhalten anpassen, anstatt Interna öffentlich zu machen, damit sie sie außer Kraft setzen können, ist es oft eine bessere Idee, diese Eingeweide in ein Objekt zu schieben und diese Schnittstelle öffentlich zu machen. So können sie einfach in einem neuen Objekt anschließen können. wenn Sie einen CD-Player schreiben zum Beispiel, und wollte die „Informationen zu dieser CD finden gehen“ Bit anpassbar, anstatt diese Methoden öffentlich machen würden Sie all diese Funktionen in ein eigenes Objekt setzen und einfach Ihr Objekt Getter / Setter öffentlich machen . Auf diese Weise fördert die gute Zusammensetzung und Trennung von Bedenken geizig über Ihre Eingeweide auszusetzen

Ich persönlich Stick mit nur „privat“ und „öffentlich“. Viele OO-Sprachen haben nur. „Protected“ kann nützlich sein, aber es ist wirklich ein Betrüger. Sobald eine Schnittstelle mehr als privat ist es außerhalb Ihrer Kontrolle, und Sie müssen gehen in anderen Leuten Code suchen Verwendungen zu finden.

Dies ist, wo die Idee der „veröffentlicht“ kommt in. Ändern einer Schnittstelle (Refactoring es) erfordert, dass Sie den gesamten Code finden, die sie und ändern, verwendet auch. Wenn die Schnittstelle ist privat, auch kein Problem. Wenn es geschützt ist, müssen Sie alle Ihre Unterklassen gehen finden. Wenn es öffentlich ist, müssen Sie den gesamten Code gehen finden, die Ihr Code verwendet. Manchmal ist dies möglich, zum Beispiel, wenn Sie auf Firmen-Code arbeiten, die für den internen Gebrauch ist nur, dass es keine Rolle, ob eine Schnittstelle öffentlich ist. Sie können aus dem Corporate-Repository der gesamten Code greifen. Aber wenn eine Schnittstelle „veröffentlicht“, wenn es Code ist es außerhalb Ihrer Kontrolle verwendet wird, dann sind Sie abgespritzt. Sie müssen diese Schnittstelle oder Risikobruch Code unterstützen. Auch können geschützte Schnittstellen betrachtet veröffentlicht (weshalb ich mit geschütztem nicht stören).

Viele Sprachen finden die hierarchische Natur der öffentlichen / / private geschützt zu einschränkend sein und nicht im Einklang mit der Wirklichkeit. Zu diesem Zweck gibt es das Konzept eines Charakterzug Klasse , aber das ist eine andere Show.

Hier ist eine bessere Version der Tabelle. (Zukunftssicher mit einer Spalte für Module.)

Java Access Modifier

Erklärungen

  • privat Mitglied (i) ist nur zugänglich innerhalb der gleichen Klasse wie sie deklariert ist.

  • Ein Mitglied mit keinem Zugriffsmodifikator (j) ist nur innerhalb von Klassen im gleichen Paket.

  • geschützt Element (k) zugänglich ist in allen Klassen im selben Paket und in Unterklassen in anderen Paketen.

  • Öffentlichkeit Mitglied (l) ist zugänglich für alle Klassen (es sei denn, es in einem Modul , die nicht das Paket nicht exportieren erklärt in ist).

Which Modifikator zu wählen?

Zugriffsmodifikatoren ist ein Werkzeug, um Ihnen zu helfen versehentlich brechen Kapselung (*) zu verhindern. Fragen Sie sich, wenn Sie das Element beabsichtigen, etwas zu sein, die die Klasse interner ist, Paket, Klassenhierarchie oder nicht intern überhaupt, und wählen Sie Zugriffsebene entsprechend.

Beispiele:

  • Ein Feld long internalCounter sollte wohl privat sein, da es wandelbar ist und eine Implementierung Detail.
  • Eine Klasse, die nur in einer Fabrik Klasse instanziiert werden soll (im selben Paket) sollte ein Paket beschränkt Konstruktor haben, da es nicht möglich sein, sollte es von außerhalb der Verpackung direkt aufrufen.
  • Eine interne void beforeRender() Methode aufgerufen rechts vor dem Rendern und als Haken in Subklassen verwendet werden, sollten geschützt werden.
  • Eine void saveGame(File dst) Methode, die von dem GUI-Code aufgerufen wird, soll öffentlich sein.

(*) Was ist Encapsulation genau? 

                | 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         |       ✔       |     ✘     |       ✘       |   ✘

Einfache Regel. Beginnen Sie mit privatem alles zu erklären. Und dann gegenüber der Öffentlichkeit der Fortschritte, wie die Bedürfnisse entstehen und Design garantiert es.

Wenn Belichtungs Mitglieder sich fragen, ob Sie Darstellung Entscheidungen oder Abstraktion Entscheidungen aussetzen. Die erste ist etwas, was Sie wollen vermeiden, wie es auf der tatsächlichen Darstellung zu viele Abhängigkeiten einführen wird, statt auf seine beobachtbaren Verhalten.

In der Regel versuche ich durch Subclassing zwingende Methode Implementierungen zu vermeiden; es ist zu einfach, um die Logik zu vermasseln. Deklarieren abstrakt geschützte Methoden, wenn Sie beabsichtigen, sie außer Kraft gesetzt werden.

Verwenden Sie auch die @Override Anmerkung, wenn zwingende Dinge zu verhindern, brechen, wenn Sie Refactoring.

Es ist eigentlich ein bisschen komplizierter als ein einfaches Gitter zeigt. Das Gitter sagt Ihnen, ob ein Zugriff erlaubt ist, aber was macht genau einen Zugang? Auch Zugriffsebene interagieren mit verschachtelten Klassen und Vererbung auf komplexe Weise.

Der „default“ Zugriff (durch das Fehlen eines Schlüsselwort angegeben) wird auch Paket namens -privater . Ausnahme: in einer Schnittstelle, kein Modifikator bedeutet den Zugang der Öffentlichkeit; Modifikatoren andere als öffentlich sind verboten. Enum-Konstanten sind immer öffentlich.

Zusammenfassung

Ist ein Zugriff auf ein Mitglied mit diesem Zugriffsbezeichner erlaubt?

  • Mitglied ist private: Nur wenn Mitglied innerhalb derselben Klasse wie der Aufruf von Code definiert wird
    • .
  • ist Mitglied Paket privat: Nur wenn der Angerufene-Code der innerhalb des Mitglieds sofort Umverpackung ist
    • .
  • Mitglied ist protected. Same-Paket, oder wenn Element in einer Oberklasse der Klasse definiert wird, um den Aufrufcode enthält,
  • Mitglied ist public: Ja.

Welche Zugriffsbezeichner gelten

Lokale Variablen und formalen Parameter können nicht Zugriffsbezeichner nehmen. Da sie von Natur aus nicht zugänglich außen nach Scoping-Regeln sind, sind sie effektiv privat.

Für die Klassen im oberen Umfang, nur public und Paket-private sind nicht gestattet. Diese Designwahl ist vermutlich, weil protected und private auf Paketebene überflüssig wären (es gibt keine Vererbung von Paketen).

Alle Zugriffsbezeichner sind möglich auf Klassenmitglieder (Konstrukteure, Methoden und statische Elementfunktionen, verschachtelte Klassen).

Siehe auch: Java Klasse Accessibility

Order

Die Zugriffsbezeichner streng bestellt werden können

  

public> geschützt> Paket-private> privat

was bedeutet, dass public den meisten Zugang bietet, private am wenigsten. Jede Bezugnahme möglich auf einem privaten Mitglied ist auch gültig für ein Paket-private Mitglied; Jede Bezugnahme auf ein Paket-private Element ist an einem geschützten Element gültig ist, und so weiter. (Der der Zugang zu geschützten Mitgliedern zu anderen Klassen im selben Paket wurde ein Fehler betrachtet.)

Notizen

  • A Methoden der Klasse sind erlaubt private Mitglieder anderer Objekte des zuzugreifen gleiche Klasse. Genauer gesagt, eine Methode der Klasse C private Mitglieder von C auf Objekte jeder Unterklasse von C. Java unterstützt keine Beschränkung des Zugang von Instanz zugreifen kann, nur durch Klasse. (Vergleiche mit Scala, die es unterstützt private[this] verwenden.)
  • Sie benötigen Zugriff auf einen Konstruktor ein Objekt zu konstruieren. Wenn also alle Konstrukteure privat sind, kann die Klasse nur durch Code lebt innerhalb der Klasse (in der Regel statische Factory-Methoden oder statische Variableninitialisierungen) konstruiert werden. Ähnliches gilt für Paket-private oder geschützte Konstrukteuren.
    • Es werden nur private Konstruktoren mit bedeutet auch, dass die Klasse nicht von außen subclassed werden, da Java eine Unterklasse der Konstrukteurs erfordert implizit oder explizit einen Oberklassenkonstruktors nennen. (Es kann enthält jedoch eine verschachtelte Klasse, die es Unterklassen.)

Innere Klassen

Sie haben auch zu prüfen verschachtelt Bereiche, wie zum Beispiel innere Klassen. Ein Beispiel für die Komplexität ist, dass innere Klassen haben Mitglieder, die sich Zugriffsmodifikatoren nehmen. So können Sie eine private innere Klasse mit einem öffentlichen Mitglied haben; kann das Element zugegriffen werden? (Siehe unten.) Die allgemeine Regel in Umfang zu betrachten ist und dachte rekursiv, um zu sehen, ob Sie auf jede Ebene zugreifen können.

Dies ist jedoch ziemlich kompliziert und für weitere Informationen, konsultieren der Java Language Specification . (Ja, es gab Compiler-Fehler gewesen in der Vergangenheit.)

Für einen Geschmack davon, wie diese interagieren, betrachten Sie dieses Beispiel. Es ist möglich, „Leck“ private innere Klassen; dies ist in der Regel eine Warnung: 

class Test {
    public static void main(final String ... args) {
        System.out.println(Example.leakPrivateClass()); // OK
        Example.leakPrivateClass().secretMethod(); // error
    }
}

class Example {
    private static class NestedClass {
        public void secretMethod() {
            System.out.println("Hello");
        }
    }
    public static NestedClass leakPrivateClass() {
        return new NestedClass();
    }
}

Compiler Ausgabe: 

Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
        Example.leakPrivateClass().secretMethod(); // error
                                  ^
1 error

Einige verwandte Fragen:

Als Faustregel:

  • private. Klassenbereich
  • default (oder package-private.): Paketbereich
  • protected: package scope + child (wie Paket, aber wir können es aus verschiedenen Paketen Unterklasse). Der geschützte Modifikator immer hält die „Eltern-Kind-Beziehung“.
  • public. Überall

Als Ergebnis, wenn wir Zugriffsrecht in drei Rechte unterteilen:

  • (D) irect (Aufrufe von einer Methode innerhalb der gleichen Klasse, oder über "diese" Syntax).
  • (R) eference (aufrufen, um eine Methode einen Verweis auf die Klasse verwendet wird, oder über "dot" Syntax).
  • (I) nheritance (via Subklassifizieren).

dann haben wir diese einfache Tabelle: 

+—-———————————————+————————————+———————————+
|                 |    Same    | Different |
|                 |   Package  | Packages  |
+—————————————————+————————————+———————————+
| private         |   D        |           |
+—————————————————+————————————+———————————+
| package-private |            |           |
| (no modifier)   |   D R I    |           |
+—————————————————+————————————+———————————+
| protected       |   D R I    |       I   |
+—————————————————+————————————+———————————+
| public          |   D R I    |    R  I   |
+—————————————————+————————————+———————————+

In sehr kurz

  • public: von überall.
  • protected. Zugänglich durch die Klassen des gleichen Pakets und die Unterklassen in jedem Paket mit Wohnsitz
  • default (nicht eingegeben.): Zugänglich durch die Klassen des gleichen Pakets
  • private. Zugänglich innerhalb der gleichen Klasse nur

Die meisten mißverstanden Zugriffsmodifikator in Java ist protected. Wir wissen, dass es mit einer Ausnahme auf den Standard Modifikator ähnlich ist, in der Subklassen sie sehen können. Aber wie? Hier ist ein Beispiel, das hoffentlich die Verwirrung klärt:

  • Nehmen wir an, wir zwei Klassen haben; Father und Son, die jeweils in einem eigenen Paket: 

    package fatherpackage;

public class Father
{

}

-------------------------------------------

package sonpackage;

public class Son extends Father
{

}

  • Lassen Sie uns fügen Sie eine geschützte Methode foo() Father. 

    package fatherpackage;

public class Father
{
    protected void foo(){}
}

  • Das Verfahren foo() kann in 4 Kontexten aufgerufen werden:

    1. Innerhalb einer Klasse, die im selben Paket befindet, in dem foo() definiert (fatherpackage): 

      package fatherpackage;

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

    2. Innerhalb einer Unterklasse auf die aktuelle Instanz über this oder super: 

      package sonpackage;

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

    3. Auf einer Referenz, dessen Typ die gleiche Klasse: 

      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. Auf einer Referenz, dessen Typ die Elternklasse und es ist innen das Paket, in dem foo() definiert (fatherpackage) [Dies kann innerhalb Zusammenhang nicht einbezogen werden. 1]: 

      package fatherpackage;

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

  • Die folgenden Situationen sind nicht gültig.

    1. Auf einer Referenz, deren Typ der übergeordneten Klasse und es ist außerhalb das Paket in dem foo() definiert (fatherpackage): 

      package sonpackage;

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

    2. Eine nicht Unterklasse innerhalb eines Pakets von einer Unterklasse (Eine Unterklasse erbt die geschützten Member von ihrer Mutter, und es macht sie privat nicht-Subklassen): 

      package sonpackage;

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

Private

  • Methoden,Variablen und Konstruktoren

Methoden, Variablen und Konstruktoren, die private deklariert sind, kann nur zugegriffen werden, die innerhalb der Klasse selbst deklariert.

  • Klasse und Schnittstelle

Private access modifier ist die restriktive Zugriffsebene.Klasse und Schnittstellen kann nicht privat sein.

Hinweis

Variablen, die deklariert sind private können außerhalb der Klasse zugegriffen werden, wenn die öffentliche getter-Methoden sind in der Klasse.Variablen, Methoden und Konstruktoren, die als geschützt in einer Oberklasse kann nur zugegriffen werden, von den Unterklassen in anderen Paket oder einer Klasse im Paket der geschützten Mitglieder-Klasse.

Geschützt

  • Klasse und Schnittstelle

The protected access modifier angewendet werden kann, um Klassen und Schnittstellen.

Methoden, Felder deklariert werden geschützt, jedoch Methoden und Felder in einer Schnittstelle deklariert werden können, geschützt.

Hinweis

Protected access gibt die Unterklasse, die chance zu nutzen, die helper-Methode oder variable, während die Vermeidung einer nonrelated Klasse versucht, es zu benutzen.

Public

Eine Klasse, Methode, Konstruktor, interface etc. als public deklariert zugegriffen werden kann von jeder anderen Klasse.

Daher Felder, Methoden, Blöcke, erklärte in einem öffentlichen Klasse zugegriffen werden kann von jeder Klasse gehören die Java-Universum.

  • Verschiedene Pakete

Allerdings, wenn die öffentliche Klasse, die wir versuchen, zuzugreifen, ist in einem anderen Paket, dann der öffentliche Klasse müssen noch importiert werden.

Wegen der Vererbung, alle öffentlichen Methoden und Variablen einer Klasse vererbt Ihre Unterklassen.

Standard -Keine keyword:

Default access modifier bedeutet, dass wir nicht explizit deklarieren Sie ein zugriffsmodifizierer für eine Klasse, ein Feld, eine Methode, etc.

  • Innerhalb des gleichen Packages

Eine variable oder Methode deklariert, ohne access control Modifikator ist, der anderen Klasse im selben Paket.Die Felder in einem interface sind implizit public static final und die Methoden in einer Schnittstelle sind standardmäßig öffentlich.

Hinweis

Wir nicht außer Kraft setzen kann, die Statische Felder.wenn Sie versuchen, zu überschreiben, es zeigt keine Fehler aber es doesnot Arbeit, was wir außer.

Ähnliche Antworten

Referenzen links

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

Privat : Begrenzter Zugang zu Klasse nur

Standard (kein Modifikator) : Begrenzter Zugang zu Klassen- und Paket

Geschützte : Begrenzter Zugang zu Klasse, Paket und Unterklassen (sowohl innerhalb als auch außerhalb des Paket)

öffentliche :. Zugänglich für Klasse, Paket (alle), und Unterklassen ... Kurz gesagt, überall

Der Unterschied in den Links zu finden bereits vorgesehen, aber die man in die Regel zu verwenden, kommt es auf das „Prinzip des kleinsten Wissens“. Lassen Sie nur die geringste Sichtbarkeit, die benötigt wird.

Zugriffsmodifikatoren gibt es Zugriff auf mehreren Ebenen zu beschränken.

öffentlich:. Es ist im Grunde so einfach, wie Sie von jeder Klasse zugreifen können, ob das in demselben Paket ist oder nicht

Für den Zugriff, wenn Sie in demselben Paket sind Sie direkt zugreifen können, aber wenn man in einem anderen Paket ist, dann können Sie ein Objekt der Klasse erstellen.

Standard:. Es ist zugänglich in dem gleichen Paket aus einem der Klasse von Paket

Für den Zugriff auf ein Objekt der Klasse erstellen können. Aber man kann nicht auf diese Variable zugreifen außerhalb des Pakets.

Geschützt: können Sie Variablen in demselben Paket zugreifen sowie Unterklasse in einem anderen Paket. so dass im Grunde ist es default + geerbt Verhalten.

Um die geschützten Bereich in der Basisklasse definiert Zugriff Sie Objekt der Kinderklasse erstellen können.

Privat:. es Zugang in derselben Klasse sein kann

In nicht-statischen Methoden können Sie direkt zugreifen, da die diese Referenz (auch in Konstrukteurs), aber für den Zugriff auf statische Methoden, die Sie Objekt der Klasse erstellen müssen.

Zugriffsmodifikatoren in Java.

Java Zugriffsmodifikatoren verwendet wird, Zugriffskontrolle in Java zur Verfügung zu stellen.

1. Standard:

Zugänglich die Klassen im selben Paket nur.

Beispiel: 

// 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
  }
}

Dieser Zugang ist eingeschränkter als öffentliches und geschützte, aber weniger eingeschränkt als privat.

2. Öffentliche

Kann von überall zugegriffen werden. (Global Access)

Beispiel: 

// 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();
  }
}
  

Ausgabe: Hallo

3. Privat

Erreichbar nur innerhalb der gleichen Klasse.

Wenn Sie versuchen, in einem anderen privaten Mitglieder auf eine Klasse zugreifen Fehler werfen kompilieren. Zum Beispiel: 

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. Geschützte

Erreichbar nur auf die Klassen im gleichen Paket und zu den Unterklassen

Beispiel: 

// 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();
  }
}
  

Ausgabe: Hallo

Gib Bild Beschreibung hier

Ich möchte nur ein Detail adressieren, die extrem häufig falsch verstanden wird, durch die meisten Antworten auf dieser Seite mit. „Default“ Zugang (wenn kein Zugriffsmodifikator vorhanden ist) ist nicht immer die gleiche wie Paket-private . Es hängt davon ab, was die Sache ist.

  • Nicht-Mitglied-Typen (dh Klassen, Aufzählungen, Schnittstellen und Annotationstypen nicht innerhalb eines anderen Typs deklariert) sind Paket-standardmäßig privat. ( JLS §6.6.1 )

  • Die Schüler und Konstrukteure sind Paket-standardmäßig privat. ( JLS §6.6.1 )

  • Enum Bauer ist standardmäßig privat . (In der Tat, Enum contructors muss sein privat, und es ist ein Fehler, zu versuchen, sie öffentlich oder geschützt zu machen). Enum-Konstanten sind öffentlich, und erlauben keinen Zugriffsbezeichner. Andere Mitglieder von Aufzählungen sind Paket-standardmäßig privat. ( JLS §8.9 )

  • Alle Mitglieder von Schnittstellen und Annotationstypen sind standardmäßig öffentlich . (In der Tat, die Mitglieder von Schnittstellen und Annotationstypen muss öffentlich sein, und es ist ein Fehler, zu versuchen, sie privat oder geschützt zu machen.) (JLS § 9.3 bis 9.5 )

  • Öffentlichkeit -. Von überall in der Anwendung

  • Standard -. Erreichbar von Paket

  • geschützt - erreichbar von Paket und Unterklassen in anderem Paket. und

  • privat -. Erreichbar von seiner Klasse nur

Sichtbar für das Paket. Der Standard. Keine Modifikatoren erforderlich sind.

Visible zur Klasse nur ( privat ).

Visible auf der Welt ( Öffentlichkeit ).

Visible auf das Paket und alle Unterklassen ( geschützt ).

Variablen und Methoden können ohne Modifikatoren deklariert werden, die aufgerufen werden. Standard Beispiele: 

String name = "john";

public int age(){
    return age;
}

Privat Zugriffsmodifikator - privat:

Methoden, Variablen und Konstrukteuren, die privaten deklariert werden, können nur innerhalb der angegebenen Klasse selbst zugegriffen werden. Der private Zugriffsmodifikator ist die restriktivsten Zugriffsebene. Klasse und Schnittstellen können nicht privat sein.

Variablen, die privat deklariert können außerhalb der Klasse zugegriffen werden, wenn die öffentliche Getter-Methoden in der Klasse vorhanden sind.

den privaten Modifier ist die wichtigste Art und Weise, dass ein Objekt kapselt sich und versteckt Daten von der Außenwelt.

Beispiele: 

Public class Details{

    private String name;

    public void setName(String n){
        this.name = n;
    }

    public String getName(){
        return this.name;
    }
}

öffentliche Zugriffsmodifikator - public:

Eine Klasse, Methode, Konstruktor, Schnittstelle usw. erklärt Öffentlichkeit kann von jeder anderen Klasse zugegriffen werden. Daher Felder, Methoden in einer öffentlichen Klasse deklarierten Blöcke können aus jeder Klasse zugegriffen werden, die zu dem Java-Universum.

Wenn jedoch die öffentliche Klasse, die wir zugreifen möchten, in einem anderen Paket ist, dann ist die öffentliche Klasse muß noch importiert werden.

Aufgrund der Klassenvererbung, alle öffentlichen Methoden und Variablen einer Klasse werden durch ihre Unterklassen vererbt.

Beispiel: 

public void cal(){

}

Protected Zugriffsmodifikator - geschützt:

Variablen, Methoden und Konstrukteuren, die in einer übergeordneten Klasse deklarierten geschützt können nur von den Unterklassen in einer anderen Packung oder eine Klasse innerhalb der Verpackung des geschützten Mitglieds der Klasse zugegriffen werden.

Der geschützte Zugriffsmodifikator kann nicht in die Klasse und Schnittstellen angewendet werden. Methoden, Felder deklariert geschützt werden, jedoch Methoden und Felder in einer Schnittstelle können nicht geschützt deklariert werden.

Geschützter Zugriff gibt eine Chance, die Unterklasse die Hilfsmethode oder Variable zu verwenden, während eine nicht verwandte Klasse zu verhindern, versuchen, es zu verwenden. 

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

Diese Seite schreibt auch über den geschützten & Standard Zugriffsmodifikator

.... Geschützt: Geschützte Zugriffsmodifikator das ein wenig schwierig ist und man kann sagen, ist ein Superset des Standard Zugriffsmodifikator. Geschützte Mitglieder sind die gleichen wie die Standardelemente, soweit der Zugriff im gleichen Paket betroffen ist. Der Unterschied besteht darin, dass die geschützten Elemente an die Unterklassen der Klasse auch zugänglich sind in dem er deklariert wird, die außerhalb des Pakets sind, in dem die übergeordneten Klasse vorhanden ist.

Aber diese geschützten Mitglieder sind „zugänglich außerhalb des Pakets nur durch Vererbung“. d.h können Sie ein geschütztes Mitglied einer Klasse zuzugreifen in seiner Unterklasse in einem anderen Paket direkt als wenn das Mitglied in der Unterklasse vorhanden ist, selbst. Aber das geschützte Mitglied wird außerhalb des Pakets in der Unterklasse nicht zugänglich sein von Mutterklasse Referenz. ....

David Antwort liefert die Bedeutung der einzelnen Zugriffsmodifikator. Was, wenn jeder zu verwenden, würde ich vorschlagen, alle Klassen und die Methoden der einzelnen Klassen machen Öffentlichkeit, die für den externen Gebrauch bestimmt sind (seine API), und alles andere privat.

Im Laufe der Zeit werden Sie ein Gefühl für die Entwicklung, wenn einige Klassen Paket-private machen und, wenn bestimmte Verfahren zur Verwendung in Subklassen geschützt zu erklären.

. Hinweis: Dies ist nur ein ergänzen für die akzeptierte Antwort

Dies bezieht sich auf Java Zugriffsmodifizierer .

Java Zugriffsmodifizierer :

  

Ein Java Zugriffsmodifikator gibt an, welche Klassen einen bestimmten zugreifen   Klasse und ihre Felder, Konstrukteure und Methoden. Zugriffsmodifikatoren können   angegeben getrennt werden für eine Klasse, seine Erbauer, Felder und   Methoden. Java Zugriffsmodifikatoren werden auch manchmal im täglichen bezeichnet   Sprache als Java Zugriffsbezeichner, aber der richtige Name ist Java Zugang   Modifikatoren. Klassen, Felder, Konstruktoren und Methoden kann man von dem,   vier verschiedene Java Zugriffsmodifikatoren:

     
      
  • Liste item
    •   
  • privat
    •   
  • default (Paket)
    •   
  • geschützt
    •   
  • Öffentlichkeit
    •   

Kontrolle des Zugriffs auf Mitglieder einer Klasse Tutorials:

  

Zugriffsebene Modifikatoren bestimmen, ob andere Klassen ein verwenden können   bestimmten Bereich oder eine bestimmte Methode aufrufen. Es gibt zwei Ebenen   die Zugriffskontrolle:

     
      
  • Auf die oberste Ebene öffentliche oder Paket-privaten (keine expliziten Modifier).
    •   
  • Auf dem Mitglied pegel öffentlich, privat, geschützt oder Paket-privates (keine expliziten Modifier).
    •   
     

Eine Klasse kann mit dem Modifikator public deklariert werden, in dem Fall, dass   Klasse ist überall auf alle Klassen sichtbar. Wenn eine Klasse hat keinen Modifikator   (Der Standard, der auch als Paket-private bekannt), ist es nur sichtbar   innerhalb des eigenen Pakets

     

Die folgende Tabelle zeigt den Zugriff auf Mitglieder von jedem erlaubt   Modifikator. 

╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ 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     ║
╚═════════════╩═══════╩═════════╩══════════╩═══════╝
     

Die erste Datenspalte zeigt an, ob die Klasse selbst Zugriff hat   das Teil durch die Zugriffsebene definiert. Wie können Sie eine Klasse sehen immer   hat Zugriff auf ihre eigenen Mitglieder. Die zweite Spalte zeigt an, ob   Klassen im selben Paket wie die Klasse (unabhängig von ihrer   hat Abstammungs) Zugang zum Mitglied. Die dritte Spalte zeigt,   ob Subklassen der Klasse außerhalb dieses Pakets deklariert haben   Zugang zum Mitglied. Die vierte Spalte zeigt an, ob alle Klassen   haben Zugriff auf das Element.

     

Zugriffsebene beeinflussen Sie auf zwei Arten. Erstens, wenn Sie Klassen verwenden, die   kommt aus einer anderen Quelle, wie die Klassen in der Java-Plattform,   Zugriffsebenen, die Mitglieder dieser Klassen Ihre eigene bestimmen   Klassen können verwendet werden. Zweitens, wenn Sie eine Klasse schreiben, müssen Sie entscheiden,   jedes Mitglied Variable welche Zugriffsebene und jede Methode in der Klasse   haben sollte.

Public Protected Standard und sind privat Zugriffsmodifikatoren.

Sie sind für die Verkapselung oder Verstecken und zeigt Inhalte der Klasse gemeint.

  1. Klasse können öffentlich oder Verzug
  2. Klasse Mitglieder können öffentlich, geschützt, default oder privat sein.

Privat ist außerhalb der Klasse nicht zugänglich Standard ist zugänglich nur im Paket. Geschützt im Paket sowie jede Klasse, die er sich erstreckt. Öffentlich ist offen für alle.

Normalerweise Membervariablen definiert ist privat, aber Mitglied Methoden sind öffentlich.

Oft habe ich erkannt, dass die grundlegenden Konzepte von jeder Sprache Erinnerung ermöglicht kann die reale Welt Analogien, indem. Hier ist meine Analogie zum Verständnis Zugriffsmodifikatoren in Java:

Nehmen wir an, dass Sie ein Student an einer Universität sind und Sie haben einen Freund, der kommt ist man über das Wochenende zu besuchen. Angenommen, es gibt eine große Statue des Gründers der Universität in der Mitte des Campus.

  • Wenn man ihn auf den Campus bringen, das erste, was Sie und Ihr Freund sieht diese Statue ist. Das bedeutet, dass jeder, der in den Campus geht auf die Statue aussehen kann, ohne die Erlaubnis der Universität. Dies macht die Statue als PUBLIC .

  • Als nächstes möchten Sie Ihren Freund zu Ihrem Wohnheim nehmen, aber dafür müssen Sie ihn als Besucher registrieren. Das bedeutet, dass er einen Zugangspass bekommt (die die gleiche wie bei Ihnen ist) in verschiedenen Gebäuden auf dem Campus zu bekommen. Dies würde seine Zugangskarte als machen PROTECTED .

  • Ihr Freund will auf den Campus WiFi einzuloggen, aber die keine Anmeldeinformationen nicht so zu tun hat. Der einzige Weg, die er bekommen kann online ist, wenn Sie mit ihm Ihre Login teilen. (Denken Sie daran, jeder Student, der an der Universität geht besitzt auch diese Anmeldeinformationen). Dies würde Ihre Anmeldedaten wie NO MODIFIER machen.

  • Schließlich Ihr Freund will Ihren Fortschrittsbericht für das Semester lesen, die auf der Website veröffentlicht wird. jeder Schüler hat jedoch ihre eigene persönliche Login in diesem Abschnitt der Campus-Website zu gelangen. Dies würde diese Anmeldeinformationen macht als PRIVATE .

Hope, das hilft!

Wenn Sie von Zugriffsmodifikatoren denken nur daran denken, auf diese Weise (gilt für beide Variablen und Methoden ):

public -> zugänglich von jedem wo
private -> zugänglich nur innerhalb der gleichen Klasse, wo sie deklariert ist

Nun stellt sich die Verwirrung, wenn es darum geht, default und protected

default -> Kein Zugriffsmodifikator Schlüsselwort vorhanden ist. Das bedeutet, es streng innerhalb der Verpackung der Klasse zur Verfügung steht. Nowhere außerhalb des Pakets kann zugegriffen werden.

protected -> Etwas weniger strenger als default und abgesehen von den gleichen Paketklassen kann es durch Unterklassen außerhalb des Paket zugegriffen werden es wird erklärt.

Es geht um Kapselung (oder wie Joe Phillips erklärte, am wenigsten Wissen ).

Beginnen Sie mit den restriktivsten (privat) und sehen, ob Sie benötigen weniger einschränkenden Modifikatoren später.

Wir verwenden alle Verfahren und Mitglied Modifikatoren wie private, öffentliche, ... aber eine Sache zu wenig Entwickler tun, ist die Verwendung von Paketen zu organisieren Code logisch.

Zum Beispiel: Sie können in einem ‚Sicherheit‘ Paket sensible Sicherheitsmethoden setzen. Dann legen Sie eine öffentliche Klasse, die einige der sicherheitsrelevanten Code in diesem Paket greift aber halten andere Sicherheitsklassen Paket privat . So andere Entwickler werden nur die öffentlich zugängliche Klasse von außerhalb dieses Pakets verwenden können (es sei denn, sie den Modifikator ändern). Dies ist kein Sicherheitsmerkmal, sondern wird Führer Nutzung. 

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

Eine andere Sache ist, dass Klassen, die eine Menge voneinander abhängen können in der gleichen Paket landen und schließlich Refactoring oder verschmolzen werden könnten, wenn die Abhängigkeit zu stark ist.

Wenn im Gegenteil setzen Sie alles wie Öffentlichkeit es wird nicht klar sein, was sollte oder nicht zugegriffen werden, was zu schreiben viel javadoc führen kann (was nichts über den Compiler erzwingt ...).

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top