Qual è la differenza tra public, protected, package-private e private in Java?

(Avvertenza: non sono un programmatore Java, sono un programmatore Perl. Perl non ha protezioni formali che è forse il motivo per cui capisco così bene il problema:))

Privato

Come si potrebbe pensare, solo la classe in cui è dichiarato può vederlo.

Pacchetto privato

Può essere visto e utilizzato solo dal pacchetto in cui è stato dichiarato. Questo è il valore predefinito in Java (che alcuni vedono come un errore).

Protetto

Pacchetto Privato + può essere visto da sottoclassi o membro del pacchetto.

Pubblico

Tutti possono vederlo.

Pubblicato

Visibile al di fuori del codice che controllo. (Anche se non la sintassi Java, è importante per questa discussione).

C++ definisce un livello aggiuntivo chiamato "amico" e meno ne sai, meglio è.

Quando dovresti usare cosa? L'intera idea è l'incapsulamento per nascondere le informazioni. Per quanto possibile vuoi nascondere il dettaglio di come è qualcosa fatto dai tuoi utenti. Perché? Perché poi puoi cambiarli in un secondo momento e non rompere il codice di nessuno. Ciò consente di ottimizzare, refactoring, riprogettare e correggere i bug senza preoccuparsi che qualcuno stesse usando quel codice che hai appena revisionato.

Quindi, la regola empirica è rendere le cose visibili solo come devono essere. Inizia con private e aggiungi solo più visibilità se necessario. Solo rendere pubblico ciò che è assolutamente necessario per l'utente di sapere, ogni dettaglio si fanno crampi pubblici la vostra capacità di riprogettare il sistema.

Se vuoi che gli utenti siano in grado di personalizzare i comportamenti, piuttosto che rendere pubblici gli interni in modo che possano sovrascriverli, è spesso un'idea migliore spingere quelle budella in un oggetto e rendere pubblica quell'interfaccia. In questo modo possono semplicemente collegare un nuovo oggetto. Ad esempio, se stavi scrivendo un lettore CD e volevi che il bit" go find info about this CD " fosse personalizzabile, piuttosto che rendere pubblici quei metodi, avresti messo tutta quella funzionalità nel proprio oggetto e reso solo il tuo oggetto getter / setter pubblico. In questo modo essere avaro di esporre il tuo coraggio incoraggia una buona composizione e separazione delle preoccupazioni

Personalmente, mi attengo solo a "privato"e " pubblico". Molte lingue OO hanno proprio questo. "Protetto" può essere utile, ma è davvero un imbroglio. Una volta che un'interfaccia è più che privata, è al di fuori del tuo controllo e devi andare a cercare il codice di altre persone per trovare gli usi.

È qui che entra in gioco l'idea di "pubblicato". Evoluzione un'interfaccia (refactoring) richiede che tu trovi tutto il codice che lo sta usando e cambi anche quello. Se l'interfaccia è privata, beh nessun problema. Se è protetto devi andare a trovare tutte le sottoclassi. Se è pubblico devi andare a trovare tutto il codice che usa il tuo codice. A volte questo è possibile, ad esempio se stai lavorando su codice aziendale solo per uso interno, non importa se un'interfaccia è pubblica. Puoi estrarre tutto il codice dal repository aziendale. Ma se un'interfaccia è "pubblicata", se c'è del codice che lo usa al di fuori del tuo controllo, allora sei bloccato. È necessario supportare tale interfaccia o rischio di codice di rottura. Anche le interfacce protette possono essere considerate pubblicate (motivo per cui non mi preoccupo di protected).

Molte lingue ritengono che la natura gerarchica di pubblico/protetto/privato sia troppo limitante e non in linea con la realtà. A tal fine c'è il concetto di una classe di tratti , ma questo è un altro spettacolo.

Ecco una versione migliore della tabella. (A prova di futuro con una colonna per i moduli.)

Spiegazioni

• Un membro privato è solo accessibile all'interno della stessa classe dichiarata.

• Un membro con nessun modificatore di accesso è accessibile solo all'interno delle classi dello stesso pacchetto.

• Un membro protetto è accessibile in tutte le classi nello stesso pacchetto e all'interno di sottoclassi in altri pacchetti.

