it-swarm.com.de

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

In Java gibt es klare Regeln, wann die einzelnen Zugriffsmodifikatoren verwendet werden sollen, und zwar die Standardmodifikatoren (Paket privat) public, protected und private, während class und interface und Umgang mit Vererbung?

2916
intrepion

Das offizielle Tutorial kann für Sie von Nutzen sein.

 ______________________________________________________________ 
 | │ Klasse │ Paket │ Unterklasse │ Unterklasse │ Welt | 
 | │ │ │ (gleiche Packung) │ (verschiedene Packungen) │ | 
 | ───────────┼───────┼─────────┼ ──────────┼──────────┼──────── | 
 | Public │ + │ + │ + │ + │ + | 
 | ───────────┼───────┼─────────┼──────────┼─── ───────┼──────── | 
 | Protected │ + │ + │ + │ + │ | 
 | ───────────┼───────┼─────────┼──────────┼─── ───────┼──────── | 
 | Kein Modifikator│ + │ + │ + │ │ | 
 | ───────────┼───────┼─────────┼──────────┼─── ───────┼──────── | 
 | Privat │ + │ │ │ │ | 
 | ___________ | _______ | _________ | __________ | __________ | ________ | 
 +: zugänglich leer: nicht zugänglich 
5292
David Segonds

(Warnung: Ich bin kein Java -Programmierer, ich bin ein Perl-Programmierer. Perl hat keinen formalen Schutz, weshalb ich das Problem vielleicht so gut verstehe :))

Privatgelände

Wie Sie denken, kann es nur die Klasse sehen, in der es deklariert ist.

Paket privat

Kann nur von dem Paket gesehen und verwendet werden, in dem es deklariert wurde. Dies ist die Standardeinstellung in Java (was manche als Fehler ansehen).

Geschützt

Package Private + kann von Unterklassen oder Paketmitgliedern gesehen werden.

Öffentlichkeit

Jeder kann es sehen.

Veröffentlicht

Sichtbar außerhalb des Codes, den ich kontrolliere. (Obwohl es sich nicht um eine Java -Syntax handelt, ist dies für diese Diskussion wichtig.).

C++ definiert eine zusätzliche Ebene namens "Freund" und je weniger Sie darüber wissen, desto besser.

Wann sollten Sie was verwenden? Die ganze Idee ist die Kapselung, um Informationen zu verbergen. So viel wie möglich möchten Sie den Benutzern verbergen, wie etwas getan wird. Warum? Denn dann können Sie sie später ändern und den Code von niemandem knacken. Auf diese Weise können Sie Fehler optimieren, umgestalten, umgestalten und beheben, ohne befürchten zu müssen, dass jemand den Code verwendet, den Sie gerade überarbeitet haben.

Als Faustregel gilt also, die Dinge nur so sichtbar zu machen, wie sie sein müssen. Beginnen Sie mit privat und fügen Sie nur bei Bedarf mehr Sichtbarkeit hinzu. Machen Sie nur das öffentlich, was der Benutzer unbedingt wissen muss. Jedes Detail, das Sie öffentlich machen, verkrampft Ihre Fähigkeit, das System neu zu gestalten.

Wenn Sie möchten, dass Benutzer Verhalten anpassen können, anstatt Interna öffentlich zu machen, damit sie diese überschreiben können, ist es oft besser, diese Eingeweide in ein Objekt zu schieben und diese Schnittstelle öffentlich zu machen. Auf diese Weise können sie einfach ein neues Objekt einstecken. Wenn Sie beispielsweise einen CD-Player schreiben und das Bit "Informationen zu dieser CD suchen" anpassen möchten, anstatt diese Methoden öffentlich zu machen, würden Sie all diese Funktionen in ein eigenes Objekt integrieren und nur Ihren Objekt-Getter/Setter öffentlich machen . Auf diese Weise fördert das geizige Freilegen der Eingeweide eine gute Zusammensetzung und Trennung der Bedenken

Persönlich halte ich mich nur an "privat" und "öffentlich". Viele OO Sprachen haben genau das. "Geschützt" kann praktisch sein, aber es ist wirklich ein Betrug. Sobald eine Schnittstelle mehr als privat ist, liegt sie außerhalb Ihrer Kontrolle, und Sie müssen den Code anderer Personen durchsuchen, um Verwendungen zu finden.

