Modificateurs d'accès à Java
Modificateurs d'accès à Java
Cette section fournit un aperçu approfondi des modificateurs d'accès en Java. Vous obtiendrez une description détaillée de chaque modificateur démontré par un exemple qui illustre la fonctionnalité de chaque modificateur d'accès.
Modificateur d'accès public
Comme le nom du modificateur le suggère, il est le moins sécurisé et les classes, méthodes, instances déclarées à l'aide de mots clés publics ont les options d'accessibilité suivantes:
- Ils sont accessibles dans le package / classe, en dehors du package / classe
Exemple
Package NewPack;Classe publique AccessMod
public void show ()
Système.dehors.println ("Bienvenue à Linuxhint!");
Le code écrit ci-dessus a la description suivante:
- Une classe publique et une méthode publique sont déclarées qui contient une déclaration de ligne imprimée.
L'image du code est fournie ici:
La méthode de classe nommée montrer dans le code ci-dessus est appelé dans la deuxième classe comme indiqué ci-dessous:
package mod;Importer NewPack.*
classe Accessm
public static void main (String args [])
AccessMod obj = new AccessMod ();
obj.montrer();
Le code est décrit ci-dessous
- le nom du package newpack de la classe est importée
- un objet de la classe AccessMod (Classe qui réside dans le package nommé newpack) est créé
L'image du code et de la sortie est illustrée ci-dessous:
D'après la sortie ci-dessus, il est conclu que les modificateurs d'accès public peuvent accéder aux objets d'une classe qui est également en dehors de cette classe et de ce package.
Modificateur d'accès privé
Contrairement à la classe publique, les méthodes privées / varibes ne sont accessibles qu'à l'intérieur de la classe. Une méthodes / variables privées ne peut pas être accessibles:
- en dehors du colis
- dans le package (mais hors de la classe)
Exemple 1: en dehors du package
Package NewPack;Classe AccessMod
SHOW VOID PRIVÉ ()
Système.dehors.println ("Linuxhint!");
La description du code est fournie ci-dessous:
- La méthode Show est déclarée avec un modificateur privé
Maintenant, le code suivant essaie d'exécuter la méthode Show à partir du AccessMod classe.
package mod;Importer NewPack.*
classe Accessm
public static void main (String Argos [])
AccessMod obj = new AccessMod ();
obj.montrer();
Une nouvelle classe nommée Accesm est créée dans le package MOD. Le newpack Le package est importé dans ce package car nous devons créer un objet de la classe nommé AccessMod (qui réside dans NewPack classe).
Il ressort clairement de la sortie qu'AccessMod et les objets associés ne pouvaient pas être accessibles en dehors du package.
Exemple: en dehors de la classe (même package)
package lh;classe prim
private void pvt ()
Système.dehors.println ("LinuxHint");
Le code est décrit comme,
- une classe nommée coussin est créé dans LH emballer. Le coussin La classe contient une méthode privée nommée PVT.
Maintenant, pour vérifier le modificateur d'accès privé, le code fourni ci-dessous est utilisé.
package lh;classe second
public static void main (String [] main)
prim obj = new prim ();
obj.Pvt ();
Le package des deux classes est le même, mais la classe nommée Second essaie de créer un objet de Pvt (). Le pvt () est une méthode dans coussin classe.
Il est observé à partir de la sortie que, pvt () la méthode ne peut pas être accessible en raison de son modificateur d'accès privé.
Modificateur d'accès par défaut
Les membres de données déclarés à l'aide de mots clés par défaut sont accessibles dans le même package uniquement. Il se situe entre les modificateurs d'accès privés et protégés et il est donc plus sûr que protégé et le moins sécurisé que privé.
Exemple 1: en dehors du package
Package NewPack;classe def
statique void main (String [] args)
Système.dehors.println ("une classe par défaut");
La description du code est la suivante,
- Une classe par défaut est créée nommée Def Et il contient la méthode principale
- Une instruction de ligne d'impression est exécutée à l'intérieur de la méthode principale
Pour tester l'accessibilité de la classe par défaut, les lignes de code suivantes sont utilisées.
package lh;Importer NewPack.*
classe Deom
statique void main (String [] args)
Def test = new def ();
test.principal();
Le code est décrit comme,
- importé le package nommé newpack
- créé une nouvelle classe habile
- créé un objet de la classe Def dans la méthode principale du habile classe
La sortie montre que l'accessibilité du Def La classe doit être changée pour le public pour être accessible dans une classe d'autres packages.
Exemple 2: en dehors de la classe (dans le même package)
Le code suivant crée une méthode par défaut pour une classe nommée coussin.
package lh;classe prim
void pub ()
Système.dehors.println ("Modificateur d'accès par défaut");
Une méthode par défaut nommée pub() est défini dans la classe coussin.
Pour vérifier son accessibilité, jetons un coup d'œil au code suivant.
package lh;classe second
public static void main (String [] main)
prim obj = new prim ();
obj.pub();
Un objet du pub() La méthode est créée dans une autre classe (qui réside dans le même package).
Il est observé à partir de la sortie que l'objet du pub() La méthode est exécutée avec succès et donc il est conclu que les méthodes déclarées à l'aide de modificateurs d'accès par défaut peuvent être utilisées dans le même package mais dans une classe différente.
Modificateur d'accès protégé
Les méthodes ou les membres de données déclarés à l'aide de mots clés protégés sont accessibles au sein de la classe ou des autres classes du même package. Il ne peut pas être accessible en dehors du package, mais une sous-classe des autres packages peut accéder aux méthodes protégées.
Exemple: en utilisant la sous-classe du même package
Package NewPack;Classe AccessMod
Protégé void show ()
Système.dehors.println ("Linuxhint!");
La méthode Show () est déclarée avec des privilèges protégés:
La méthode est accessible dans le Accès (sous-classe du même package où le AccessMod se trouve) et le processus est réalisé en utilisant le code suivant:
Package NewPack;classe AccessM étend AccessMod
public static void main (String args [])
AccessMod obj = new AccessMod ();
obj.montrer();
L'image de sortie du code est fournie ci-dessous:
Maintenant, élaborons la différence entre les modificateurs d'accès par défaut et protégés en utilisant l'exemple suivant. Les modificateurs d'accès par défaut ne sont pas accessibles par sous-classes (en dehors du package), cependant, nous accéderons à une méthode protégée en utilisant une sous-classe.
Exemple 2: Utilisation de la sous-classe d'autres packages
package lh;classe publique prot
Affichage vide protégé ()
Système.dehors.println ("Bienvenue à Linuxhint!");
Dans le code ci-dessus, une méthode protégée est déclarée à l'intérieur d'une classe qui contient une instruction de ligne d'impression simple.
Le code écrit ci-dessous créera et accédera à l'objet de la méthode protégée indiquée dans l'image ci-dessus.
Package NewPack;Importer LH.*
class Protmod étend prot
public static void main (String args [])
protmod obj = new protmod ();
obj.afficher();
Tu observerais ça,
- le paquet LH est importé dans le package newpack
- une sous-classe (de Prot classe) nommé protmod est déclaré
- Objet de la classe Protmod nommée obj est utilisé pour obtenir le contenu du afficher() méthode de Prot classe).
La sortie montre que le afficher() Méthode contenue à l'intérieur du Prot La classe est utilisée dans la sous-classe du Prot classe.
Conclusion
Les modificateurs d'accès de Java vous permettent de déterminer le niveau d'accessibilité des méthodes, des classes, des variables et des constructeurs. Cet article fournit la fonctionnalité des modificateurs d'accès qui peuvent être utilisés dans Java. Les modificateurs d'accès tels que privé, public, protégé et par défaut sont exercés à l'aide de divers exemples. Enfin, il est conclu que les modificateurs privés définissent la plate-forme la plus sécurisée tandis que les modificateurs publics sont considérés comme le moins sécurisé.