• Un membro public è accessibile a tutte le classi (a meno che non risieda in un modulo che non esporta il pacchetto in cui è dichiarato).

Quale modificatore scegliere?

Modificatori di accesso è uno strumento per aiutare a prevenire accidentalmente rompere l'incapsulamento^(*). Chiedetevi se si intende il membro di essere qualcosa che è interno al classe, pacchetto, gerarchia di classi o non interno a tutti, e scegliere il livello di accesso di conseguenza.

Esempi:

• Un campo long internalCounter dovrebbe probabilmente essere privato poiché è mutabile e un dettaglio di implementazione.
• Una classe che dovrebbe essere istanziata solo in una classe factory (nello stesso pacchetto) dovrebbe avere un costruttore limitato al pacchetto, poiché non dovrebbe essere possibile chiamarla direttamente dall'esterno del pacchetto.
• Un metodo interno void beforeRender() chiamato proprio prima del rendering e utilizzato come hook in sottoclassi dovrebbe essere protetto.
• Un metodo void saveGame(File dst) che viene chiamato dal codice GUI dovrebbe essere pubblico.

^{(*) Cos'è esattamente l'incapsulamento?}

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

Regola facile. Inizia con la dichiarazione di tutto privato. E poi progredire verso il pubblico man mano che sorgono i bisogni e il design lo garantisce.

Quando esponete i membri chiedetevi se state esponendo scelte di rappresentazione o scelte di astrazione. Il primo è qualcosa che vuoi evitare in quanto introdurrà troppe dipendenze sulla rappresentazione effettiva piuttosto che sul suo comportamento osservabile.

Come regola generale cerco di evitare di sovrascrivere le implementazioni del metodo mediante sottoclassi; e ' troppo facile rovinare la logica. Dichiarare i metodi protetti astratti se si intende sovrascriverli.

Inoltre, utilizzare l'annotazione @Override quando si esegue l'override per evitare che le cose si rompano quando si esegue il refactoring.

In realtà è un po ' più complicato di quanto mostri una semplice griglia. La griglia ti dice se è consentito un accesso, ma cosa costituisce esattamente un accesso? Inoltre, i livelli di accesso interagiscono con le classi nidificate e l'ereditarietà in modi complessi.

L'accesso "predefinito" (specificato dall'assenza di una parola chiave) viene anche chiamato pacchetto-privato. Eccezione: in un'interfaccia, nessun modificatore significa accesso pubblico; modificatori diversi dal pubblico sono vietati. Le costanti Enum sono sempre pubblico.

Riassunto

È consentito l'accesso a un membro con questo identificatore di accesso?

• Il membro è private: solo se il membro è definito all'interno della stessa classe del codice di chiamata.
• Il membro è un pacchetto privato: solo se il codice chiamante si trova all'interno del pacchetto immediatamente racchiuso dal membro.
• Membro è protected: Stesso pacchetto, o se membro è definito in una superclasse della classe contenente il codice chiamante.
• Il membro è public: Sì.

A quali specificatori di accesso si applicano

Le variabili locali e i parametri formali non possono accettare gli specificatori di accesso. Poiché sono intrinsecamente inaccessibili all'esterno secondo le regole di scoping, sono effettivamente privati.

Per le classi nell'ambito principale, sono consentiti solo public e package-private. Questa scelta di progettazione è presumibilmente perché protected e private sarebbero ridondanti a livello di pacchetto (non c'è ereditarietà di pacchetti).

Tutte le gli specificatori di accesso sono possibili sui membri della classe (costruttori, metodi e funzioni membro statiche, classi nidificate).

Correlato: Accessibilità della classe Java

Ordine

Gli identificatori di accesso possono essere ordinati rigorosamente

Pubblico > protetto > pacchetto-privato > privato

Significa che public fornisce il maggior accesso, private il minimo. Qualsiasi riferimento possibile su un membro privato è valido anche per un membro pacchetto-privato; qualsiasi il riferimento a un membro privato del pacchetto è valido su un membro protetto e così via. (Dare accesso ai membri protetti ad altre classi nello stesso pacchetto è stato considerato un errore.)

Note