Hier kommt die Idee von "veröffentlicht" ins Spiel. Wenn Sie eine Schnittstelle ändern (umgestalten), müssen Sie den gesamten Code finden, der sie verwendet, und dies auch ändern. Wenn die Schnittstelle privat ist, naja kein Problem. Wenn es geschützt ist, musst du alle deine Unterklassen finden. Wenn es öffentlich ist, müssen Sie den gesamten Code finden, der Ihren Code verwendet. Manchmal ist dies möglich, wenn Sie beispielsweise an Unternehmenscode arbeiten, der nur für den internen Gebrauch bestimmt ist, spielt es keine Rolle, ob eine Schnittstelle öffentlich ist. Sie können den gesamten Code aus dem Unternehmensrepository abrufen. Aber wenn eine Schnittstelle "veröffentlicht" ist, wenn es Code gibt, der sie außerhalb Ihrer Kontrolle verwendet, dann sind Sie abgesprungen. Sie müssen diese Schnittstelle unterstützen oder riskieren, Code zu brechen. Sogar geschützte Schnittstellen können als veröffentlicht betrachtet werden (weshalb ich mich nicht mit protected beschäftige).

Viele Sprachen empfinden den hierarchischen Charakter von öffentlich/geschützt/privat als zu einschränkend und nicht realitätskonform. Zu diesem Zweck gibt es das Konzept einer Eigenschaftsklasse , aber das ist eine andere Show.

436
Schwern

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

Java Access Modifiers

