L'accesso ai membri "pacchetto privato" non è sinonimo di accesso predefinito (senza modificatori)?

Sono un po 'confuso sul termine "pacchetto privato" utilizzato da parte della documentazione, insieme all'uso di "accesso predefinito". L'accesso privato al pacchetto e quello predefinito non sono entrambi sinonimi di protetto?

Sì, è quasi lo stesso. Il modificatore protetto specifica che è possibile accedere al membro solo all'interno del proprio pacchetto (come con pacchetto privato) e, inoltre , da una sottoclasse della sua classe in un altro pacchetto.

Il modificatore di accesso "predefinito" (quello in cui nessuno di essi è esplicitamente fornito) è "pacchetto privato", il che significa che solo le cose nello stesso pacchetto possono accedervi. Tuttavia, essere nello stesso pacchetto non implica nulla sulla relazione di ereditarietà tra le classi: è puramente una convenzione di denominazione.

"Protetto" significa che non solo le classi nello stesso pacchetto, ma anche le sottoclassi (indipendentemente dal pacchetto in cui si trovano quelle sottoclassi) potranno accedervi.

L'accesso predefinito per le classi è privato del pacchetto, tuttavia l'accesso predefinito per i membri dell'interfaccia è pubblico.

per esempio

public interface I {
   int A = 1;
// same as
   public static final int A = 1;

   void method();
// same as
   public abstract void method();

   class C { }
// same as
   public static class C { }
}

Le regole di accesso predefinite per le interfacce non sono le stesse delle classi.

L'accesso privato al pacchetto e quello predefinito sono sinonimi. Un oggetto può anche accedere al membro protetto degli oggetti le cui classi si trovano nello stesso pacchetto. Un oggetto può anche accedere a membri protetti delle sue superclassi senza una condizione sul loro pacchetto. Come esempio concreto:

package ab;

class A {
   protected void foo() {}
   void dd(){}
}

class C {
   void aa(){
       A a = new A();
       a.foo(); //legal
       a.dd();  //legal
   }
}


package sub;

class D extends A{
      void ac(){
         foo(); //legal ..
         dd();  //illegal.. because dd has default access.. 
      }

class E {
    void ee(){
       A a = new A();
       a.foo(); //illegal
       a.dd();  //illegal     
    }

"Pacchetto privato" e accesso predefinito sono gli stessi. Nelle prime versioni del compilatore intorno alla 1.1.2 / 3, "pacchetto" era un modificatore consentito, ma ignorato, vale a dire lo stesso di nessun modificatore, cioè "pacchetto privato". Poco dopo ci fu una moda di breve durata per mettere /*package*/(come commento) in tali situazioni. Allo stesso modo a quel tempo si potevano dichiarare cose come classi sincronizzate, sebbene ancora una volta non ci fosse alcun effetto semantico effettivo.

Nessuno dei due è uguale a "protected", che si estende alle classi derivate in altri pacchetti.

Da Java Language Spec

• 6.6.5 Esempio: campi, metodi e costruttori di accesso predefinito Se nessuno dei modificatori di accesso public, protected o private è specificato, un membro della classe o un costruttore è accessibile in tutto il pacchetto che contiene la dichiarazione della classe in cui la classe membro viene dichiarato, ma il membro della classe o il costruttore non è accessibile in nessun altro pacchetto.

Se una classe pubblica ha un metodo o un costruttore con accesso predefinito, allora questo metodo o costruttore non è accessibile o ereditato da una sottoclasse dichiarata al di fuori di questo pacchetto

default e package-private sono entrambi uguali, il che significa che entrambi possono essere usati da qualsiasi classe finché non sono nello stesso pacchetto.

Il termine pacchetto privato , in realtà, è definito dal significato di modificatore privato in quanto privato significa che è disponibile solo nella stessa classe e nessun'altra classe o sottoclasse può accedervi all'interno o all'esterno dello stesso pacchetto.

Quindi package-private significa lo stesso di default .