Qual è la differenza tra pubblico, protetto, pacchetto-privato e privato in Java?

In Java, ci sono regole chiare su quando utilizzare ciascuno dei modificatori di accesso, vale a dire il valore predefinito (pacchetto privato), public, protectede private, pur facendo classe interfacee si occupano di eredità?

Il tutorial ufficiale potrebbe esserti utile.

______________________________________________________________
| │ Classe │ Pacchetto │ Sottoclasse │ Sottoclasse │ Mondo |
| │ │ │ (stesso pkg) │ (diff pkg) │ |
| ───────────┼───────┼─────────┼──────────┼──────── ──┼──────── |
| public │ + │ + │ + │ + │ + | 
| ───────────┼───────┼─────────┼──────────┼──────── ──┼──────── |
| protetto │ + │ + │ + │ + │ | 
| ───────────┼───────┼─────────┼──────────┼──────── ──┼──────── |
| nessun modificatore│ + │ + │ + │ │ | 
| ───────────┼───────┼─────────┼──────────┼──────── ──┼──────── |
| privato │ + │ │ │ │ |
| ___________ | _______ | _________ | __________ | __________ | ________ |
 +: spazio vuoto accessibile: non accessibile

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

Privato

Come penseresti, 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).

protetta

Il pacchetto Private + può essere visualizzato da sottoclassi o membri del pacchetto.

Pubblico

Tutti possono vederlo.

Pubblicato

Visibile al di fuori del codice che controllo. (Pur non essendo una sintassi Java, è importante per questa discussione).

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

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

Quindi, la regola empirica è quella di rendere le cose solo visibili come devono essere. Inizia con privato e aggiungi solo maggiore visibilità, se necessario. Rendi pubblico solo ciò che è assolutamente necessario che l'utente sappia, ogni dettaglio che rendi pubblico riduce la tua 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 ignorarli, spesso è una buona idea spingere quelle viscere 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 desideri che il bit "vai a cercare informazioni su questo CD" sia personalizzabile, piuttosto che rendere pubblici questi metodi, dovresti mettere tutta quella funzionalità nel suo oggetto e rendere pubblico solo il tuo oggetto getter / setter . In questo modo essere avari di esporre l'intestino incoraggia una buona composizione e separazione delle preoccupazioni

Personalmente, rimango solo "privato" e "pubblico". Molte lingue OO hanno proprio questo. "Protetto" può essere utile, ma è davvero un imbroglione. Una volta che un'interfaccia è più che privata è fuori dal tuo controllo e devi cercare nel codice di altre persone per trovare gli usi.

È qui che entra in gioco l'idea di "pubblicato". La modifica di un'interfaccia (refactoring) richiede la ricerca di tutto il codice che la utilizza e la modifica anche. Se l'interfaccia è privata, non c'è problema. Se è protetto devi cercare tutte le tue sottoclassi. Se è pubblico devi trovare tutto il codice che utilizza il tuo codice. A volte questo è possibile, ad esempio, se stai lavorando su un codice aziendale che è solo per uso interno, non importa se un'interfaccia è pubblica. Puoi estrarre tutto il codice dal repository aziendale. Ma se un'interfaccia viene "pubblicata", se c'è del codice che la utilizza al di fuori del tuo controllo, allora sei esagerato. È necessario supportare tale interfaccia o il codice di rottura del rischio. Anche le interfacce protette possono essere considerate pubblicate (motivo per cui non

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

Ecco una versione migliore della tabella, che include anche una colonna per i moduli.

spiegazioni

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

• Un membro senza modificatore di accesso ( j) è accessibile solo all'interno delle classi nello stesso pacchetto.

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

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

Quale modificatore scegliere?

I modificatori di accesso sono uno strumento che aiuta a prevenire l'incapsulamento accidentale ^(*) . Chiediti se intendi che il membro sia qualcosa di interno alla classe, pacchetto, gerarchia di classi o che non sia affatto interno e scegli il livello di accesso di conseguenza.

Esempi:

• Un campo long internalCounterdovrebbe probabilmente essere privato poiché è modificabile e un dettaglio di implementazione.
• Una classe che dovrebbe essere istanziata solo in una classe factory (nello stesso pacchetto) dovrebbe avere un costruttore con restrizioni di pacchetto, poiché non dovrebbe essere possibile chiamarlo direttamente dall'esterno del pacchetto.
• Un void beforeRender()metodo interno chiamato prima del rendering e usato come hook nelle sottoclassi dovrebbe essere protetto.
• Un void saveGame(File dst)metodo chiamato dal codice GUI dovrebbe essere pubblico.

^{(*) Che 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 dichiarando tutto privato. E poi il progresso verso il pubblico quando sorgono le esigenze e il design lo garantisce.

Quando esponete i membri chiedetevi se state esponendo le scelte di rappresentanza o le scelte di astrazione. Il primo è qualcosa che vuoi evitare in quanto introdurrà troppe dipendenze dalla rappresentazione reale piuttosto che dal suo comportamento osservabile.

Come regola generale, cerco di evitare l'implementazione del metodo di sostituzione mediante la sottoclasse; è troppo facile rovinare la logica. Dichiarare metodi protetti astratti se si intende sostituirlo.

Inoltre, usa l'annotazione @Override quando esegui l'override per evitare che le cose si rompano durante il refactoring.

In realtà è un po 'più complicato di 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) è anche chiamato pacchetto-privato . Eccezione: in un'interfaccia, nessun modificatore significa accesso pubblico; i modificatori diversi dal pubblico sono vietati. Le costanti di Enum sono sempre pubbliche.

Sommario

È 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 chiamante.
• Il membro è privato pacchetto: solo se il codice chiamante si trova nel pacchetto che racchiude immediatamente il membro.
• Il membro è protected: stesso pacchetto o se il membro è definito in una superclasse della classe contenente il codice chiamante.
• Il membro è public: Sì.

A cosa si applicano gli identificatori di accesso

Le variabili locali e i parametri formali non possono accettare identificatori di accesso. Poiché sono intrinsecamente inaccessibili all'esterno in base alle regole di scoping, sono effettivamente private.

Per le classi nell'ambito superiore, publicsono consentiti solo e pacchetto-privato. Questa scelta progettuale è presumibilmente perché protectede privatesarebbe ridondante a livello di pacchetto (non vi è ereditarietà di pacchetti).

Tutti gli identificatori di accesso sono possibili sui membri della classe (costruttori, metodi e funzioni dei membri statici, classi nidificate).

Correlati: accessibilità alla classe Java

Ordine

Gli specificatori di accesso possono essere rigorosamente ordinati

pubblico> protetto> pacchetto-privato> privato

nel senso che publicfornisce il massimo accesso, privateil minimo. Qualsiasi riferimento possibile su un membro privato è valido anche per un membro pacchetto-privato; qualsiasi riferimento a un membro pacchetto-privato è valido su un membro protetto e così via. (Dare accesso ai membri protetti ad altre classi nello stesso pacchetto è stato considerato un errore.)

Appunti

• 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, ma solo per classe. (Confronta con Scala, che lo supporta usando private[this].)
• È necessario l'accesso 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 di variabili statici). Allo stesso modo per costruttori di pacchetti privati ​​o protetti.
  • Avere solo costruttori privati ​​significa anche che la classe non può essere sottoclassata esternamente, poiché Java richiede ai costruttori di una sottoclasse di chiamare implicitamente o esplicitamente un costruttore di superclassi. (Tuttavia, può contenere una classe nidificata che la sottoclasse.)

Classi interne

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

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

Per un assaggio di come questi interagiscono, considera questo esempio. È possibile "trapelare" 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

Alcune domande correlate:

• Java - Accessibilità del metodo all'interno della classe package-private?

Come regola generale:

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

Di conseguenza, se dividiamo l'accesso in tre diritti:

• (D) irect (invocare da un metodo all'interno della stessa classe o tramite la sintassi "this").
• (R) eference (invoca un metodo usando un riferimento alla classe, o tramite la sintassi "punto").
• (I) ereditarietà (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 parte.
• protected: accessibile dalle classi dello stesso pacchetto e dalle sottoclassi residenti 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 spera chiarisca la confusione:

• Supponiamo che abbiamo 2 classi; Fathere Son, ciascuno nel suo 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 foo()è definito ( fatherpackage):

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

  2. All'interno di una sottoclasse, nell'istanza corrente tramite thiso 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 padre ed è all'interno del pacchetto dove foo()è definito ( fatherpackage) [Questo può essere incluso nel 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 del pacchetto dove foo()è definito ( 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 ​​a non sottoclassi):

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

Privato

• Metodi, variabili e costruttori

Metodi, variabili e costruttori dichiarati privati ​​sono accessibili solo all'interno della classe dichiarata stessa.

• Classe e interfaccia

Il modificatore di accesso privato è il livello di accesso più restrittivo. Classe e interfacce non possono essere private.

Nota

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

protetta

• Classe e interfaccia

Il modificatore di accesso protetto non può essere applicato a classe e interfacce.

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 helper o la variabile, impedendo a una classe non correlata di tentare di utilizzarla.

Pubblico

Una classe, un metodo, un costruttore, un'interfaccia, ecc. Dichiarati pubblici sono accessibili da qualsiasi altra classe.

Pertanto, campi, metodi, blocchi dichiarati all'interno di una classe pubblica sono accessibili da qualsiasi classe appartenente all'universo Java.

• Pacchetti diversi

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

A causa dell'ereditarietà delle classi, tutti i metodi e le variabili pubblici di una classe sono ereditati dalle sue sottoclassi.

Predefinito -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 del 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 provi a sovrascriverlo non mostra alcun errore ma non funziona ciò che escludiamo.

Risposte correlate

• Sostituzione dei metodi statici in Java

Link ai riferimenti

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

La differenza si trova nei collegamenti già forniti, ma quale utilizzare di solito dipende dal "Principio della conoscenza minima". Consentire solo la minima visibilità necessaria.

Privato : accesso limitato alla sola classe

Predefinito (nessun modificatore) : accesso limitato alla classe e al pacchetto

Protetto : accesso limitato a classe, pacchetto e sottoclassi (pacchetto interno ed esterno)

Pubblico : accessibile a classe, pacchetto (tutti) e sottoclassi ... In breve, ovunque.

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

Pubblico: è fondamentalmente semplice da poter accedere da qualsiasi classe, che si trovi nello stesso pacchetto o meno.

Per accedere se ci si trova nello stesso pacchetto, è possibile accedere direttamente, ma se ci si trova in un altro pacchetto, è possibile creare un oggetto della classe.

Predefinito: è accessibile nello stesso pacchetto da qualsiasi classe del pacchetto.

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

Protetto: è possibile accedere alle variabili nello stesso pacchetto e alla sottoclasse in qualsiasi altro pacchetto. quindi in pratica è predefinito + comportamento ereditato .

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

Privato: può accedere alla 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.

Modificatori di accesso in Java.

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

1. Predefinito:

Accessibile alle classi solo nello stesso pacchetto.

Per 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 quello pubblico e protetto, ma meno limitato di quello privato.

2. Pubblico

È possibile accedervi da qualsiasi luogo. (Accesso globale)

Per 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 a membri privati ​​di una classe in un'altra genererà un errore di compilazione. Per 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 nello stesso pacchetto e alle sottoclassi

Per 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

• pubblico - accessibile da qualsiasi parte dell'applicazione.

• impostazione predefinita : accessibile dal pacchetto.

• protetto - accessibile dal pacchetto e dalle sottoclassi in altri pacchetti. anche

• privato - accessibile solo dalla sua classe.

Visibile al pacchetto. Il predefinito. Non sono necessari modificatori.

Visibile solo alla classe ( privato ).

Visibile al mondo ( pubblico ).

Visibile al pacchetto e tutte le sottoclassi ( protette ).

Variabili e metodi possono essere dichiarati senza alcun modificatore chiamato. Esempi predefiniti:

String name = "john";

public int age(){
    return age;
}

Modificatore di accesso privato - privato:

Metodi, variabili e costruttori dichiarati privati ​​sono accessibili solo all'interno della classe dichiarata stessa. Il modificatore di accesso privato è il livello di accesso più restrittivo. Classe e interfacce non possono essere private.

È possibile accedere alle variabili dichiarate private al di fuori della classe se nella classe sono presenti metodi getter pubblici.

L'uso 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:

Una classe, metodo, costruttore, interfaccia, ecc. Dichiarati pubblici sono accessibili da qualsiasi altra classe. Pertanto, campi, metodi, blocchi dichiarati all'interno di una classe pubblica sono accessibili 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 comunque essere importata.

A causa dell'ereditarietà delle classi, tutti i metodi e le variabili pubblici di una classe sono ereditati dalle sue sottoclassi.

Esempio:

public void cal(){

}

Modificatore di accesso protetto - protetto:

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 a classe e interfacce. Metodi, campi possono essere dichiarati protetti, tuttavia metodi e campi in un'interfaccia non possono essere dichiarati protetti.

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

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

Questa pagina scrive bene sul modificatore di accesso protetto e predefinito

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

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

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

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

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

Ciò è correlato ai modificatori di accesso Java .

Dai modificatori di accesso Java :

Un modificatore di accesso Java specifica quali classi possono accedere a una determinata classe e ai suoi campi, costruttori e metodi. I modificatori di accesso possono essere specificati separatamente per una classe, i suoi costruttori, campi e metodi. I modificatori di accesso a Java vengono talvolta definiti nel parlato quotidiano come identificatori di accesso a Java, ma il nome corretto è modificatori di accesso a Java. Classi, campi, costruttori e metodi possono avere uno dei quattro diversi modificatori di accesso Java:

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

Dal controllo dell'accesso ai tutorial dei membri di una classe :

I modificatori del livello di accesso determinano se altre classi possono utilizzare un determinato campo o invocare un particolare metodo. Esistono due livelli di controllo dell'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 pubblico, nel qual caso tale classe è visibile da tutte le classi ovunque. Se una classe non ha modificatori (il valore predefinito, noto anche come pacchetto-privato), è visibile solo all'interno del proprio pacchetto

La tabella seguente mostra l'accesso ai membri consentito da ciascun 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 di dati indica se la classe stessa ha accesso al membro definito dal livello di accesso. Come puoi vedere, una classe ha sempre accesso ai propri membri. La seconda colonna indica se le classi nello stesso pacchetto della classe (indipendentemente dalla loro parentela) hanno accesso al membro. La terza colonna indica se le sottoclassi della classe dichiarate all'esterno di questo pacchetto hanno accesso al membro. La quarta colonna indica se tutte le classi hanno accesso al membro.

I livelli di accesso ti influenzano in due modi. Innanzitutto, quando si utilizzano classi che provengono da un'altra fonte, come le classi nella piattaforma Java, i livelli di accesso determinano quali membri di quelle classi possono essere utilizzate dalle proprie classi. In secondo luogo, quando scrivi una classe, devi decidere quale livello di accesso dovrebbe avere ogni variabile membro e ogni metodo nella tua classe.

Default protetti pubblici e privati ​​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.

Il privato non è accessibile al di fuori della classe L'impostazione predefinita è accessibile solo nel pacchetto. Protetto nel pacchetto e in ogni classe che lo estende. Il pubblico è aperto a tutti.

Normalmente, le variabili membro sono definite private, ma i metodi membro sono pubblici.

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

Supponiamo che tu sia uno studente in un'università e che 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 cammina nel campus può guardare la statua senza il permesso dell'università. Questo rende la statua PUBBLICA .

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

• Il tuo amico vuole accedere al campus WiFi ma non ha le credenziali per farlo. L'unico modo in cui può collegarsi online è se condividi il tuo login con lui. (Ricorda, 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 rapporto sullo stato di avanzamento del semestre 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 PRIVATE .

Spero che sia di aiuto!

Quando stai pensando ai modificatori di accesso, pensaci in questo modo (si applica sia alle variabili che ai metodi ):

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

Ora la confusione sorge quando si tratta di defaulteprotected

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

protected-> Leggermente meno rigoroso rispetto defaultalle stesse classi di pacchetti e separato dalle classi secondarie al di fuori del pacchetto dichiarato.

L'accesso Java modifica quale è possibile utilizzare

Modificatore di accesso può essere applicabile per class, field^[Chi] , method. Prova ad accedere, sottoclassare o sovrascriverlo.

• L'accesso fieldo methodavviene tramite a class.
• Eredità. Il classmodificatore di accesso (sottoclasse) successivo può essere qualsiasi. Il methodmodificatore di accesso (override) successivo dovrebbe essere lo stesso o espanderlo

La classe di primo livello (ambito di primo livello) può essere publice default. Nested class^{[Informazioni]} può averne uno qualsiasi

package non si applica alla gerarchia dei pacchetti

Modificatori di accesso rapido

Si tratta di incapsulamento (o come affermava Joe Phillips, meno conoscenza ).

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

Tutti usiamo metodi e modificatori di membri come privati, pubblici, ... ma una cosa che fanno troppo pochi sviluppatori è usare i pacchetti per organizzare il codice logicamente.

Ad esempio: è possibile inserire metodi di sicurezza sensibili in un pacchetto "sicurezza". Quindi inserire una classe pubblica che acceda ad alcuni dei codici relativi alla sicurezza in questo pacchetto ma mantenere privato il pacchetto di altre classi di sicurezza . Pertanto, altri sviluppatori potranno utilizzare la classe disponibile pubblicamente al di fuori di questo pacchetto (a meno che non modifichino il modificatore). Questa non è una funzione di sicurezza, ma guiderà l' utilizzo.

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

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

Se al contrario si imposta tutto come pubblico , non sarà chiaro a cosa si debba o non si debba accedere, il che potrebbe portare a scrivere molto javadoc (che non impone nulla tramite il compilatore ...).

Il seguente diagramma a blocchi spiega come i membri di dati della classe base vengono ereditati quando la modalità di accesso alla classe derivata è privata .

Nota: la dichiarazione dei membri di dati con identificatore di accesso privato è nota come nascondere i dati.

Fonte: identificatori di accesso : privati, pubblici e protetti

I miei due centesimi :)

privato:

class -> una classe di livello superiore non può essere privata. le classi interne possono essere private accessibili dalla stessa classe.

variabile di istanza -> accessibile solo nella classe. Impossibile accedere al di fuori della classe.

pacchetto-privato:

classe -> una classe di livello superiore può essere package-private. Può essere accessibile solo dallo stesso pacchetto. Non dal pacchetto secondario, non dal pacchetto esterno.

variabile di istanza -> accessibile dallo stesso pacchetto. Non dal pacchetto secondario, non dal pacchetto esterno.

protetta:

classe -> una classe di livello superiore non può essere protetta.

variabile di istanza -> Accessibile solo nello stesso pacchetto o pacchetto secondario. L'accesso al di fuori del pacchetto è possibile solo durante l'estensione della classe.

pubblico:

classe -> accessibile dal pacchetto / pacchetto secondario / altro pacchetto

variabile di istanza -> accessibile da pacchetto / subpackage / altro pacchetto

Ecco una risposta dettagliata

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

• pubblico

  Se un membro della classe viene dichiarato con pubblico, è possibile accedervi da qualsiasi luogo

• protetta

  Se un membro della classe viene dichiarato protetto da parole chiave, è possibile accedervi dagli stessi membri della classe, dai membri della classe esterni all'interno dello stesso pacchetto e dai membri della classe ereditati. Se un membro della classe è protetto, NON è possibile accedervi dalla classe di pacchetto esterna a meno che la classe di pacchetto esterna non sia ereditata, ovvero estenda l'altra superclasse di pacchetto. Ma un membro della classe protetta è sempre disponibile per le stesse classi di pacchetto. NON importa che la stessa classe di pacchetto sia ereditata o NOT

• predefinito

  In Java l'impostazione predefinita NON è una parola chiave del modificatore di accesso. Se un membro della classe viene dichiarato senza alcuna parola chiave del modificatore di accesso, in questo caso viene considerato come membro predefinito. Il membro della classe predefinito è sempre disponibile per gli stessi membri della classe del pacchetto. Ma il membro della classe pacchetto esterno NON può accedere ai membri della classe predefinita anche se le classi esterne sono sottoclassi a differenza dei membri protetti

• privato

  Se un membro della classe viene dichiarato con una parola chiave protetta, in questo caso è disponibile SOLO per gli stessi membri della classe

Identificatori di accesso in Java: ci sono 4 specificatori di accesso in java, vale a dire privato, pacchetto-privato (predefinito), protetto e pubblico in ordine di accesso crescente.

Privato : quando stai sviluppando una classe e desideri che un membro di questa classe non sia esposto all'esterno di questa classe, dovresti dichiararlo come privato. ai membri privati ​​è possibile accedere solo in classe dove sono definiti, ad esempio classe che lo racchiude. ai membri privati ​​è possibile accedere su "questo" riferimento e anche su altre istanze di classe che racchiudono questi membri, ma solo all'interno della definizione di questa classe.

Pacchetto privato (impostazione predefinita) : questo identificatore di accesso fornirà l'accesso specificato dall'identificatore di accesso privato oltre all'accesso descritto di seguito.

Quando stai sviluppando un pacchetto e quindi una classe (diciamo Class1) al suo interno, puoi usare lo specificatore di accesso predefinito (non è necessario menzionarlo esplicitamente), per esporre il membro all'interno della classe, ad altre classi all'interno del tuo (stesso) pacchetto. In queste altre classi (all'interno dello stesso pacchetto), è possibile accedere a questi membri predefiniti sull'istanza di Class1. Inoltre è possibile accedere a questi membri predefiniti all'interno di sottoclassi di Class1, ad esempio Class2 (su questo riferimento o sull'istanza di Class1 o sull'istanza di Class2).

Fondamentalmente, all'interno dello stesso pacchetto è possibile accedere direttamente ai membri predefiniti sull'istanza della classe o sul riferimento "questo" nelle sottoclassi.

protetto : questo identificatore di accesso fornirà l'accesso specificato dall'identificatore di accesso privato al pacchetto oltre all'accesso descritto di seguito.

Quando si sta sviluppando un pacchetto e quindi una classe (ad esempio Class1) al suo interno, è necessario utilizzare l'identificatore di accesso protetto per il membro di dati all'interno di Class1 se non si desidera che questo membro abbia accesso all'esterno del pacchetto (ad esempio nel pacchetto del consumatore di il pacchetto, ad esempio il client che utilizza le API) in generale, ma si desidera fare un'eccezione e consentire l'accesso a questo membro solo se il client scrive class, ad esempio Class2, che estende Class1. Quindi, in generale, i membri protetti saranno accessibili su "questo" riferimento in classi derivate, ad esempio Classe2 e anche su istanze esplicite di Classe2.

Notare che:

1. Non sarai in grado di accedere al membro protetto ereditato di Class1 in Class2, se tenti di accedervi su un'istanza esplicita di Class1, sebbene sia ereditata in esso.
2. Quando si scrive un'altra classe Class3 nello stesso / diverso pacchetto che estende Class2, il membro protetto da Class1 sarà accessibile su questo riferimento e anche sull'istanza esplicita di Class3. Ciò sarà vero per qualsiasi gerarchia estesa, ovvero il membro protetto sarà comunque accessibile su questo riferimento o istanza di classe estesa. Si noti che in Class3, se si crea un'istanza di Class2, non sarà possibile accedere al membro protetto da Class1 sebbene sia ereditato.

Quindi, in sostanza, è possibile accedere ai membri protetti in altri pacchetti, solo se parte della classe da questo altro pacchetto, estende la classe che racchiude questo membro protetto e si accede al membro protetto su "questo" riferimento o istanze esplicite di classe estesa, all'interno della definizione di estesa classe.

pubblico : questo identificatore di accesso fornirà l'accesso specificato dall'identificatore di accesso protetto oltre all'accesso descritto di seguito.

Quando si sviluppa un pacchetto e quindi una classe (ad esempio Class1) al suo interno, è necessario utilizzare l'identificatore di accesso pubblico per il membro dati all'interno di Class1 se si desidera che questo membro sia accessibile in altri pacchetti sull'istanza di Class1 creata in una classe di altri pacchetto. Fondamentalmente questo identificatore di accesso dovrebbe essere usato quando si intende esporre il proprio membro di dati al mondo senza alcuna condizione.