In questo tutorial, impareremo a conoscere il Java Access Modifier, i suoi tipi e come usarli con l'aiuto di esempi.
Cosa sono i modificatori di accesso?
In Java, i modificatori di accesso vengono utilizzati per impostare l'accessibilità (visibilità) di classi, interfacce, variabili, metodi, costruttori, membri di dati e metodi setter. Per esempio,
class Animal ( public void method1() (… ) private void method2() (… ) )
Nell'esempio sopra, abbiamo dichiarato 2 metodi: method1 () e method2 (). Qui,
- metodo1 è
public- Ciò significa che è possibile accedervi da altre classi. - metodo2 è
private- Ciò significa che non è possibile accedervi da altre classi.
Nota la parola chiave publice private. Questi sono modificatori di accesso in Java. Sono anche conosciuti come modificatori di visibilità.
Nota : non è possibile impostare il modificatore di accesso dei metodi getter.
Tipi di modificatore di accesso
Prima di conoscere i tipi di modificatori di accesso, assicurati di conoscere i pacchetti Java.
Esistono quattro parole chiave dei modificatori di accesso in Java e sono:
| Modificatore | Descrizione |
| Predefinito | le dichiarazioni sono visibili solo all'interno del pacchetto (pacchetto privato) |
| Privato | le dichiarazioni sono visibili solo all'interno della classe |
| Protetto | le dichiarazioni sono visibili all'interno del pacchetto o di tutte le sottoclassi |
| Pubblico | le dichiarazioni sono visibili ovunque |
Modificatore di accesso predefinito
Se non specifichiamo esplicitamente alcun modificatore di accesso per classi, metodi, variabili, ecc., Per impostazione predefinita viene considerato il modificatore di accesso predefinito. Per esempio,
package defaultPackage; class Logger ( void message()( System.out.println("This is a message"); ) )
Qui, la classe Logger ha il modificatore di accesso predefinito. E la classe è visibile a tutte le classi che appartengono al pacchetto defaultPackage. Tuttavia, se proviamo a utilizzare la classe Logger in un'altra classe al di fuori di defaultPackage, otterremo un errore di compilazione.
Modificatore di accesso privato
Quando vengono dichiarati variabili e metodi private, non è possibile accedervi al di fuori della classe. Per esempio,
class Data ( // private variable private String name; ) public class Main ( public static void main(String() main)( // create an object of Data Data d = new Data(); // access private variable and field from another class d.name = "Programiz"; ) )
Nell'esempio precedente, abbiamo dichiarato una variabile privata denominata name e un metodo privato denominato display(). Quando eseguiamo il programma, otterremo il seguente errore:
Main.java:18: error: name has private access in Data d.name = "Programiz"; ^
L'errore viene generato perché stiamo tentando di accedere alla variabile private e al metodo privato della classe Data dalla classe Main.
Potresti chiederti cosa succede se abbiamo bisogno di accedere a quelle variabili private. In questo caso, possiamo usare il metodo getter e setters. Per esempio,
class Data ( private String name; // getter method public String getName() ( return this.name; ) // setter method public void setName(String name) ( this.name= name; ) ) public class Main ( public static void main(String() main)( Data d = new Data(); // access the private variable using the getter and setter d.setName("Programiz"); System.out.println(d.getName()); ) )
Uscita :
Il nome è Programiz
Nell'esempio precedente, abbiamo una variabile privata denominata name. Per accedere alla variabile dalla classe esterna, abbiamo utilizzato i metodi: getName()e setName(). Questi metodi sono chiamati getter e setter in Java.
Qui, abbiamo usato il metodo setter ( setName()) per assegnare valore alla variabile e il metodo getter ( getName()) per accedere alla variabile.
Abbiamo usato la thisparola chiave all'interno di setName () per fare riferimento alla variabile della classe. Per saperne di più su questa parola chiave, visita Java questa parola chiave.
Nota : non possiamo dichiarare classi e interfacce private in Java. Tuttavia, le classi nidificate possono essere dichiarate private. Per saperne di più, visita Java Nested e Inner Class.
Modificatore di accesso protetto
Quando vengono dichiarati metodi e membri dati protected, è possibile accedervi all'interno dello stesso pacchetto e dalle sottoclassi. Per esempio,
class Animal ( // protected method protected void display() ( System.out.println("I am an animal"); ) ) class Dog extends Animal ( public static void main(String() args) ( // create an object of Dog class Dog dog = new Dog(); // access protected method dog.display(); ) )
Uscita :
Io sono un animale
Nell'esempio precedente, abbiamo un metodo protetto denominato display()all'interno della classe Animal. La classe Animal viene ereditata dalla classe Dog. Per ulteriori informazioni sull'ereditarietà, visitare Java Inheritance.
Abbiamo quindi creato un oggetto dog della classe Dog. Utilizzando l'oggetto abbiamo provato ad accedere al metodo protetto della classe genitore.
Poiché è possibile accedere ai metodi protetti dalle classi figlie, siamo in grado di accedere al metodo della classe Animal dalla classe Dog.
Nota : non possiamo dichiarare classi o interfacce protectedin Java.
Modificatore di accesso pubblico
Quando vengono dichiarati metodi, variabili, classi e così via public, possiamo accedervi da qualsiasi luogo. Il modificatore di accesso pubblico non ha limitazioni di ambito. Per esempio,
// Animal.java file // public class public class Animal ( // public variable public int legCount; // public method public void display() ( System.out.println("I am an animal."); System.out.println("I have " + legCount + " legs."); ) ) // Main.java public class Main ( public static void main( String() args ) ( // accessing the public class Animal animal = new Animal(); // accessing the public variable animal.legCount = 4; // accessing the public method animal.display(); ) )
Uscita :
Io sono un animale Ho 4 gambe.
Qui,
- La classe pubblica Animal è accessibile dalla classe principale.
- Si accede alla variabile pubblica legCount dalla classe Main.
- Si
display()accede al metodo public dalla classe Main.
Modificatori di accesso riassunti in una figura
Accessibilità di tutti i modificatori di accesso in Java
I modificatori di accesso vengono utilizzati principalmente per l'incapsulamento. Posso aiutarci a controllare quale parte di un programma può accedere ai membri di una classe. In questo modo è possibile prevenire l'uso improprio dei dati. Per ulteriori informazioni sull'incapsulamento, visitare Java Encapsulation.
