Modificatori di accesso in Java
Modificatori di accesso in Java
Questa sezione fornisce una visione approfondita dei modificatori di accesso in Java. Otterresti una descrizione dettagliata di ciascun modificatore dimostrato da un esempio che illustra la funzionalità di ciascun modificatore di accesso.
Modificatore di accesso pubblico
Come suggerisce il nome del modificatore, è meno sicuro e le classi, i metodi, le istanze dichiarate utilizzando le parole chiave pubbliche hanno le seguenti opzioni di accessibilità:
- è possibile accedere all'interno del pacchetto/classe, al di fuori del pacchetto/classe
Esempio
pacchetto newpack;Classe pubblica AccessMod
public void show ()
Sistema.fuori.println ("Benvenuti a LinuxHint!");
Il codice scritto sopra ha la seguente descrizione:
- Viene dichiarato una classe pubblica e un metodo pubblico che contiene una dichiarazione di riga di stampa.
L'immagine del codice è fornita qui:
Il metodo di classe chiamato spettacolo Nel codice sopra viene chiamato nella seconda classe come mostrato di seguito:
pacchetto mod;Importa Newpack.*;
Classe Accessm
Public Static Void Main (String Args [])
AccessMod obj = new AccessMod ();
obj.spettacolo();
Il codice è descritto di seguito
- il nome del pacchetto Newpack della classe viene importata
- un oggetto della classe AccessMod (Classe che risiede nel pacchetto denominato Newpack) è creato
L'immagine del codice e dell'output è mostrata di seguito:
Dall'output di cui sopra, si è concluso che i modificatori di accesso pubblico possono accedere agli oggetti di una classe che è al di fuori di quella classe e pacchetto.
Modificatore di accesso privato
Contrariamente alla classe pubblica, è possibile accedere a metodi/varibalani privati solo all'interno della classe. Non è possibile accedere a metodi/variabili private:
- fuori dal pacchetto
- All'interno del pacchetto (ma fuori dalla classe)
Esempio 1: al di fuori del pacchetto
pacchetto newpack;Classe AccessMod
Private void show ()
Sistema.fuori.println ("LinuxHint!");
La descrizione del codice è fornita di seguito:
- Il metodo Show è dichiarato con un modificatore privato
Ora, il seguente codice cerca di eseguire il metodo dello spettacolo dal AccessMod classe.
pacchetto mod;Importa Newpack.*;
Classe Accessm
public static void main (String Argos [])
AccessMod obj = new AccessMod ();
obj.spettacolo();
Una nuova classe denominata ACCESM è creata nel pacchetto mod. IL Newpack Il pacchetto viene importato in questo pacchetto in quanto dobbiamo creare un oggetto della classe denominato AccessMod (che risiede in Newpack's classe).
È chiaro dall'output a cui non è possibile accedere ad AccessMod e Associates Objects al di fuori del pacchetto.
Esempio: al di fuori della classe (stesso pacchetto)
pacchetto LH;Classe Prim
private void pvt ()
Sistema.fuori.println ("linuxhint");
Il codice è descritto come,
- una classe chiamata prim è creato in lh pacchetto. IL prim La classe contiene un metodo privato chiamato Pvt.
Ora, per verificare il modificatore di accesso privato, viene utilizzato il codice fornito di seguito.
pacchetto LH;Classe Second
public static void main (string [] main)
prim obj = new prim ();
obj.Pvt ();
Il pacchetto di entrambe le classi è lo stesso, ma la classe denominata Second tenta di creare un oggetto di Pvt (). Il pvt () è un metodo in prim classe.
Si osserva dall'output che, Pvt () Non è possibile accedere al metodo a causa del suo modificatore di accesso privato.
Modificatore di accesso predefinito
I membri dei dati dichiarati utilizzando le parole chiave predefinite sono accessibili solo all'interno dello stesso pacchetto. Rientra tra modificatori di accesso privati e protetti e quindi è più sicuro che protetto e meno sicuro che privato.
Esempio 1: al di fuori del pacchetto
pacchetto newpack;Classe def
statico void main (string [] args)
Sistema.fuori.println ("una classe predefinita");
La descrizione del codice è la seguente,
- Viene creata una classe predefinita denominata Def e contiene il metodo principale
- Un'istruzione di riga di stampa viene eseguita all'interno del metodo principale
Per testare l'accessibilità della classe predefinita, vengono utilizzate le seguenti righe di codice.
pacchetto LH;Importa Newpack.*;
classe deft
statico void main (string [] args)
Def test = new def ();
test.principale();
Il codice è descritto come,
- importato il pacchetto denominato Newpack
- ha creato una nuova classe abile
- ha creato un oggetto della classe Def nel metodo principale del abile classe
L'output mostra che l'accessibilità del Def La classe deve essere modificata nel pubblico a cui accedere in una classe di altri pacchetti.
Esempio 2: al di fuori della classe (all'interno dello stesso pacchetto)
Il seguente codice crea un metodo predefinito per una classe denominata prim.
pacchetto LH;Classe Prim
void pub ()
Sistema.fuori.println ("Modificatore di accesso predefinito");
Un metodo predefinito chiamato pub() è definito in classe prim.
Per verificarne l'accessibilità, diamo un'occhiata al seguente codice.
pacchetto LH;Classe Second
public static void main (string [] main)
prim obj = new prim ();
obj.pub();
Un oggetto di pub() Il metodo viene creato in un'altra classe (che risiede nello stesso pacchetto).
Si osserva dall'output che l'oggetto del pub() Il metodo viene eseguito correttamente e quindi si è concluso che i metodi dichiarati utilizzando i modificatori di accesso predefiniti possono essere utilizzati all'interno dello stesso pacchetto ma in una classe diversa.
Modificatore di accesso protetto
I metodi o i membri dei dati dichiarati utilizzando parole chiave protette sono accessibili all'interno della classe o delle altre classi nello stesso pacchetto. Non è possibile accedere al di fuori del pacchetto ma una sottoclasse degli altri pacchetti può accedere ai metodi protetti.
Esempio: utilizzando la sotto-Classe dello stesso pacchetto
pacchetto newpack;Classe AccessMod
Protected void show ()
Sistema.fuori.println ("LinuxHint!");
Il metodo Show () è dichiarato con privilegi protetti:
Il metodo è accessibile nel file Accessm (Sottoclasse dello stesso pacchetto in cui il AccessMod bugie) e il processo viene effettuato utilizzando il seguente codice:
pacchetto newpack;Classe Accessm estende AccessMod
Public Static Void Main (String Args [])
AccessMod obj = new AccessMod ();
obj.spettacolo();
L'immagine di output del codice è fornita di seguito:
Ora, elaboriamo la differenza tra i modificatori di accesso predefiniti e protetti usando l'esempio seguente. I modificatori di accesso predefiniti non possono essere accessibili dalle sottoclassi (al di fuori del pacchetto), tuttavia, accederemo a un metodo protetto utilizzando una sottoclasse.
Esempio 2: usando la sottoclasse di altri pacchetti
pacchetto LH;Classe pubblica Prot
Protected void display ()
Sistema.fuori.println ("Benvenuti a LinuxHint!");
Nel codice sopra, un metodo protetto viene dichiarato all'interno di una classe che contiene una semplice istruzione riga di stampa.
Il codice scritto di seguito creerà e accede all'oggetto del metodo protetto mostrato nell'immagine sopra.
pacchetto newpack;importa lh.*;
class protmod estende prot
Public Static Void Main (String Args [])
protmod obj = new protmod ();
obj.Schermo();
Lo osserveresti,
- il pacchetto lh viene importato nel pacchetto Newpack
- una sottoclasse (di Prot classe) nominato Protmod è dichiarato
- oggetto della classe protmod denominata obj viene utilizzato per ottenere il contenuto del Schermo() metodo di Prot classe).
L'output mostra che il Schermo() metodo contenuto all'interno del Prot La classe è utilizzata nella sottoclasse del Prot classe.
Conclusione
I modificatori di accesso di Java consentono di determinare il livello di accessibilità di metodi, classi, variabili e costruttori. Questo articolo fornisce la funzionalità dei modificatori di accesso che possono essere utilizzati in Java. I modificatori di accesso come privati, pubblici, protetti e predefiniti sono esercitati utilizzando vari esempi. Infine, si è concluso che i modificatori privati fissano la piattaforma più sicura mentre i modificatori pubblici sono considerati il meno sicuro.