1. Modificatore di accesso privato
2. Ruolo del costruttore privato
3. Modificatore di accesso predefinito
4. Modificatore di accesso protetto
5. Modificatore di accesso pubblico
6. Modificatore di accesso con overriding del metodo

Esistono due tipi di modificatori in Java: modificatori di accesso E modificatori di non accesso .

I modificatori di accesso in Java specificano l'accessibilità o l'ambito di un campo, metodo, costruttore o classe. Possiamo modificare il livello di accesso di campi, costruttori, metodi e classi applicandovi il modificatore di accesso.

Esistono quattro tipi di modificatori di accesso Java:

Privato: Il livello di accesso di un modificatore privato è solo all'interno della classe. Non è possibile accedervi dall'esterno della classe.Predefinito: il livello di accesso di un modificatore predefinito è solo all'interno del pacchetto. Non è possibile accedervi dall'esterno del pacchetto. Se non specifichi alcun livello di accesso, sarà quello predefinito.Protetto: il livello di accesso di un modificatore protetto è all'interno del pacchetto e all'esterno del pacchetto tramite la classe figlia. Se non crei la classe figlia, non è possibile accedervi dall'esterno del pacchetto.Pubblico: il livello di accesso di un modificatore pubblico è ovunque. È possibile accedervi dall'interno della classe, dall'esterno della classe, dall'interno del pacchetto e dall'esterno del pacchetto.

Esistono molti modificatori non di accesso, come statico, astratto, sincronizzato, nativo, volatile, transitorio, ecc. Qui impareremo solo i modificatori di accesso.

Comprendere i modificatori di accesso Java

Comprendiamo i modificatori di accesso in Java con una semplice tabella.

1) Privato

Il modificatore di accesso privato è accessibile solo all'interno della classe.

alternativa a mylivecricket

Semplice esempio di modificatore di accesso privato

In questo esempio, abbiamo creato due classi A e Simple. Una classe contiene un membro dati privato e un metodo privato. Stiamo accedendo a questi membri privati ​​dall'esterno della classe, quindi si è verificato un errore in fase di compilazione.

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

Ruolo del costruttore privato

Se rendi privato un costruttore di classe, non puoi creare l'istanza di quella classe dall'esterno della classe. Per esempio:

 class A{ private A(){}//private constructor void msg(){System.out.println('Hello java');} } public class Simple{ public static void main(String args[]){ A obj=new A();//Compile Time Error } } 

Nota: una classe non può essere privata o protetta tranne la classe nidificata.

2) Predefinito

Se non usi alcun modificatore, viene trattato come predefinito per impostazione predefinita. Il modificatore predefinito è accessibile solo all'interno di package. Non è possibile accedervi dall'esterno del pacchetto. Fornisce più accessibilità rispetto al privato. Ma è più restrittivo che protetto e pubblico.

Linux cambia nome alla directory

Esempio di modificatore di accesso predefinito

In questo esempio abbiamo creato due pacchetti pack e mypack. Stiamo accedendo alla classe A dall'esterno del suo pacchetto, poiché la classe A non è pubblica, quindi non è possibile accedervi dall'esterno del pacchetto.

 //save by A.java package pack; class A{ void msg(){System.out.println('Hello');} } 

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

Nell'esempio precedente, l'ambito della classe A e del suo metodo msg() è predefinito, quindi non è possibile accedervi dall'esterno del pacchetto.

3) Protetto

IL modificatore di accesso protetto è accessibile all'interno e all'esterno del pacchetto ma solo tramite ereditarietà.

Il modificatore di accesso protetto può essere applicato al membro dati, al metodo e al costruttore. Non può essere applicato alla classe.

Fornisce maggiore accessibilità rispetto al modificatore predefinito.

Esempio di modificatore di accesso protetto

In questo esempio abbiamo creato i due pacchetti pack e mypack. Il pacchetto A class of pack è pubblico, quindi è possibile accedervi dall'esterno del pacchetto. Ma il metodo msg di questo pacchetto è dichiarato protetto, quindi è possibile accedervi dall'esterno della classe solo tramite ereditarietà.

 //save by A.java package pack; public class A{ protected void msg(){System.out.println('Hello');} } 

 //save by B.java package mypack; import pack.*; class B extends A{ public static void main(String args[]){ B obj = new B(); obj.msg(); } } 

 Output:Hello 

4) Pubblico

IL modificatore di accesso pubblico è accessibile ovunque. Ha la portata più ampia tra tutti gli altri modificatori.

Esempio di modificatore di accesso pubblico

 //save by A.java package pack; public class A{ public void msg(){System.out.println('Hello');} } 

 //save by B.java package mypack; import pack.*; class B{ public static void main(String args[]){ A obj = new A(); obj.msg(); } } 

 Output:Hello 

Modificatori di accesso Java con overriding del metodo

Se stai sovrascrivendo un metodo, il metodo sovrascritto (ovvero dichiarato nella sottoclasse) non deve essere più restrittivo.

semplice programma Python

 class A{ protected void msg(){System.out.println('Hello java');} } public class Simple extends A{ void msg(){System.out.println('Hello java');}//C.T.Error public static void main(String args[]){ Simple obj=new Simple(); obj.msg(); } } 

Il modificatore predefinito è più restrittivo che protetto. Ecco perché si verifica un errore in fase di compilazione.