Panoramica delle parole chiave protette in Java

Le parole chiave protette sono parole chiave utilizzate per limitare l'ambito entro cui è possibile accedere alla variabile, al metodo e ai costruttori. È uno dei tipi di modificatori di accesso in Java. Sono utilizzati per differenziare l'ambito di metodi, variabili, costruttori e classi. Esistono 4 tipi di modificatori di accesso in Java e sono:

  1. Parola chiave predefinita: sono accessibili solo all'interno del pacchetto e non possono essere richiamati al di fuori di esso. Come suggerisce il nome, quando non viene menzionato alcun identificatore di accesso, viene automaticamente assegnato come predefinito.
  2. Parola chiave pubblica: sono accessibili da qualsiasi parte del programma. Ciò significa che può essere utilizzato dalla stessa o una classe diversa e lo stesso o un pacchetto diverso.
  3. Parola chiave privata: limitano le parole chiave a un livello superiore impedendo loro di accedervi da qualsiasi luogo esterno alla classe stessa.
  4. Parola chiave protetta: in questo articolo, impareremo di più sulle parole chiave protette.

Una volta che una variabile o un metodo è contrassegnato come protetto, è possibile accedervi solo con i metodi seguenti:

  • All'interno della stessa classe in cui è dichiarato.
  • Da altre classi che si trovano anche nello stesso pacchetto della classe dichiarata.
  • Classi ereditate da quella dichiarata, indipendentemente dal loro pacchetto.

Le parole chiave protette sono come una combinazione di parole chiave sia pubbliche che private poiché sono state introdotte per poter accedere alle variabili al di fuori della classe (il che non è possibile nel caso di parole chiave private) ma anche sostenere che solo alcuni metodi possono ereditare la stessa.

Sintassi

Le parole chiave protette vengono dichiarate con la parola chiave prefissata come "protetta". Dichiariamo innanzitutto la parola chiave protetta in una delle classi denominata "MyClass" come di seguito:

class MyClass (
protected String name = "Katy";
protected int token= 55;
)
public class SubClass extends MyClass (
public static void main(String() args) (
SubClass obj = new SubClass();
System.out.println(obj.name + "'s token number is: " + obj.token);
)
)

Qui la classe "Sottoclasse" estende "MyClass" e quindi la parola chiave protetta può essere utilizzata qui creando un oggetto di Sottoclasse e chiamando le variabili.

Produzione:

Le parole chiave protette possono essere utilizzate solo a livello di membro, ovvero classi interne dichiarate al di fuori di una funzione e non statiche. La parola chiave protetta è diversa da quella di privato in quanto sono accessibili al di fuori di una classe e nella sottoclasse di un altro pacchetto.

Alcune delle restrizioni sull'uso di parole chiave protette sono:

  • Non possono essere utilizzati per dichiarare le classi protette.
  • Le interfacce non possono essere dichiarate come protette.
  • L'accessibilità al di fuori del pacchetto è solo attraverso l'ereditarietà.
  • Un costruttore reso protetto non è accessibile al di fuori del pacchetto creando la sua istanza.

Esempi

Esaminiamo alcuni esempi in cui possiamo comprendere meglio il concetto di parole chiave protette.

1. Chiamare una parola chiave protetta senza estendere la classe genitore

Qui proviamo a chiamare la parola chiave dalla classe genitrice di "pacchetto1". "ProtectedExample2" viene creato in "package2" e qui viene chiamata la parola chiave "disp". Ma il codice non sarà in grado di accedere alla parola chiave poiché la classe figlio non ha ereditato il suo valore dalla classe principale e genererà un'eccezione come mostrato.

Codice:

package com.package1;
public class Example (
protected String disp="Printing message from protected variable from package1";
)
//Create new package as com.package2
//Create new class as ProtectedExample2
package com.package2;
import com.package1.Example;
public class ProtectedExample2 (
public static void main(String() args) (
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
)
)

Produzione:

2. Accesso a una classe protetta

In questo esempio, proviamo ad accedere alla classe "ProtectedExample5" che è protetta. Ciò provoca un errore di compilazione.

Codice:

protected class ProtectedExample5 (
void display()
(
System.out.println("Try to access outer protected class");
)
public static void main(String() args) (
ProtectedExample5 p=new ProtectedExample5();
p.display();
)
)

Produzione:

3. Visualizzazione della parola chiave protetta dallo stesso pacchetto ma con classe diversa

Nell'esempio seguente creiamo prima un pacchetto chiamato "com.package1" e creiamo una nuova classe con il nome "Esempio". Qui dichiariamo che la nostra parola chiave "disp" è protetta. Cercheremo di visualizzare questa parola chiave protetta usando la classe "Esempio1". Per questo, prima è necessario creare un oggetto della classe genitore "Esempio1" e quindi stampare il valore assegnato alla parola chiave "disp".

Codice:

package com.package1;
public class Example (
protected String disp="Printing message from protected variable from package1";
)
class Example1 (
public static void main(String() args) (
Example obj=new Example();
System.out.println(obj.disp);
)
)

Produzione:

4. Visualizzazione di parole chiave protette da un pacchetto diverso

Usando lo stesso codice sopra vedremo come chiamare la parola chiave protetta creando un pacchetto diverso "pacchetto2". È possibile accedere a una parola chiave protetta solo tramite l'ereditarietà dal pacchetto1, pertanto "ProtectedExample2" viene esteso da "Esempio". In modo simile al primo esempio, dobbiamo creare un oggetto della classe "ProtectedExample2" per accedere alla parola chiave protetta dal pacchetto "com.package1".

Codice:

package com.package2;
import com.package1.Example;
public class ProtectedExample2 extends Example(
public static void main(String() args) (
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
)
)

Produzione:

5. Accesso a una classe protetta sostituendo la sottoclasse

Qui la classe viene dichiarata protetta all'interno della classe ereditata "Esempio5". Inoltre, una classe protetta denominata "Esempio" viene dichiarata all'esterno della funzione ma nello stesso pacchetto. Quando viene creato un oggetto di "Esempio 5" e viene chiamata la classe protetta "disp ()", possiamo osservare che viene chiamato il metodo sovrascritto invece della classe esterna. Questo perché non saremo in grado di importare "com.package1" e la sua classe "Esempio" poiché non è visibile e causa un errore di compilazione.

Codice:

//Create a file by Example.java
package com.package1;
class Example
(
protected void disp()
(
System.out.println("Printing from protected class in the outside function");
)
)
//Create a class by the name Example5.java
public class Example5 extends Example (
protected void disp()
(
System.out.println("Accessing the overriden function");
)
public static void main(String() args) (
Example5 exp=new Example5();
exp.disp();
)
)

Produzione:

Importanza della parola chiave protetta

  • Queste parole chiave consentono alle classi o alle loro variabili di essere ereditate dalla sua classe genitore che non è possibile con qualsiasi altra parola chiave limitata come privato.
  • La parola chiave protetta è la combinazione del vantaggio della parola chiave privata e quella di una parola chiave pubblica. Elimina lo svantaggio della parola chiave pubblica che la variabile o la classe sono accessibili da qualsiasi parte del programma limitando l'ambito.

Conclusione - Parola chiave protetta in Java

Come mostrato negli esempi precedenti, scegliamo parole chiave protette in base al livello di accesso richiesto a livello di codice. Aiutano notevolmente nei casi in cui è necessario accedere alla stessa variabile o classe da altri metodi ereditati nel programma. Una relazione genitore-figlio è sempre presente tra la classe genitore e le sue sottoclassi che utilizzano la parola chiave protetta.

Articoli consigliati

Questa è una guida alle parole chiave protette in Java. Qui discutiamo la panoramica, la sintassi e diversi esempi di parole chiave protette in Java. Puoi anche consultare i seguenti articoli per saperne di più -

  1. Incapsulamento in Java
  2. Costruttore in Java
  3. Domande di intervista Java
  4. Sostituzione in OOP
  5. Parole chiave Java
  6. Strumenti di distribuzione Java
  7. Modificatori di accesso in PHP
  8. Sostituzione in Java
  9. Incapsulamento in JavaScript

Categoria: