En Java, tout a une forme de contrôle d'accès.
Les niveaux de contrôle des autorisations d'accès sont des autorisations d'accès au minimum au minimum: publics, protégés, d'accès à package (pas de mots clés) et privés.
Lorsqu'ils sont utilisés, les modificateurs d'accès Java, publics, protégés et privés, sont placés avant chaque définition de membre (domaine ou méthode) dans la classe.
1. Droits d'accès des membres de la classe
La seule façon d'obtenir l'accès à un membre est:
1). Rendre ce membre public. Peu importe qui est, le membre peut être accessible;
2). Accorder l'accès aux paquets aux membres par des modificateurs non additionnés et en plaçant d'autres classes dans le même package, et d'autres classes du package peuvent accéder au membre;
3). Les classes héritées peuvent accéder à la fois aux membres publics et aux membres protégés.
4). Fournir des méthodes d'accessoires et de mutateurs pour lire et modifier les valeurs numériques.
1. Permissions d'accès aux packages
L'autorisation d'accès par défaut n'a pas de mots clés, mais PASS fait référence aux autorisations d'accès des packages, ce qui signifie que toutes les autres classes du rapport actuel ont accès à ce membre, mais pour toutes les classes en dehors de ce package, ce membre est en effet privé.
L'accès à package combine toutes les classes pertinentes dans le package afin qu'ils puissent facilement interagir les uns avec les autres.
Remarque: Si les deux classes sont dans le même répertoire et ne définissent aucun nom de package pour elles-mêmes, Java considère automatiquement ces fichiers comme le package par défaut affilié au répertoire, de sorte que ces fichiers ont accès les uns aux autres.
L'exemple suivant illustre ce problème:
// Le gâteau et la tarte sont dans le même répertoire et ne sont pas explicitement affichés dans n'importe quelle classe de package Pie {void f () {System.out.println ("Pie.f ()"); }} Class Cake {public static void main (String [] args) {Pie x = new Pie (); xf (); }} // La sortie est Pie.f ()2.Publique: autorisation d'accès à l'interface
L'utilisation du mot-clé public signifie que les déclarations de membres ultérieures sont disponibles pour tous, en particulier les programmeurs clients qui utilisent des bibliothèques de classe.
3. Private: vous ne pouvez pas y accéder
Le mot-clé privé indique qu'aucune autre classe que la classe contenant le membre ne peut pas accéder au membre. D'autres classes du même package ne peuvent pas accéder aux membres privés de cette classe, ce qui équivaut donc à vous isoler.
Cette fonction du mot-clé privé a de nombreuses utilisations, telles que le contrôle de la création d'objets et d'empêcher les autres d'accéder directement à un constructeur spécifique (ou à tous les constructeurs). regarder
L'exemple suivant:
classe Sundae {private sundae () {} statique Sundae makeasundae () {return new sundae (); }} Classe publique Secravre {public static void main (String [] args) {sundae x = sundae.makeasundae (); }}Dans cet exemple, nous pouvons créer des objets Sundae en appelant la méthode makeasundae (), mais nous ne pouvons pas les créer via le constructeur.
Cela s'applique également aux champs privés de la classe.
Cependant, une chose à noter est que vous ne pouvez pas penser que d'autres objets ne peuvent pas avoir de références publiques à l'objet simplement parce que la référence à un objet de la classe est privée.
4. Protected: Autorisations d'accès hérité
Si un nouveau package est créé et hérite de la classe à partir d'un autre package, le seul membre qui peut être accessible est le membre public du package source.
Parfois, le créateur d'une classe de base souhaite attribuer un accès à un membre particulier à la classe dérivée plutôt qu'à toutes les classes, ce qui nécessite le mot-clé protégé.
Remarque que Protected fournit également un accès aux packages, c'est-à-dire que d'autres classes du même package peuvent également accéder aux éléments protégés de cette classe.
2. Interface et implémentation
Le contrôle des droits d'accès est souvent appelé caché dans les implémentations concrètes.
Les données et les méthodes d'emballage dans les classes et la cachette d'implémentations spécifiques sont souvent appelées collectivement l'encapsulation.
Pour deux raisons importantes, le contrôle d'autorisation d'accès se trouve les limites des autorisations à l'intérieur du type de données:
1. Définissez les limites que les programmeurs clients peuvent utiliser et ne peuvent pas utiliser. Vous pouvez établir votre propre mécanisme interne dans la structure, sans vous soucier que les programmeurs clients traitent accidentellement le mécanisme interne comme faisant partie de l'interface qu'ils utilisent.
2. Séparez l'interface et l'implémentation spécifique.
3. Autorisations d'accès aux classes
En Java, les modificateurs d'accès peuvent également être utilisés pour déterminer quelles classes de la bibliothèque sont disponibles pour l'utilisateur de la bibliothèque.
Les modificateurs doivent être placés avant la classe de mots clés. Par exemple:
Widget de classe publique {......} ou
Améliorer l'accès.Widget;
Vous devez savoir qu'une classe ne peut pas être privée (si la classe est privée, alors aucune autre classe ne peut y accéder sauf la classe), et elle ne peut pas être protégée (en fait, une classe interne peut être privée ou protégée, mais il s'agit d'un cas particulier, comme décrit dans les articles suivants), et ne peut être que des autorisations d'accès aux packages ou du public.
Si vous ne voulez pas que d'autres accédent à la classe, vous pouvez spécifier tous les constructeurs de la classe comme privés, empêchant quiconque de créer des objets de la classe. Mais il y a des exceptions à cela, qui ne peuvent pas vous empêcher de créer la classe à l'intérieur du membre statique de la classe. Regardons l'exemple suivant:
Class Soup1 {private Soup1 () {} public static Soup1 Makeoup () {// Créer un objet en utilisant une méthode statique renvoie New Soup1 (); }} classe soup2 {private soup2 () {} private static Soup2 ps1 = new Soup2 (); // Créer un objet utilisant le mode singleton public static Soup2 Access () {return ps1; } public void f () {}} public class déjeuner {void testprivate () {// soup1 Soup = new Soup1; Ne peut pas être exécuté} void testsingleton () {soup2.access (). F (); }}Nous pouvons voir que les constructeurs de Soup1 et Soup2 sont tous deux privés, et personne ne peut utiliser directement le constructeur pour créer des objets de cette classe. Mais nous pouvons également utiliser ces deux classes: créer une méthode statique dans Soup1, utiliser le constructeur pour créer un objet Soup1 et retourner sa référence; La création de Soup2 utilise le motif Singleton dans le motif de conception et ne peut créer qu'un de ses objets. L'objet de la classe Soup2 est créé en tant que membre privé statique de Soup2, donc il n'y en a qu'un, et il ne peut être accessible que s'il est accessible via la méthode publique.
De plus, certaines limitations méritent d'être notées:
1. Chaque unité de compilation ne peut avoir qu'une classe publique.
2. Le nom de la classe publique doit correspondre exactement au nom de fichier qui contient l'unité de compilation, y compris la partie supérieure et les minuscules.
3. S'il n'y a pas de classe publique dans l'unité de compilation, vous pouvez nommer le fichier à volonté.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.