Modificatore di accesso predefinito per un costruttore Java

Qualcuno può spiegare qual è il modificatore di accesso predefinito per un costruttore esplicito no-arg (e altri costruttori)?

I costruttori sono uguali ai metodi in questo senso: se non si fornisce un pubblico esplicito, privato o protetto, il costruttore ottiene la visibilità predefinita “pacchetto privato”. Può essere chiamato dalla stessa class o da qualsiasi altra class nello stesso pacchetto, ma non da sottoclassi in un pacchetto diverso (quindi se una class ha solo costruttori visibili a pacchetto, allora tutte le sottoclassi devono trovarsi nello stesso pacchetto).

Un costruttore privato impedisce a qualsiasi altra class di creare un’istanza di questo, ma è ansible avere un metodo factory statico pubblico all’interno della class che chiama il proprio costruttore privato. Questo è un modello comune per cose come i singleton.

Costruttore predefinito JLS 8.8.9

Se una class non contiene dichiarazioni del costruttore, viene automaticamente fornito un costruttore predefinito che non accetta parametri:

se la class è dichiarata pubblica, il costruttore predefinito assegna implicitamente il modificatore di accesso al pubblico;
se la class è dichiarata protetta, allora il costruttore predefinito viene implicitamente protetto dal modificatore di accesso;
se la class è dichiarata privata, il costruttore predefinito assegna implicitamente il modificatore di accesso privato; altrimenti,
il costruttore predefinito ha l’accesso predefinito implicito da nessun modificatore di accesso.

Un constructor avrà un controllo di accesso di tipo default quando nessun modificatore di accesso è definito esplicitamente . Quindi questo costruttore avrà un accesso a livello di pacchetto . Le classi che sono definite all’interno di quel pacchetto come quella della class con questo costruttore predefinito saranno in grado di accedervi e anche le classi che estendono questa class contenente il costruttore predefinito saranno in grado di accedervi tramite ereditarietà.

Se il costruttore è reso private , solo il codice all’interno di quella class può accedervi.

Esempio Singleton

 public class Test { private static Test uniqueInstance = new Test(); private Test(){} public static Test getInstance(){ return uniqueInstance; } } 

Anche le inner classs non statiche con la class hanno accesso ai suoi memebers privati ​​e viceversa.

Per esempio:

 public class T { private T(){ System.out.println("Hello"); } class TT{ public TT(){ new T(); } } public static void main(String[] args){ T t = new T(); T.TT i = t.new TT(); } } 

Differisce a seconda che tu stia scrivendo un costruttore per una class regolare o un enum:

  • Per le classi, la risposta è data da JLS §6.6.1 :

    Un membro della class o un costruttore dichiarato senza un modificatore di accesso ha implicitamente l’accesso al pacchetto .

  • Per le enumerazioni, la risposta è data da JLS §8.9.2 :

    In una dichiarazione enum, una dichiarazione del costruttore senza nessun modificatore di accesso è privata .

    (I costruttori Enum sono sempre privati ​​per impedire ad altre classi di istanziare più costanti enumerate.)