• I metodi di una classe sono autorizzati ad accedere a membri privati di altri oggetti della stessa classe. Più precisamente, un metodo di classe C può accedere a membri privati di C su oggetti di qualsiasi sottoclasse di C. Java non supporta la limitazione dell'accesso per istanza, solo da classe. (Confronta con Scala, che lo supporta usando private[this].)
• È necessario accedere a un costruttore per costruire un oggetto. Pertanto, se tutti i costruttori sono privati, la classe può essere costruita solo dal codice che vive all'interno della classe (in genere metodi di fabbrica statici o inizializzatori variabili statiche). Allo stesso modo per i costruttori di pacchetti privati o protetti.
  • Avere solo costruttori privati significa anche che la classe non può essere sottoclassata esternamente, poiché Java richiede un i costruttori di sottoclasse per chiamare implicitamente o esplicitamente un costruttore di superclasse. (Può, tuttavia, contenere una classe nidificata che la sottoclasse.)

Classi interne

Devi anche considerare gli ambiti annidati , come le classi interne. Un esempio della complessità è che le classi interne hanno membri, che a loro volta possono prendere modificatori di accesso. Quindi puoi avere una classe interna privata con un membro pubblico; è possibile accedere al membro? (Vedi sotto.) Il regola generale è quello di guardare ambito e pensare in modo ricorsivo per vedere se è possibile accedere a ogni livello.

Tuttavia, questo è piuttosto complicato, e per tutti i dettagli, consultare le specifiche del linguaggio Java. (Sì, ci sono stati bug del compilatore in passato.)

Per un assaggio di come questi interagiscono, prendere in considerazione questo esempio. È possibile "perdere" classi interne private; questo di solito è un avvertimento:

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

Uscita del compilatore:

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

Alcuni correlati traccia smal:

• Java-Metodo accessibilità all'interno del pacchetto-classe privata?

Come regola generale:

• privato : ambito di classe.
• default (o pacchetto-privato): ambito del pacchetto.
• protected : ambito del pacchetto + child (come il pacchetto, ma possiamo sottoclassarlo da pacchetti diversi). Il modificatore protetto mantiene sempre la relazione "genitore-figlio".
• pubblico : ovunque.

Di conseguenza, se dividiamo il diritto di accesso in tre diritti:

• (D)irect (invocare da un metodo all'interno della stessa classe).
• (R)eference (invocare un metodo utilizzando un riferimento alla classe o tramite la sintassi "dot").
• (I) nheritance (tramite sottoclasse).

Allora abbiamo questa semplice tabella:

+—-———————————————+————————————+———————————+
|                 |    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 breve

• public: accessibile da ogni luogo.
• protected: accessibile dalle classi dello stesso pacchetto e dalle sottoclassi che risiedono in qualsiasi pacchetto.
• default (nessun modificatore specificato): accessibile dalle classi dello stesso pacchetto.
• private: accessibile solo all'interno della stessa classe.

Il modificatore di accesso più frainteso in Java è protected. Sappiamo che è simile al modificatore predefinito con un'eccezione in cui le sottoclassi possono vederlo. Ma come? Ecco un esempio che si spera chiarisca la confusione:

• Supponiamo di avere 2 classi; Father e Son, ciascuna nel proprio pacchetto:

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

• Aggiungiamo un metodo protetto foo() a Father.

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

• Il metodo foo() può essere chiamato in 4 contesti:

  1. All'interno di una classe che si trova nello stesso pacchetto in cui è definito foo() (fatherpackage):

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

  2. All'interno di una sottoclasse, sull'istanza corrente tramite this o super:

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

  3. Su un riferimento il cui tipo è la stessa classe:

     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. Su un riferimento il cui tipo è la classe genitore ed è all'interno di il pacchetto in cui è definito foo() (fatherpackage) [Questo può essere incluso all'interno del contesto n. 1]:

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

• Le seguenti situazioni non sono valide.

  1. Su un riferimento il cui tipo è la classe genitore ed è al di fuori di il pacchetto in cui è definito foo() (fatherpackage):

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

  2. Una non sottoclasse all'interno di un pacchetto di una sottoclasse (Una sottoclasse eredita i membri protetti dal suo genitore e li rende privati di non sottoclassi):

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

Privato

• Metodi, variabili e costruttori

I metodi, le variabili e i costruttori dichiarati privati sono accessibili solo all'interno della classe dichiarata stessa.

• Classe e interfaccia