Erklärungen

  • Ein privates Mitglied (i) ist nur innerhalb derselben Klasse zugänglich wie es ist erklärt.

  • Ein Member ohne Zugriffsmodifikator (j) kann nur innerhalb von Klassen im selben Paket aufgerufen werden.

  • Ein geschütztes Mitglied (k) ist in allen Klassen in demselben Paket und zugänglich. innerhalb von Unterklassen in anderen Paketen.

  • Ein öffentliches Mitglied (l) ist für alle Klassen zugänglich (es sei denn, es befindet sich in einem Modul , das dies nicht tut Exportieren Sie das Paket, in dem es deklariert ist.


Welchen Modifikator soll ich wählen?

Zugriffsmodifikatoren sind ein Tool, mit dem Sie verhindern können, dass die Kapselung versehentlich unterbrochen wird(*). Fragen Sie sich, ob Sie beabsichtigen, dass das Mitglied etwas ist, das für die Klasse, das Paket, die Klassenhierarchie oder gar nicht intern ist, und wählen Sie die Zugriffsebene entsprechend aus.

Beispiele:

  • Ein Feld long internalCounter sollte wahrscheinlich privat sein, da es veränderlich ist und ein Implementierungsdetail enthält.
  • Eine Klasse, die nur in einer Factory-Klasse (im selben Paket) instanziiert werden soll, sollte einen paketbeschränkten Konstruktor haben, da es nicht möglich sein sollte, sie direkt von außerhalb des Pakets aufzurufen.
  • Eine interne void beforeRender() -Methode, die direkt vor dem Rendern aufgerufen und als Hook in Unterklassen verwendet wird, sollte geschützt werden.
  • Eine void saveGame(File dst) -Methode, die vom GUI-Code aufgerufen wird, sollte öffentlich sein.

(*) Was genau ist Encapsulation?

366
aioobe
                | 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         |       ✔       |     ✘    |       ✘       |   ✘    
____________________________________________________________________
183
Abdull

Einfache Regel. Beginnen Sie damit, alles für privat zu erklären. Und dann Fortschritte in Richtung der Öffentlichkeit, wenn die Bedürfnisse entstehen und das Design dies rechtfertigt.

Fragen Sie sich bei der Darstellung von Mitgliedern, ob Sie Darstellungsoptionen oder Abstraktionsoptionen verfügbar machen. Das erste ist etwas, das Sie vermeiden möchten, da es zu viele Abhängigkeiten von der tatsächlichen Darstellung und nicht von ihrem beobachtbaren Verhalten hervorruft.

In der Regel versuche ich, Methodenimplementierungen nicht durch Unterklassen zu überschreiben. Es ist zu einfach, die Logik zu verkorksen. Deklarieren Sie abstrakte geschützte Methoden, wenn Sie beabsichtigen, diese zu überschreiben.

Verwenden Sie beim Überschreiben auch die Annotation @Override, um zu verhindern, dass beim Refactor Fehler auftreten.

150
John Nilsson

Es ist tatsächlich etwas komplizierter als ein einfaches Raster. Das Raster zeigt an, ob ein Zugriff zulässig ist, aber was genau ist ein Zugriff? Außerdem interagieren die Zugriffsebenen auf komplexe Weise mit verschachtelten Klassen und der Vererbung.

Der "Standard" -Zugriff (angegeben durch das Fehlen eines Schlüsselworts) wird auch als package-private bezeichnet. Ausnahme: In einer Schnittstelle bedeutet kein Modifikator öffentlichen Zugriff. Andere Modifikatoren als public sind verboten. Aufzählungskonstanten sind immer öffentlich.

Zusammenfassung

Ist ein Zugriff auf ein Mitglied mit diesem Zugriffsbezeichner zulässig?

  • Mitglied ist private: Nur wenn Mitglied in derselben Klasse wie aufrufender Code definiert ist.
  • Das Mitglied ist ein privates Paket: Nur wenn der aufrufende Code innerhalb des sofort einschließenden Pakets des Mitglieds liegt.
  • Mitglied ist protected: Das gleiche Paket, oder wenn Mitglied in einer Oberklasse der Klasse definiert ist, die den aufrufenden Code enthält.
  • Mitglied ist public: Ja.

Für welche Zugriffsspezifizierer gelten

Lokale Variablen und formale Parameter können keine Zugriffsspezifizierer annehmen. Da sie nach den Regeln des Geltungsbereichs von Natur aus nicht von außen zugänglich sind, sind sie praktisch privat.

Für Klassen im oberen Bereich sind nur public und package-private zulässig. Diese Entwurfsauswahl ist vermutlich darauf zurückzuführen, dass protected und private auf Paketebene redundant sind (es gibt keine Vererbung von Paketen).

Alle Zugriffsspezifizierer sind für Klassenmitglieder möglich (Konstruktoren, Methoden und statische Elementfunktionen, verschachtelte Klassen).

Verwandt: Java Class Accessibility

Bestellung

Die Zugangsdaten können streng geordnet werden

public> protected> package-private> private

dies bedeutet, dass public den meisten Zugriff bietet, private den geringsten. Jeder Verweis, der für ein privates Mitglied möglich ist, gilt auch für ein paketprivates Mitglied. Alle Verweise auf ein paketprivates Mitglied gelten für ein geschütztes Mitglied usw. (Es wurde als Fehler angesehen, geschützten Mitgliedern Zugriff auf andere Klassen im selben Paket zu gewähren.)

Anmerkungen

  • Die Methoden einer Klasse dürfen auf private Mitglieder anderer Objekte derselben Klasse zugreifen. Genauer gesagt, eine Methode der Klasse C kann auf private Mitglieder von C on zugreifen Objekte einer Unterklasse von C. Java unterstützen keine Einschränkung des Zugriffs nach Instanz, nur nach Klasse. (Vergleiche mit Scala, die es mit private[this] unterstützt.)
  • Sie benötigen Zugriff auf einen Konstruktor, um ein Objekt zu erstellen. Wenn also alle Konstruktoren privat sind, kann die Klasse nur von Code erstellt werden, der in der Klasse lebt (normalerweise statische Factory-Methoden oder statische Variableninitialisierer). Ähnliches gilt für paketprivate oder geschützte Konstruktoren.
    • Nur private Konstruktoren zu haben, bedeutet auch, dass die Klasse nicht extern untergeordnet werden kann, da Java erfordert, dass die Konstruktoren einer Unterklasse implizit oder explizit einen Superklassenkonstruktor aufrufen. (Es kann jedoch eine verschachtelte Klasse enthalten, die eine Unterklasse hat.)

Innere Klassen

Sie müssen auch verschachtelte Bereiche berücksichtigen, z. B. innere Klassen. Ein Beispiel für die Komplexität ist, dass innere Klassen Mitglieder haben, die selbst Zugriffsmodifikatoren annehmen können. So können Sie eine private innere Klasse mit einem öffentlichen Mitglied haben; ist das mitglied erreichbar? (Siehe unten.) Die allgemeine Regel lautet, den Umfang zu betrachten und rekursiv zu überlegen, ob Sie auf die einzelnen Ebenen zugreifen können.

Dies ist jedoch recht kompliziert, und für Einzelheiten lesen Sie siehe die Java Sprachspezifikation . (Ja, es gab in der Vergangenheit Compiler-Fehler.)

Sehen Sie sich dieses Beispiel an, um zu erfahren, wie diese interagieren. Es ist möglich, private innere Klassen zu "entleeren"; Dies ist normalerweise 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:

104

Als Faustregel gilt:

  • private: Klassenbereich.
  • default (oder package-private): Paketumfang.
  • protected: package scope + child (wie package, aber wir können es von verschiedenen Packages aus unterteilen). Der geschützte Modifikator behält immer die "Eltern-Kind" -Beziehung bei.
  • public: überall.

Infolgedessen, wenn wir das Zugriffsrecht in drei Rechte aufteilen:

  • (D) irect (Aufruf von einer Methode innerhalb derselben Klasse oder über "diese" Syntax).
  • (R) eference (Aufruf einer Methode unter Verwendung eines Verweises auf die Klasse oder über die "Punkt" -Syntax).
  • (I) Vererbung (über Unterklassen).

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   |
+—————————————————+————————————+———————————+
81
nxhoaf

Kurz gesagt

  • public: von überall zugänglich.
  • protected: Zugriff für die Klassen desselben Pakets und für die Unterklassen, die sich in einem beliebigen Paket befinden.
  • standard (kein Modifikator angegeben): Zugriff durch die Klassen desselben Pakets.
  • private: Zugriff nur innerhalb derselben Klasse.
47
Ravi

Der am häufigsten missverstandene Zugriffsmodifikator in Java ist protected. Wir wissen, dass es dem Standardmodifikator ähnlich ist, mit einer Ausnahme, in der Unterklassen es sehen können. Aber wie? Hier ist ein Beispiel, das hoffentlich die Verwirrung verdeutlicht:

  • Angenommen, wir haben 2 Klassen; Father und Son, jeweils in einer eigenen Verpackung:

    package fatherpackage;
    
    public class Father
    {
    
    }
    
    -------------------------------------------
    
    package sonpackage;
    
    public class Son extends Father
    {
    
    }
    
  • Fügen wir eine geschützte Methode foo() zu Father hinzu.

    package fatherpackage;
    
    public class Father
    {
        protected void foo(){}
    }
    
  • Die Methode foo() kann in 4 Kontexten aufgerufen werden:

    1. Innerhalb einer Klasse, die sich in demselben Paket befindet, in dem foo() definiert ist (fatherpackage):

      package fatherpackage;
      
      public class SomeClass
      {
          public void someMethod(Father f, Son s)
          {
              f.foo();
              s.foo();
          }
      }
      
    2. Innerhalb einer Unterklasse auf der aktuellen Instanz über this oder super:

      package sonpackage;
      
      public class Son extends Father
      {
          public void sonMethod()
          {
              this.foo();
              super.foo();
          }
      }
      
    3. Auf einer Referenz, deren Typ dieselbe Klasse ist:

      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, deren Typ die übergeordnete Klasse ist und inside das Paket, in dem foo() definiert ist (fatherpackage) [Dies kann in Kontext-Nr. 1]:

      package fatherpackage;
      
      public class Son extends Father
      {
          public void sonMethod(Father f)
          {
              f.foo();
          }
      }
      
  • Die folgenden Situationen sind nicht gültig.

    1. In einer Referenz, deren Typ die übergeordnete Klasse und außerhalb das Paket ist, in dem foo() definiert ist (fatherpackage):

      package sonpackage;
      
      public class Son extends Father
      {
          public void sonMethod(Father f)
          {
              f.foo(); // compilation error
          }
      }
      
    2. Eine Nicht-Unterklasse in einem Paket einer Unterklasse (Eine Unterklasse erbt die geschützten Member von ihrem übergeordneten Element und macht sie für Nicht-Unterklassen privat):

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

Privat

  • Methoden, Variablen und Konstruktoren

Auf als privat deklarierte Methoden, Variablen und Konstruktoren kann nur innerhalb der deklarierten Klasse selbst zugegriffen werden.

  • Klasse und Schnittstelle

Der Modifikator für den privaten Zugriff ist die restriktivste Zugriffsebene. Klasse und Schnittstellen können nicht privat sein.

Hinweis

Auf als privat deklarierte Variablen kann außerhalb der Klasse zugegriffen werden, wenn in der Klasse öffentliche Getter-Methoden vorhanden sind. Auf Variablen, Methoden und Konstruktoren, die in einer Superklasse als geschützt deklariert sind, kann nur von den Unterklassen in einem anderen Paket oder einer Klasse innerhalb des Pakets der Klasse der geschützten Mitglieder zugegriffen werden.


Geschützt

  • Klasse und Schnittstelle

Der Modifikator für den geschützten Zugriff kann nicht auf Klassen und Schnittstellen angewendet werden.

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

Hinweis

Geschützter Zugriff gibt der Unterklasse die Möglichkeit, die Hilfsmethode oder -variable zu verwenden, während verhindert wird, dass eine nicht verwandte Klasse versucht, sie zu verwenden.


Öffentlich

Auf eine als public deklarierte Klasse, Methode, Konstruktor, Schnittstelle usw. kann von jeder anderen Klasse aus zugegriffen werden.

Daher kann auf Felder, Methoden und Blöcke, die in einer öffentlichen Klasse deklariert sind, von jeder Klasse aus zugegriffen werden, die zum Java-Universum gehört.

  • Verschiedene Pakete

Befindet sich die öffentliche Klasse, auf die wir zugreifen möchten, jedoch in einem anderen Paket, muss die öffentliche Klasse noch importiert werden.

Aufgrund der Klassenvererbung werden alle öffentlichen Methoden und Variablen einer Klasse von ihren Unterklassen geerbt.


Standard -Nein Schlüsselwort:

Standardzugriffsmodifikator bedeutet, dass wir keinen expliziten Zugriffsmodifikator für eine Klasse, ein Feld, eine Methode usw. Deklarieren.

  • Innerhalb der gleichen Pakete

Eine Variable oder Methode, die ohne Zugriffskontrollmodifikator deklariert wurde, steht jeder anderen Klasse im selben Paket zur Verfügung. Die Felder in einer Schnittstelle sind implizit public static final und die Methoden in einer Schnittstelle sind standardmäßig public.

Hinweis

Wir können die statischen Felder nicht überschreiben. Wenn Sie versuchen, sie zu überschreiben, wird kein Fehler angezeigt, aber es funktioniert nicht, was wir außer.

Verwandte Antworten

Verweise Links

http://docs.Oracle.com/javase/tutorial/Java/javaOO/accesscontrol.htmlhttp://www.tutorialspoint.com/Java/java_access_modifiers.htm

27
Nambi

Privat: Nur eingeschränkter Zugang zur Klasse

Standard (kein Modifikator): Eingeschränkter Zugriff auf Klasse und Paket

Geschützt: Eingeschränkter Zugriff auf Klasse, Paket und Unterklassen (sowohl innerhalb als auch außerhalb des Pakets)

Public: Zugriff auf Klasse, Paket (alle) und Unterklassen ... Kurz gesagt, überall.

17
samkit shah

Der Unterschied liegt in den bereits bereitgestellten Links, aber welche man normalerweise verwendet, hängt vom "Prinzip des geringsten Wissens" ab. Erlauben Sie nur die geringste Sichtbarkeit, die benötigt wird.

16
Joe Phillips

Zugriffsmodifikatoren in Java.

Java-Zugriffsmodifikatoren werden verwendet, um die Zugriffssteuerung in Java bereitzustellen.

1. Standardeinstellung:

Nur für die Klassen im selben Paket zugänglich.

Zum 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 Zugriff ist eingeschränkter als der öffentliche und geschützte, aber weniger eingeschränkt als der private.

2. Öffentlich

Kann von überall zugegriffen werden. (Globaler Zugriff)

Zum 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

Zugänglich nur innerhalb derselben Klasse.

Wenn Sie versuchen, auf private Mitglieder einer Klasse in einer anderen zuzugreifen, tritt ein Kompilierungsfehler auf. 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ützt

Zugriff nur auf die Klassen im selben Paket und auf die Unterklassen

Zum 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

Enter image description here

14
Virtual

Zugriffsmodifikatoren dienen dazu, den Zugriff auf mehreren Ebenen einzuschränken.

Public: Grundsätzlich ist es so einfach, dass Sie von jeder Klasse aus darauf zugreifen können, ob diese sich in demselben Paket befindet oder nicht.

Wenn Sie sich in demselben Paket befinden, können Sie direkt darauf zugreifen. Wenn Sie sich jedoch in einem anderen Paket befinden, können Sie ein Objekt der Klasse erstellen.

Standard: Es ist in demselben Paket von jeder der Paketklassen aus zugänglich.

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

Geschützt: Sie können auf Variablen in demselben Paket sowie auf Unterklassen in jedem anderen Paket zugreifen. Also ist es im Grunde Standard + geerbt Verhalten.

Um auf das in der Basisklasse definierte geschützte Feld zuzugreifen, können Sie ein Objekt der untergeordneten Klasse erstellen.

Private: Es kann in derselben Klasse zugegriffen werden.

In nicht-statischen Methoden können Sie direkt über this reference (auch in Konstruktoren) darauf zugreifen. Um jedoch auf statische Methoden zugreifen zu können, müssen Sie ein Objekt der Klasse erstellen.

14
Prashant

Sichtbar für das Paket. Der Standard. Es werden keine Modifikatoren benötigt.

Nur sichtbar für die Klasse (privat).

Sichtbar für die Welt (public).

Sichtbar für das Paket und alle Unterklassen (protected).

Variablen und Methoden können ohne aufgerufene Modifikatoren deklariert werden. Standardbeispiele:

String name = "john";

public int age(){
    return age;
}

Modifikator für privaten Zugriff - privat:

Auf als privat deklarierte Methoden, Variablen und Konstruktoren kann nur innerhalb der deklarierten Klasse zugegriffen werden. Der private Zugriffsmodifikator ist die restriktivste Zugriffsebene. Klasse und Schnittstellen können nicht privat sein.

Auf als privat deklarierte Variablen kann außerhalb der Klasse zugegriffen werden, wenn in der Klasse öffentliche Getter-Methoden vorhanden sind.

Der private Modifikator ist die Hauptmethode, mit der ein Objekt sich selbst einkapselt und Daten vor der Außenwelt verbirgt.

Beispiele:

Public class Details{

    private String name;

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

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

Modifikator für öffentlichen Zugriff - public:

Auf eine als öffentlich deklarierte Klasse, Methode, Konstruktor, Schnittstelle usw. kann von jeder anderen Klasse aus zugegriffen werden. Daher kann auf Felder, Methoden und Blöcke, die in einer öffentlichen Klasse deklariert sind, von jeder Klasse aus zugegriffen werden, die zum Universum Java gehört.

Wenn sich die öffentliche Klasse, auf die wir zugreifen möchten, jedoch in einem anderen Paket befindet, muss die öffentliche Klasse noch importiert werden.

Aufgrund der Klassenvererbung werden alle öffentlichen Methoden und Variablen einer Klasse von ihren Unterklassen geerbt.

Beispiel:

public void cal(){

}

Geschützter Zugriffsmodifikator - geschützt:

Auf Variablen, Methoden und Konstruktoren, die in einer Superklasse als geschützt deklariert sind, kann nur von den Unterklassen in einem anderen Paket oder einer Klasse innerhalb des Pakets der Klasse der geschützten Mitglieder zugegriffen werden.

Der Modifikator für den geschützten Zugriff kann nicht auf Klassen und Schnittstellen angewendet werden. Methoden und Felder können als geschützt deklariert werden, Methoden und Felder in einer Schnittstelle können jedoch nicht als geschützt deklariert werden.

Geschützter Zugriff gibt der Unterklasse die Möglichkeit, die Hilfsmethode oder -variable zu verwenden, während verhindert wird, dass eine nicht verwandte Klasse versucht, sie zu verwenden.

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}
12
amila isura

Ich möchte nur ein Detail ansprechen, das extrem häufig falsch ist, einschließlich der meisten Antworten auf dieser Seite. "Standard" -Zugriff (wenn kein Zugriffsmodifikator vorhanden ist) ist nicht immer dasselbe wie package-private . Es kommt darauf an, was das Ding ist.

  • Typen, die keine Mitglieder sind (dh Klassen, Aufzählungen, Schnittstellen und Anmerkungstypen, die nicht in einem anderen Typ deklariert sind), sind standardmäßig paketprivat. ( JLS §6.6.1 )

  • Klassenmitglieder und Konstruktoren sind standardmäßig paketprivat. ( JLS §6.6.1 )

  • Enum-Konstruktoren sind standardmäßig privat . (Enum-Konstruktoren müssen privat sein, und es ist ein Fehler, sie öffentlich oder geschützt zu machen.) Enum-Konstanten sind öffentlich und erlauben keine Zugriffsspezifizierer. Andere Mitglieder von Enums sind standardmäßig paketprivat. ( JLS §8.9 )

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

12
Boann
  • public - Zugriff von überall in der Anwendung.

  • Standard - Zugriff vom Paket.

  • protected - Zugriff über Pakete und Unterklassen in anderen Paketen. auch

  • privat - nur von seiner Klasse zugänglich.

12

Diese Seite beschreibt den Modifikator protected & default

.... Geschützt: Der Modifikator für den geschützten Zugriff ist etwas knifflig, und Sie können sagen, dass er eine Obermenge des Standardmodifikators für den Zugriff ist. Geschützte Mitglieder sind dieselben wie die Standardmitglieder, was den Zugriff in demselben Paket betrifft. Der Unterschied besteht darin, dass die geschützten Member auch für die Unterklassen der Klasse, in der das Member deklariert ist, zugänglich sind, die sich außerhalb des Pakets befinden, in dem die übergeordnete Klasse vorhanden ist.

Diese geschützten Mitglieder sind jedoch „nur durch Vererbung außerhalb des Pakets zugänglich“. Sie können direkt auf ein geschütztes Mitglied einer Klasse in ihrer Unterklasse zugreifen, die in einem anderen Paket enthalten ist, als ob das Mitglied in der Unterklasse selbst vorhanden wäre. Auf dieses geschützte Mitglied kann jedoch in der Unterklasse außerhalb des Pakets nicht über die Referenz der übergeordneten Klasse zugegriffen werden. ....

10
dameng

Davids Antwort enthält die Bedeutung der einzelnen Zugriffsmodifikatoren. Als Verwendungszeitpunkt würde ich vorschlagen, alle Klassen und die Methoden jeder Klasse, die für die externe Verwendung bestimmt sind (ihre API), und alles andere als privat öffentlich zu machen.

Im Laufe der Zeit werden Sie ein Gespür dafür entwickeln, wann einige Klassen paketprivat gemacht werden müssen und wann bestimmte Methoden für die Verwendung in Unterklassen als geschützt deklariert werden müssen.

8
Dov Wasserman

Hinweis: Dies ist nur eine Ergänzung für die akzeptierte Antwort.

Dies bezieht sich auf Java Access Modifiers .

From Java Access Modifiers :

Ein Zugriffsmodifikator Java gibt an, welche Klassen auf eine bestimmte Klasse und deren Felder, Konstruktoren und Methoden zugreifen können. Zugriffsmodifikatoren können für eine Klasse, ihre Konstruktoren, Felder und Methoden separat angegeben werden. Java Zugriffsmodifikatoren werden in der täglichen Sprache manchmal auch als Java Zugriffsspezifikatoren bezeichnet, der korrekte Name lautet jedoch Java Zugriffsmodifikatoren. Klassen, Felder, Konstruktoren und Methoden können einen von vier verschiedenen Zugriffsmodifikatoren Java haben:

  • Listenpunkt
  • privatgelände
  • standard (Paket)
  • geschützt
  • öffentlichkeit

From Steuern des Zugriffs auf Klassenmitglieder Tutorials:

Zugriffsebenenmodifikatoren bestimmen, ob andere Klassen ein bestimmtes Feld verwenden oder eine bestimmte Methode aufrufen können. Es gibt zwei Ebenen der Zugangskontrolle:

  • Auf der obersten Ebene - public oder package-private (kein expliziter Modifikator).
  • Auf Mitgliedsebene - öffentlich, privat, geschützt oder paketprivat (kein expliziter Modifikator).

Eine Klasse kann mit dem Modifikator public deklariert werden. In diesem Fall ist diese Klasse für alle Klassen überall sichtbar. Wenn eine Klasse keinen Modifizierer hat (der Standardwert, auch als package-private bezeichnet), ist sie nur innerhalb ihres eigenen Pakets sichtbar

Die folgende Tabelle zeigt den Zugriff auf Mitglieder, die von den einzelnen Modifikatoren zugelassen werden.

╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ 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 gibt an, ob die Klasse selbst Zugriff auf das durch die Zugriffsebene definierte Mitglied hat. Wie Sie sehen, hat eine Klasse immer Zugriff auf ihre eigenen Mitglieder. Die zweite Spalte gibt an, ob Klassen im selben Paket wie die Klasse (unabhängig von ihrer Herkunft) Zugriff auf das Mitglied haben. Die dritte Spalte gibt an, ob Unterklassen der Klasse, die außerhalb dieses Pakets deklariert wurden, Zugriff auf das Mitglied haben. Die vierte Spalte gibt an, ob alle Klassen Zugriff auf das Mitglied haben.

Zugriffsebenen wirken sich auf zwei Arten auf Sie aus. Wenn Sie Klassen verwenden, die aus einer anderen Quelle stammen, z. B. die Klassen in der Plattform Java, bestimmen die Zugriffsebenen zunächst, welche Mitglieder dieser Klassen von Ihren eigenen Klassen verwendet werden können. Zweitens müssen Sie beim Schreiben einer Klasse entscheiden, welche Zugriffsebene jede Mitgliedsvariable und jede Methode in Ihrer Klasse haben soll.

Public Protected Default und Private sind Zugriffsmodifikatoren.

Sie dienen zum Einkapseln oder Ausblenden und Anzeigen von Inhalten der Klasse.

  1. Die Klasse kann public oder default sein
  2. Klassenmitglieder können öffentlich, geschützt, standardmäßig oder privat sein.

Privat ist außerhalb der Klasse nicht zugänglich. Standardmäßig ist nur im Paket ein Zugriff möglich. Geschützt im Paket sowie in jeder Klasse, die es erweitert. Öffentlichkeit ist offen für alle.

Normalerweise werden Member-Variablen als privat definiert, aber Member-Methoden sind öffentlich.

5
richa_v

Oft wurde mir klar, dass das Erinnern an die Grundbegriffe einer Sprache durch die Schaffung realer Analogien möglich wird. Hier ist meine Analogie zum Verständnis von Zugriffsmodifikatoren in Java:

Nehmen wir an, Sie sind Student an einer Universität und Sie haben einen Freund, der Sie über das Wochenende besucht. Angenommen, in der Mitte des Campus befindet sich eine große Statue des Universitätsgründers.

  • Wenn Sie ihn zum Campus bringen, sehen Sie und Ihr Freund als Erstes diese Statue. Das bedeutet, dass jeder, der auf dem Campus spazieren geht, die Statue ohne Erlaubnis der Universität besichtigen kann. Dies macht die Statue zu PUBLIC.

  • Als Nächstes möchten Sie Ihren Freund in Ihr Wohnheim bringen, müssen ihn jedoch als Besucher registrieren. Dies bedeutet, dass er einen Zutrittsausweis (der mit Ihrem identisch ist) erhält, um in verschiedene Gebäude auf dem Campus zu gelangen. Dies würde seine Zugangskarte zu PROTECTED machen.

  • Ihr Freund möchte sich beim Campus-WLAN anmelden, verfügt jedoch nicht über die erforderlichen Anmeldeinformationen. Er kann nur online gehen, wenn Sie ihm Ihr Login mitteilen. (Denken Sie daran, dass jeder Student, der an die Universität geht, auch über diese Anmeldeinformationen verfügt.) Dies würde Ihre Anmeldeinformationen als NO MODIFIER.

  • Schließlich möchte Ihr Freund Ihren Fortschrittsbericht für das Semester lesen, der auf der Website veröffentlicht wird. Jeder Student hat jedoch ein eigenes persönliches Login, um auf diesen Bereich der Campus-Website zuzugreifen. Dies würde diese Anmeldeinformationen zu PRIVATE machen.

Hoffe das hilft!

5
Greedy Coder

Wenn Sie an Zugriffsmodifikatoren denken, denken Sie einfach so (gilt sowohl für Variablen als auch für Methoden):

public -> von überall zugänglich
private -> nur innerhalb derselben Klasse zugänglich, in der es deklariert ist

Jetzt entsteht die Verwirrung, wenn es um default und protected geht

default -> Es ist kein Schlüsselwort für den Zugriffsmodifikator vorhanden. Dies bedeutet, dass es nur innerhalb des Pakets der Klasse verfügbar ist. Nirgendwo Außerhalb dieses Pakets kann darauf zugegriffen werden.

protected -> Etwas weniger streng als default und abgesehen von denselben Paketklassen können Unterklassen außerhalb des Pakets darauf zugreifen es wird deklariert.

4
Pritam Banerjee

Es geht um Verkapselung (oder wie Joe Phillips sagte, geringstes Wissen ).

Beginnen Sie mit den restriktivsten (privaten) Modifikatoren und prüfen Sie, ob Sie später weniger restriktive Modifikatoren benötigen.

Wir alle verwenden Methoden- und Member-Modifikatoren wie private, public, ..., aber eine Sache, die zu wenige Entwickler tun, ist die Verwendung von Paketen, um Code logisch zu organisieren .

Beispiel: Sie können vertrauliche Sicherheitsmethoden in ein Sicherheitspaket einfügen. Fügen Sie dann eine öffentliche Klasse ein, die auf einen Teil des sicherheitsrelevanten Codes in diesem Paket zugreift, während andere Sicherheitsklassen das Paket für sich behalten . Daher können andere Entwickler die öffentlich verfügbare Klasse nur von außerhalb dieses Pakets verwenden (es sei denn, sie ändern den Modifikator). Dies ist kein Sicherheitsmerkmal, wird aber die Verwendung leiten .

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

Eine andere Sache ist, dass Klassen, die stark voneinander abhängen, möglicherweise im selben Paket landen und möglicherweise überarbeitet oder zusammengeführt werden, wenn die Abhängigkeit zu groß ist.

Wenn Sie im Gegenteil alles als public festlegen, ist nicht klar, auf was zugegriffen werden soll oder nicht, was dazu führen kann, dass viel Javadoc geschrieben wird (was nichts über erzwingt) der Compiler ...).