Modificatore di accesso privato è il livello di accesso più restrittivo. La classe e le interfacce non possono essere private.

Nota

È possibile accedere alle variabili dichiarate private al di fuori della classe se i metodi getter pubblici sono presenti nella classe. Le variabili, i metodi e i costruttori dichiarati protetti in una superclasse sono accessibili solo dalle sottoclassi in un altro pacchetto o da qualsiasi classe all'interno del pacchetto della classe dei membri protetti.

Protetto

• Classe e interfaccia

Il modificatore di accesso protetto non può essere applicato alla classe e interfaccia.

Metodi, campi possono essere dichiarati protetti, tuttavia metodi e campi in un'interfaccia non possono essere dichiarati protetti.

Nota

L'accesso protetto offre alla sottoclasse la possibilità di utilizzare il metodo o la variabile helper, impedendo al contempo a una classe non correlata di tentare di utilizzarla.

Pubblico

Una classe, un metodo, un costruttore, un'interfaccia ecc. essere accessibile da qualsiasi altra classe.

Pertanto è possibile accedere a campi, metodi, blocchi dichiarati all'interno di una classe pubblica da qualsiasi classe appartenente all'Universo Java.

• Pacchetti diversi

Tuttavia, se la classe pubblica a cui stiamo tentando di accedere si trova in un pacchetto diverso, la classe pubblica deve ancora essere importata.

A causa dell'ereditarietà della classe, tutti i metodi e le variabili pubbliche di una classe sono ereditato dalle sue sottoclassi.

Default - Nessuna parola chiave:

Modificatore di accesso predefinito significa che non dichiariamo esplicitamente un modificatore di accesso per una classe, un campo, un metodo, ecc.

• All'interno degli stessi pacchetti

Una variabile o un metodo dichiarato senza alcun modificatore di controllo di accesso è disponibile per qualsiasi altra classe nello stesso pacchetto. I campi in un'interfaccia sono implicitamente pubblici statici finali e i metodi in un'interfaccia sono di default pubblici.

Nota

Non possiamo ignorare i campi statici.se si tenta di sovrascrivere non mostra alcun errore ma non funziona quello che noi tranne.

Risposte correlate

• Sovrascrivere i metodi statici in java

Riferimenti collegamenti

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

La differenza può essere trovata nei collegamenti già forniti, ma quale usare di solito si riduce al "Principio della minima conoscenza". Consentire solo la minima visibilità necessaria.

Privato: Accesso limitato solo alla classe

Default (nessun modificatore): Accesso limitato alla classe e al pacchetto

Protetto : accesso limitato a classe, pacchetto e sottoclassi (sia all'interno che all'esterno del pacchetto)

Public : Accessibile a classe, pacchetto (tutti) e sottoclassi... In breve, ovunque.

Modificatori di accesso in Java.

I modificatori di accesso Java vengono utilizzati per fornire il controllo degli accessi in Java.

1. Impostazione predefinita:

Accessibile solo alle classi dello stesso pacchetto.

Ad esempio,

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

Questo accesso è più limitato di pubblico e protetto, ma meno limitato di privato.

2. Pubblico

È accessibile da qualsiasi luogo. (Accesso globale)

Ad esempio,

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

Uscita: Ciao

3. Privato

Accessibile solo all'interno della stessa classe.

Se si tenta di accedere ai membri privati su una classe in un altro genererà errore di compilazione. Ad esempio,

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. Protetto

Accessibile solo alle classi dello stesso pacchetto e alle sottoclassi

Ad esempio,

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

Uscita: Ciao

I modificatori di accesso sono disponibili per limitare l'accesso a più livelli.

Public: È fondamentalmente semplice come puoi accedere da qualsiasi classe, sia che si trovi nello stesso pacchetto o meno.

Per accedere se sei nello stesso pacchetto puoi accedere direttamente, ma se sei in un altro pacchetto puoi creare un oggetto della classe.

Default: È accessibile nello stesso pacchetto da qualsiasi classe di pacchetto.

Per accedere è possibile creare un oggetto della classe. Ma non è possibile accedere a questa variabile al di fuori del pacchetto.

Protected: è possibile accedere a variabili nello stesso pacchetto e sottoclasse in qualsiasi altro pacchetto. quindi in pratica è il comportamento predefinito + Ereditato .

Per accedere al campo protetto definito nella classe base è possibile creare oggetto della classe figlio.

Privato: può essere accesso nella stessa classe.

Nei metodi non statici è possibile accedere direttamente a causa di questo riferimento (anche nei costruttori) ma per accedere ai metodi statici è necessario creare l'oggetto della classe.

Visibile al pacchetto. Predefinito. Non sono necessari modificatori.

Visibile solo alla classe ( privato ).

Visibile al mondo ( pubblico ).

Visibile al pacchetto e a tutte le sottoclassi (protetta ).

Variabili e metodi possono essere dichiarati senza modificatori che vengono chiamati. Esempi predefiniti:

String name = "john";

public int age(){
    return age;
}

Modificatore di accesso privato-privato:

I metodi, le variabili e i costruttori dichiarati privati possono essere accesso all'interno della classe dichiarata stessa. Il modificatore di accesso privato è il livello di accesso più restrittivo. La classe e le interfacce non possono essere private.

Le variabili dichiarate private sono accessibili all'esterno della classe se nella classe sono presenti metodi getter pubblici.

L'utilizzo del modificatore privato è il modo principale in cui un oggetto si incapsula e nasconde i dati dal mondo esterno.

Esempi:

Public class Details{

    private String name;

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

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

Modificatore di accesso pubblico-pubblico:

A classe, metodo, costruttore, interfaccia, ecc. è possibile accedere a public dichiarato da qualsiasi altra classe. Pertanto è possibile accedere a campi, metodi, blocchi dichiarati all'interno di una classe pubblica da qualsiasi classe appartenente all'universo Java.

Tuttavia, se la classe pubblica a cui stiamo tentando di accedere si trova in un pacchetto diverso, la classe pubblica deve ancora essere importata.

A causa dell'ereditarietà della classe, tutti i metodi e le variabili pubbliche di una classe vengono ereditati sottoclassi.

Esempio:

public void cal(){

}

Accesso protetto - protetto dal modificatore:

Le variabili, i metodi e i costruttori dichiarati protetti in una superclasse sono accessibili solo dalle sottoclassi in un altro pacchetto o da qualsiasi classe all'interno del pacchetto della classe dei membri protetti.

Il modificatore di accesso protetto non può essere applicato alla classe e alle interfacce. Metodi, campi possono essere dichiarati protetti, tuttavia metodi e campi in un'interfaccia non possono essere dichiarati protetto.

L'accesso protetto dà alla sottoclasse la possibilità di utilizzare il metodo o la variabile helper, impedendo al contempo a una classe non correlata di tentare di utilizzarla.

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

• Pubblico - accessibile da qualsiasi punto dell'applicazione.

• Default - accessibile dal pacchetto.

• Protetto-accessibile da pacchetti e sottoclassi in altri pacchetti. anche

• Privato - accessibile solo dalla sua classe.

Voglio solo affrontare un dettaglio che è estremamente comunemente sbagliato, incluso dalla maggior parte delle risposte in questa pagina. L'accesso"predefinito" (quando non è presente alcun modificatore di accesso) non è sempre lo stesso di package-private . Dipende da cosa è la cosa.

• I tipi non membri (ovvero classi, enumerazioni, interfacce e tipi di annotazione non dichiarati all'interno di un altro tipo) sono privati del pacchetto per impostazione predefinita. (JLS §6.6.1)

• Membri della classe e i costruttori sono privati dei pacchetti per impostazione predefinita. (JLS §6.6.1)

• I costruttori Enum sono privati per impostazione predefinita . (Infatti, enum contructors deve essere privato, ed è un errore cercare di renderli pubblici o protetti). Le costanti Enum sono pubbliche e non consentono alcun identificatore di accesso. Gli altri membri di enums sono package-private per impostazione predefinita. ( JLS §8.9)

• Tutti i membri di interfacce e tipi di annotazione sono pubblici da predefinito. (Infatti, i membri di interfacce e tipi di annotazione devono essere pubblici, ed è un errore cercare di renderli privati o protetti.) (JLS §9.3 a 9.5)

Questa pagina scrive bene sul modificatore di accesso protetto e predefinito

.... Protetto: Il modificatore di accesso protetto è un po ' complicato e si può dire che è un superset del modificatore di accesso predefinito. I membri protetti sono uguali ai membri predefiniti per quanto riguarda l'accesso nello stesso pacchetto. La differenza è che i membri protetti sono accessibili anche alle sottoclassi della classe in cui viene dichiarato il membro che si trovano al di fuori del pacchetto in cui la classe genitore è presente.

Ma questi membri protetti sono "accessibili al di fuori del pacchetto solo attraverso l'ereditarietà". cioè è possibile accedere a un membro protetto di una classe nella sua sottoclasse presente in qualche altro pacchetto direttamente come se il membro fosse presente nella sottoclasse stessa. Ma quel membro protetto non sarà accessibile nella sottoclasse al di fuori del pacchetto utilizzando il riferimento della classe genitore. ....

La risposta di David fornisce il significato di ogni modificatore di accesso. Per quanto riguarda quando usare ciascuno, suggerirei di rendere pubbliche tutte le classi e i metodi di ogni classe che sono pensati per uso esterno (la sua API) e tutto il resto privato.

Nel tempo svilupperai un senso per quando rendere alcune classi private del pacchetto e quando dichiarare determinati metodi protetti per l'uso nelle sottoclassi.

• Visibile al pacchetto. il predefinito . Non sono necessari modificatori.
• Visibile solo alla classe; privato .
• Visibile al mondo; pubblico .
• Visibile al pacchetto e a tutte le sottoclassi; protetto .

Quindi parliamo del controllo degli accessi e dell'ereditarietà Le seguenti regole per i metodi ereditati sono,

• Anche i metodi dichiarati public in una superclasse devono essere pubblici in tutti sottoclassi.
• I metodi dichiarati protected in una superclasse devono essere protected o public nelle sottoclassi; non possono essere private.
• I metodi dichiarati senza controllo di accesso (non è stato utilizzato alcun modificatore) possono essere dichiarato più privato nelle sottoclassi.
• I metodi dichiarati private non sono affatto ereditati, quindi non c'è regola per loro.

Nota: Questo è solo un supplemento per la risposta accettata.

Questo è correlato a Java Modificatori di accesso.

Da Modificatori di accesso Java :

Un modificatore di accesso Java specifica quali classi possono accedere a un dato classe e suoi campi, costruttori e metodi. I modificatori di accesso possono essere specificato separatamente per una classe, i suoi costruttori, campi e metodo. I modificatori di accesso Java sono anche a volte indicati in daily discorso come specificatori di accesso Java, ma il nome corretto è Java access modificatore. Classi, campi, costruttori e metodi possono avere uno di quattro diversi modificatori di accesso Java:

• Voce di elenco
• privato
• predefinito (pacchetto)
• protetto
• pubblico

Da Controllo dell'accesso ai membri di una classe tutorial:

I modificatori del livello di accesso determinano se altre classi possono utilizzare campo particolare o richiamare un particolare metodo. Ci sono due livelli di controllo di accesso:

• Al livello superiore-pubblico, o pacchetto-privato (nessun modificatore esplicito).
• A livello di membro-pubblico, privato, protetto o pacchetto-privato (nessun modificatore esplicito).

Una classe può essere dichiarata con il modificatore public, nel qual caso la classe è visibile a tutte le classi ovunque. Se una classe non ha modificatore (il valore predefinito, noto anche come package-private), è visibile solo all'interno del proprio pacchetto

La seguente tabella mostra l'accesso ai membri consentito da ciascuno modificatore.

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

La prima colonna dati indica se la classe stessa ha accesso a il membro definito dal livello di accesso. Come si può vedere, una classe sempre ha accesso ai propri membri. La seconda colonna indica se classi nello stesso pacchetto della classe (indipendentemente dalla loro parentela) hanno accesso al membro. La terza colonna indicare se le sottoclassi della classe dichiarata al di fuori di questo pacchetto hanno accesso al membro. La quarta colonna indica se tutte le classi avere accesso al membro.

I livelli di accesso influiscono in due modi. Innanzitutto, quando usi le classi che provengono da un'altra fonte, ad esempio le classi nella piattaforma Java, i livelli di accesso determinano quali membri di quelle classi sono i tuoi le classi possono usare. In secondo luogo, quando si scrive una classe, è necessario decidere quale livello di accesso ogni variabile membro e ogni metodo nella tua classe avrei dovuto.

Public Protected Default e private sono modificatori di accesso.

Sono pensati per l'incapsulamento o per nascondere e mostrare i contenuti della classe.

1. La classe può essere pubblica o predefinita
2. I membri della classe possono essere pubblici, protetti, predefiniti o privati.

Privato non è accessibile al di fuori della classe Il valore predefinito è accessibile solo nel pacchetto. Protetto nel pacchetto e in qualsiasi classe che lo estende. Il pubblico è aperto a tutti.

Normalmente, variabili membro sono definiti privati, ma i metodi membri sono pubblici.

Spesso mi sono reso conto che ricordare i concetti di base di qualsiasi linguaggio può essere reso possibile creando analogie del mondo reale. Ecco la mia analogia per comprendere i modificatori di accesso in Java:

Supponiamo che tu sia uno studente di un'università e che tu abbia un amico che verrà a trovarti durante il fine settimana. Supponiamo che esista una grande statua del fondatore dell'università nel mezzo del campus.

• Quando lo porti al campus, la prima cosa che tu e il tuo amico vedete questa statua. Ciò significa che chiunque cammini nel campus può guardare la statua senza il permesso dell'università. Questo rende la statua come PUBBLICA .

• Successivamente, vuoi portare il tuo amico al tuo dormitorio, ma per questo devi registrarlo come visitatore. Ciò significa che ottiene un pass di accesso (che è lo stesso del tuo) per entrare in vari edifici del campus. Questo renderebbe la sua carta di accesso come PROTETTO .

• Il tuo amico vuole accedere al WiFi del campus, ma non ha le credenziali per farlo. L " unico modo che può ottenere on-line è se si condivide il login con lui. (Ricordate, ogni studente che va all'università possiede anche queste credenziali di accesso). Ciò renderebbe le tue credenziali di accesso come NESSUN MODIFICATORE.

• Infine, il tuo amico vuole leggere il tuo rapporto sui progressi per il semestre che è pubblicato sul sito web. Tuttavia, ogni studente ha il proprio login personale per accedere a questa sezione del sito web del campus. Ciò renderebbe queste credenziali come PRIVATE .

Spero che questo aiuti!

Quando stai pensando ai modificatori di accesso, pensaci in questo modo (si applica a entrambi i metodi variabili e ):

public --> accessibile da ogni dove
private --> accessibile solo all'interno della stessa classe in cui è dichiarato

Ora sorge la confusione quando si tratta di default e protected

default --> Nessuna parola chiave modificatore di accesso è presente. Ciò significa che è disponibile rigorosamente all'interno del pacchetto della classe. Da nessuna parte al di fuori di quella pacchetto si può accedere.

protected --> Leggermente meno rigoroso di default e a parte le stesse classi di pacchetti è possibile accedervi da sottoclassi al di fuori del pacchetto è dichiarato.

Si tratta di incapsulamento (o come ha dichiarato Joe Phillips, conoscenza minima).

Inizia con il più restrittivo (privato) e vedi se hai bisogno di modificatori meno restrittivi in seguito.

Usiamo tutti i modificatori di metodi e membri come private, public,... ma una cosa troppo pochi sviluppatori fanno è usare i pacchetti per organizzare codice logicamente.

Per esempio: È possibile inserire metodi di sicurezza sensibili in un pacchetto "sicurezza". Poi mettere una classe pubblica che accede a parte del codice relativo alla sicurezza in questo pacchetto ma mantiene altre classi di sicurezza pacchetto privato. Quindi altri sviluppatori saranno in grado di utilizzare la classe disponibile pubblicamente solo dall'esterno di questo pacchetto (a meno che non cambino il modificatore). Questa non è una funzionalità di sicurezza, ma guiderà l'utilizzo di.

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

Un'altra cosa è che le classi che dipendono molto l'una dall'altra possono finire nello stesso pacchetto e potrebbero eventualmente essere rifattorizzate o unite se la dipendenza è troppo forte.

Se al contrario si imposta tutto come public non sarà chiaro a cosa si dovrebbe o non si dovrebbe accedere, il che potrebbe portare a scrivere un sacco di javadoc (che non impone nulla tramite il compilatore...).