2

Zugriffsmodifikatoren

enter image description here

Ich mag Jenkovs Artikel

In der folgenden Tabelle wird zusammengefasst, was Java für jeden Java Zugriffsmodifikator erstellt: enter image description here

privatgelände

Wenn eine Methode oder Variable als privat markiert ist (der Modifikator für den privaten Zugriff zugewiesen ist), kann nur Code innerhalb derselben Klasse auf die Variable zugreifen oder die Methode aufrufen. Code in Unterklassen kann weder auf die Variable oder Methode zugreifen noch von einer externen Klasse aus codieren.

Klassen können nicht mit dem Modifikator "Privater Zugriff" markiert werden. Das Markieren einer Klasse mit dem Modifikator "Privater Zugriff" würde bedeuten, dass keine andere Klasse darauf zugreifen kann, was bedeutet, dass Sie die Klasse überhaupt nicht wirklich verwenden können. Daher ist der private Zugriffsmodifikator für Klassen nicht zulässig.

default

Der Standardzugriffsmodifizierer Java wird deklariert, indem überhaupt kein Zugriffsmodifizierer geschrieben wird. Der Standardzugriffsmodifikator bedeutet, dass Code innerhalb der Klasse selbst sowie Code innerhalb von Klassen im selben Paket wie diese Klasse auf die Klasse, das Feld, den Konstruktor oder die Methode zugreifen kann, der bzw. der der Standardzugriffsmodifikator zugewiesen ist. Daher wird der Standardzugriffsmodifikator manchmal auch als Paketzugriffsmodifikator bezeichnet.

geschützt

Der Modifikator für den geschützten Zugriff bietet denselben Zugriff wie der Standardzugriffsmodifikator, mit dem Zusatz, dass Unterklassen auf geschützte Methoden und Elementvariablen (Felder) der Oberklasse zugreifen können. Dies gilt auch dann, wenn sich die Unterklasse nicht im selben Paket wie die Superklasse befindet.

öffentlichkeit

Der Zugriffsmodifikator Java public bedeutet, dass der gesamte Code auf die Klasse, das Feld, den Konstruktor oder die Methode zugreifen kann, unabhängig davon, wo sich der Zugriffscode befindet. Der Zugangscode kann sich in einer anderen Klasse und in einem anderen Paket befinden.

2
yoAlex5