Modificateurs de niveau d'accès java. Visibilité. spécificateurs d'accès. Modificateur d'accès ouvert -public

Le langage Java fournit de nombreux modificateurs répartis dans les catégories suivantes :

• modificateur d'accès
• Modificateur sans accès

Un modificateur est utilisé pour définir une classe, une méthode ou une variable, généralement au premier plan d'une instruction. A travers l'exemple suivant à titre d'illustration :

public class className ( // ... ) private boolean myFlag; semaines doubles finales statiques = 9,5 ; int final statique protégé BOXWIDTH = 42 ; public static void main(String arguments) ( // 方法体 )

Modificateur de contrôle d'accès

Java, vous pouvez utiliser des caractères de contrôle d'accès pour protéger l'accès aux classes, variables, méthodes et constructeurs. Java prend en charge quatre autorisations différentes.

Par défaut, également appelé par défaut par défaut, visible dans le même package, n'utilisez aucun modificateur.

Privé à spécifié privé modificateur visible dans la même classe.

Oui, pour indiquer général modificateur visible pour toutes les classes.

protégé, en protégé modificateur spécifie que toutes les classes et sous-classes du même package sont visibles.

Modificateur d'accès par défaut - n'utilisez aucun mot-clé

Utilisez des variables et des méthodes déclarées dans le modificateur d'accès par défaut pour une classe dans le même package visible. Une interface où les variables sont implicitement déclarées comme public static final, et une interface où la méthode d'accès par défaut est public.

Instruction dans l'exemple suivant, les variables et les méthodes ne peuvent pas utiliser de modificateur.

Version de chaîne = "1.5.1" ; boolean processOrder() ( retourne vrai; )

Modificateur d'accès privé -private

Le modificateur d'accès privé, est le niveau d'accès le plus restrictif, il est déclaré en tant que méthodes privées, variables et appartient à la classe constructeur uniquement accessible, mais les classes et les interfaces ne peuvent pas être déclarées privées.

Les variables déclarées comme un type d'accès privé ne sont accessibles qu'en dehors de la classe via la méthode getter publique de la classe.

Le modificateur d'accès privé est principalement utilisé pour protéger les détails d'implémentation et les données derrière la classe.

Les classes suivantes utilisent le modificateur d'accès privé :

Enregistreur de classe publique ( format de chaîne privé ; public String getFormat() ( return this.format ; ) public void setFormat(String format) ( this.format = format ; ) )

Par exemple, le format de variable de la classe Logger est une variable privée, de sorte que les autres classes ne peuvent pas directement obtenir et définir la valeur de la variable. Pour pouvoir travailler avec une autre variable de classe définit deux méthodes publiques : GetFormat() (format de la valeur de retour) et SetFormat(String) (paramètre de format)

Modificateur d'accès ouvert -public

Il est déclaré en tant que classes publiques, méthodes, constructeurs et interfaces peuvent être tout autre type d'accès.

Si plusieurs visites mutuelles de classes publiques dans différents packages, vous devez importer le package de classe publique correspondant situé de manière permanente. Parce que l'héritage de classe, une classe de toutes les méthodes et variables publiques peut être héritée par ses sous-classes.

Les fonctionnalités suivantes utilisent le contrôle d'accès public :

Public static void main(String arguments) ( // ... )

La méthode principale du programme Java () doit être définie en public, sinon l'interpréteur Java ne pourra pas exécuter la classe.

Modificateurs d'accès protégés protégés

Déclarés comme des variables protégées, les méthodes et les constructeurs d'un même package peuvent avoir tout autre type d'accès, et sont accessibles dans différents packages par des sous-classes.

Un modificateur d'accès protégé ne peut pas être modifié par les classes et les interfaces, les méthodes et les variables membres peuvent être déclarées protégées, mais les variables et les méthodes membres des interfaces ne peuvent pas être déclarées protégées.

modificateur Les sous-classes peuvent accéder aux méthodes et variables protégées déclarées, nous pouvons donc protéger des classes non liées à l'aide de ces méthodes et variables.

La classe parent suivante utilise un modificateur d'accès protégé dont les sous-classes remplacent la méthode openSpeaker() de la classe parent.

Class AudioPlayer ( protected boolean openSpeaker(Speaker sp) ( // 实现细节 ) ) class StreamingAudioPlayer ( boolean openSpeaker(Speaker sp) ( // 实现细节 ) )

Si la méthode openSpeaker() est déclarée privée, alors en plus de la classe AudioPlayer, elle ne peut pas accéder à la méthode. Si openSpeaker() est déclaré public, alors toutes les classes ont la possibilité d'accéder à la méthode. Si nous voulons rendre le processus visible aux sous-classes de la classe, alors la méthode est déclarée protected.

Contrôle d'accès et héritage

Notez que les méthodes suivantes ont hérité des règles :

La classe parent déclarée comme méthodes publiques dans la sous-classe doit également être publique.

La classe Parent est déclarée comme méthode protégée dans une sous-classe, ou déclarée comme protégée, ou déclarée publiquement. Vous ne pouvez pas être déclaré privé.

La classe parent déclarée comme méthode privée ne peut pas être héritée.

Modificateur sans accès

Afin d'obtenir un certain nombre d'autres fonctionnalités, Java fournit également un certain nombre de modificateurs sans accès.

Le modificateur statique est utilisé pour créer des méthodes de classe et des variables de classe.

Modificateur final utilisé pour décorer les classes, les méthodes et les variables, la classe modifiée finale ne peut pas être héritée, la méthode de classe modifiée ne peut pas être héritée, les variables constantes modifiées ne peuvent pas être modifiées.

Le modificateur abstrait est utilisé pour créer des classes abstraites et des méthodes abstraites.

Modificateurs synchrones et volatils, principalement pour les flux de programmation.

Modificateur statique

Variables statiques :

Le mot-clé static est utilisé pour déclarer des variables statiques qui ne dépendent pas d'un objet, quel que soit le nombre d'objets d'instance de la classe, il ne s'agit que d'une copie de la variable statique. Les variables statiques sont également appelées variables de classe. Les variables locales ne peuvent pas être déclarées en tant que variables statiques.

Méthodes statiques :

Le mot clé static est utilisé pour déclarer un objet indépendant d'une méthode statique. Les méthodes statiques ne peuvent pas utiliser une classe de variable non statique. Méthode statique pour obtenir des données à partir de la liste des paramètres, puis calculer les données.

L'accès aux variables de classe et aux méthodes peut être utilisé directement avec l'accès classname.variablename et classname.methodname.

Dans l'exemple suivant, un modificateur statique est utilisé pour créer des méthodes de classe et des variables de classe.

Public class InstanceCounter ( private static int numInstances = 0; protected static int getCount() ( return numInstances; ) private static void addInstance() ( numInstances++; ) InstanceCounter() ( InstanceCounter.addInstance(); ) public static void main(String arguments ) ( System.out.println("Commencer par " + InstanceCounter.getCount() + " instances"); for (int i = 0; i< 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }

Voici des exemples d'opérations d'édition ci-dessus :

Commencé avec 0 instances Créé 500 instances

Classificateur ultime

Variables finales :

Les variables finales peuvent être explicitement initialisées et ne sont initialisées qu'une seule fois. Un répertoire est déclaré car les objets feuilles ne peuvent pas pointer vers un autre objet. Mais l'objectif final est l'endroit où les données peuvent être modifiées. Il s'agit de la référence finale à un objet qui ne peut pas être modifié, mais dont la valeur peut être modifiée.

Le modificateur final est généralement utilisé ensemble pour créer une constante de classe de modificateur statique.

Public class Test( final int value = 10; // 下面是声明常量的实例 public static final int BOXWIDTH = 6; static final String TITLE = "(!LANG:Manager"; public void changeValue(){ value = 12; //将输出一个错误 } } !}

Méthode finale

Les méthodes de classe de destination sont héritées par les sous-classes mais ne peuvent pas être modifiées par les sous-classes.

L'objectif principal d'une méthode est d'empêcher la modification de l'instruction finale de la méthode.

Comme indiqué ci-dessous, en utilisant les méthodes de fin de modificateur de déclaration.

Classe publique Test( public final void changeName() ( // 方法体 ) )

catégorie finale

Les classes finales ne peuvent pas être héritées, aucune classe ne peut hériter des caractéristiques d'une classe finale.

Test public de classe finale ( // 类体 )

Modificateur abstrait

Classe abstraite :

Une classe abstraite ne peut pas être utilisée pour instancier un objet, le seul but d'une instruction est d'abstraire une classe pour une extension future de cette classe.

La classe ne peut pas être changée abstraite et finale. Si la classe contient des méthodes abstraites, la classe doit être déclarée en tant que classe abstraite, sinon, une erreur du compilateur.

Une classe abstraite peut contenir des méthodes abstraites et des méthodes non abstraites.

Classe abstraite Caravane (double prix privé ; modèle de chaîne privé ; année de chaîne privée ; abstract public void goFast(); //抽象方法 abstract public void changeColor(); )

Méthode abstraite

Aucune méthode n'est une implémentation de méthode abstraite, une implémentation de méthode concrète fournie par des sous-classes. Les méthodes abstraites ne peuvent pas être déclarées finales et strictes.

Toute sous-classe qui hérite d'une classe abstraite doit implémenter toutes les méthodes abstraites de la classe parente, sauf si la sous-classe est une classe abstraite.

Si une classe contient un certain nombre de méthodes abstraites, la classe doit être déclarée en tant que classe abstraite. Une classe abstraite ne peut pas contenir de méthodes abstraites.

Une déclaration de méthode abstraite se termine par un point-virgule, par exemple : public abstract pattern ();

Public abstract class SuperClass( abstract void m(); //抽象方法 ) class SubClass étend SuperClass( //实现抽象方法 void m()( ......... ) )

Modificateur synchrone

Méthode par mot-clé synchrone pour déclarer en même temps un seul accès au thread. Le modificateur synchrone peut être appliqué à quatre modificateurs d'accès.

public synchronisé void showDetails() ( ....... )

Modificateur de transition

L'objet sérialisé contient des variables transitoires d'instance de machine virtuelle Java (JVM) modifiées pour ignorer cette variable particulière.

Le modificateur est inclus dans la définition des variables d'instruction pour les classes de prétraitement des types de données et des variables.

limite int transitoire public = 55 ; // ne persistera pas public int b; // persistera

Modificateurs volatils

Une variable membre modifiée volatile à chaque accès, les threads sont obligés de relire la valeur de la variable membre à partir de la mémoire partagée. De plus, lorsque les variables membres changent, le thread est obligé de modifier la valeur réécrite dans la mémoire partagée. Ainsi, à tout moment, deux threads différents voient toujours la même valeur d'une variable membre.

La classe publique MyRunnable implémente Runnable ( private volatile boolean active; public void run() ( active = true; while (active) // 第一行 ( // 代码 )) public void stop() ( active = false; // 第二行) )

Dans des circonstances normales, un thread appelle la méthode Run () (dans Runnable d'un thread ouvert) dans un autre thread appelle la méthode stop (). Si la valeur active dans Première ligne le tampon est utilisé deuxième rang lorsque la boucle active est fausse ne s'arrête pas.

Cependant, dans le code ci-dessus, nous utilisons un actif volatil modifié pour que la boucle s'arrête.

Que vous ajoutez lors de l'initialisation pour modifier les valeurs. Le langage Java dispose d'un large éventail de modificateurs dont les principaux sont :

• modificateurs d'accès ;
• modificateurs de classe, de méthode, de variable et de thread non utilisés pour l'accès.

Pour utiliser un modificateur en Java, vous devez inclure son mot clé dans la définition d'une classe, d'une méthode ou d'une variable. Le modificateur doit venir avant le reste de l'opérateur, comme illustré dans les exemples suivants :

public class className ( // ... ) private boolean myFlag; semaines doubles finales statiques = 9,5 ; int final statique protégé BOXWIDTH = 42 ; public static void main(String arguments) ( // corps de la méthode )

Modificateurs d'accès

Java fournit un certain nombre de modificateurs d'accès pour définir les niveaux d'accès pour les classes, les variables, les méthodes et les constructeurs. Il y a quatre accès :

• Visible dans le package (par défaut et aucun modificateur requis).
• Visible uniquement à la classe (privé).
• Visible par tous (public).
• Visible par le package et toutes les sous-classes (protégé).

Modificateur d'accès par défaut - pas de mot-clé

Modificateur d'accès par défaut- signifie que nous ne déclarons pas explicitement un modificateur d'accès en Java pour une classe, un champ, une méthode, etc.

Une variable ou une méthode déclarée sans modificateur de contrôle d'accès est disponible pour toute autre classe du même package. Les champs d'une interface sont implicitement publics, statiques, finaux et les méthodes d'une interface sont publiques par défaut.

Exemple

Les variables et les méthodes peuvent être déclarées en Java sans aucun modificateur, comme illustré dans l'exemple suivant :

Version de chaîne = "1.5.1" ; boolean processOrder() ( retourne vrai; )

modificateur d'accès privé

modificateur privé- Les méthodes, variables et constructeurs déclarés privés en Java ne sont accessibles qu'au sein de la classe déclarée elle-même.

Le modificateur d'accès privé est le niveau d'accès le plus restrictif. La classe et les interfaces ne peuvent pas être privées.

Les variables déclarées privées sont accessibles en dehors de la classe si les méthodes publiques qui les reçoivent sont présentes dans la classe (voir exemple et explication ci-dessous).

L'utilisation du modificateur privé en Java est le principal moyen de masquer les données.

Exemple

La classe suivante utilise le contrôle d'accès privé :

Enregistreur de classe publique ( format de chaîne privé ; public String getFormat() ( return this.format ; ) public void setFormat(String format) ( this.format = format ; ) )

Ici la variable format classer enregistreur est privé, il n'y a donc aucun moyen pour les autres classes d'obtenir et de définir directement sa valeur.

Alors pour rendre cette variable accessible à tous, nous avons défini deux méthodes publiques : getFormat(), qui renvoie une valeur format, Et setFormat(Chaîne), qui définit sa valeur.

modificateur d'accès public

modificateur public- classe, méthode, constructeur, interface, etc. déclaré public est accessible depuis n'importe quelle autre classe. Ainsi, les champs, méthodes, blocs déclarés à l'intérieur de la classe publique sont accessibles depuis n'importe quelle classe appartenant à "l'univers" de Java.

Cependant, si nous essayons d'accéder à une classe publique dans un autre package, la classe publique doit être importée.

Grâce à l'héritage de classe, en Java, toutes les méthodes et variables publiques d'une classe sont héritées par ses sous-classes.

Exemple

La fonction suivante utilise le contrôle d'accès public :

Public static void main(String arguments) ( // ... )

Méthode principale() doit être publique. Sinon, il ne peut pas être appelé depuis l'interpréteur Java pour exécuter la classe.

modificateur d'accès protégé

modificateur protégé- Les variables, méthodes et constructeurs déclarés protégés dans une superclasse ne sont accessibles que par les sous-classes d'un autre package ou par n'importe quelle classe du package de classes protégées.

Le modificateur d'accès protégé en Java ne peut pas être appliqué aux classes et aux interfaces. Les méthodes et les champs peuvent être déclarés protégés, mais les méthodes et les champs d'une interface ne peuvent pas être déclarés protégés.

L'accès protégé donne à une sous-classe la possibilité d'utiliser une méthode ou une variable d'assistance, empêchant une classe non liée de tenter de l'utiliser.

Exemple

La classe parent suivante utilise un contrôle d'accès protégé afin que sa classe enfant remplace la méthode openSpeaker():

Class AudioPlayer ( protected boolean openSpeaker(Speaker sp) ( // détails d'implémentation ) ) class StreamingAudioPlayer ( boolean openSpeaker(Speaker sp) ( // détails d'implémentation ) )

Cependant, si nous définissons une méthode openSpeaker() comme protégé, il ne sera accessible à partir d'aucune classe autre que AudioPlayer. Si nous le définissons comme public, il deviendra accessible à tous. Mais notre intention est de n'exposer cette méthode qu'à la sous-classe, c'est pourquoi nous avons utilisé le modificateur protected.

Contrôle d'accès et règles d'héritage

Les règles suivantes en Java s'appliquent aux méthodes héritées :

• Les méthodes déclarées publiques dans une superclasse doivent également être publiques dans toutes les sous-classes.
• Les méthodes déclarées protected dans une superclasse doivent être soit protected soit public dans les sous-classes ; ils ne peuvent pas être privés.
• Les méthodes déclarées comme privées ne sont pas héritées par tout le monde, il n'y a donc pas de règle pour elles.

Modificateurs de classe, de méthode, de variable et de thread non utilisés pour l'accès

Java fournit un certain nombre de modificateurs non pas pour l'accès, mais pour implémenter de nombreuses autres fonctionnalités :

• modificateur statique utilisé pour créer des méthodes et des variables de classe ;
• modificateur final utilisé pour terminer l'implémentation des classes, des méthodes et des variables ;
• modificateur abstrait nécessaire pour créer des classes et des méthodes abstraites ;
• modificateurs synchronisé Et volatil sont utilisés en Java pour les threads.

modificateur statique

modificateur statique- utilisé pour créer des méthodes et des variables de classe.

variables statiques

Le mot-clé static est utilisé pour créer des variables qui existeront indépendamment de toute instance créée pour la classe. Une seule copie d'une variable statique existe en Java, quel que soit le nombre d'instances de la classe.

Les variables statiques sont également appelées variables de classe. En Java, les variables locales ne peuvent pas être déclarées statiques.

méthodes statiques

Le mot-clé static est utilisé pour créer des méthodes qui existeront indépendamment de toute instance créée pour la classe.

En Java, les méthodes statiques ou statiques n'utilisent aucune variable d'instance d'aucun objet de classe, elles sont définies. Les méthodes statiques prennent toutes les données des paramètres et certains de ces paramètres sont évalués sans référence aux variables.

Les variables et les méthodes de classe sont accessibles en utilisant le nom de la classe suivi d'un point et du nom de la variable ou de la méthode.

Exemple

Le modificateur statique en Java est utilisé pour créer des méthodes de classe et des variables, comme illustré dans l'exemple suivant :

Public class InstanceCounter ( private static int numInstances = 0; protected static int getCount() ( return numInstances; ) private static void addInstance() ( numInstances++; ) InstanceCounter() ( InstanceCounter.addInstance(); ) public static void main(String arguments ) ( System.out.println("À partir de " + InstanceCounter.getCount() + " instance"); for (int i = 0; i

Le résultat suivant sera obtenu :

À partir de l'instance 0 Création de 500 instances

modificateur final

modificateur final- utilisé pour compléter l'implémentation des classes, des méthodes et des variables.

variables finales

Une variable finale ne peut être initialisée qu'une seule fois. Une variable de référence déclarée finale ne peut jamais être affectée pour faire référence à un autre objet.

Cependant, les données à l'intérieur de l'objet peuvent être modifiées. Ainsi, l'état de l'objet peut être changé, mais pas la référence.

Avec les variables en Java, le modificateur final est souvent utilisé avec static pour faire d'une variable de classe une constante.

Exemple

public class Test( final int value = 10; // Voici des exemples de déclarations de constante : public static final int BOXWIDTH = 6; static final String TITLE = "(!LANG:Manager"; public void changeValue(){ value = 12; //будет получена ошибка } } !}

méthodes finales

La méthode finale ne peut être remplacée par aucune sous-classe. Comme mentionné précédemment, en Java, le modificateur final empêche qu'une méthode soit modifiée par une sous-classe.

L'intention principale de rendre une méthode définitive serait que le contenu de la méthode ne soit pas modifié par la même occasion.

Exemple

La déclaration d'une méthode qui utilise le modificateur final dans une déclaration de classe est illustrée dans l'exemple suivant :

Classe publique Test( public final void changeName() ( // corps de la méthode ) )

classe finale

L'objectif principal en Java de l'utilisation d'une classe déclarée comme finale est d'empêcher la classe d'être sous-classée. Si une classe est marquée final, aucune classe ne peut hériter d'aucune fonction de la classe finale.

Exemple

public final class Test ( // corps de la classe )

modificateur abstrait

modificateur abstrait- utilisé pour créer des classes et des méthodes abstraites.

classe abstraite

La classe abstraite ne peut pas être instanciée. Si une classe est déclarée abstraite, alors son seul but est d'être étendue.

Une classe ne peut pas être à la fois abstraite et finale, car une classe finale ne peut pas être étendue. Si une classe contient des méthodes abstraites, elle doit être déclarée abstraite. Sinon, une erreur de compilation sera générée.

Une classe abstraite peut contenir à la fois des méthodes abstraites et des méthodes ordinaires.

Exemple

abstract class Caravan( private double price; private String model; private String year; public abstract void goFast(); //abstract method public abstract void changeColor(); )

méthode abstraite

Une méthode abstraite est une méthode déclarée avec n'importe quelle implémentation. Le corps de la méthode (implémentation) est fourni par la sous-classe. Les méthodes abstraites ne peuvent jamais être définitives ou strictes.

Toute classe qui étend une classe abstraite doit implémenter toutes les méthodes abstraites de la superclasse, sauf si la sous-classe est une classe abstraite.

Si une classe en Java contient une ou plusieurs méthodes abstraites, alors la classe doit être déclarée abstraite. Une classe abstraite n'est pas obligée de contenir des méthodes abstraites.

Une méthode abstraite se termine par un point-virgule. Exemple : public abstract sample();

Exemple

public abstract class SuperClass( abstract void m(); //méthode abstraite ) class SubClass extend SuperClass( // implémente la méthode abstraite void m())( ......... ) )

modificateur synchronisé

modificateur synchronisé

Le mot clé synchronized est utilisé pour indiquer qu'une méthode n'est accessible que par un seul thread à la fois. En Java, le modificateur synchronized peut être appliqué avec n'importe lequel des quatre modificateurs de niveau d'accès.

Exemple

public synchronisé void showDetails() ( ....... )

modificateur transitoire

Une variable d'instance marquée transitoire indique à la machine virtuelle Java (JVM) d'ignorer la variable particulière lors de la sérialisation de l'objet qui la contient.

Ce modificateur est inclus dans l'instruction, qui crée une variable de la classe ou du type de données prédécesseur de la variable.

Exemple

limite int transitoire public = 55 ; // ne persistera pas public int b; // sera sauvegardé

modificateur volatil

modificateur volatil- sont utilisés en Java pour les threads.

En Java, le modificateur volatile est utilisé pour faire savoir à la JVM qu'un thread d'accès à une variable doit toujours fusionner sa propre copie de la variable avec la copie principale en mémoire.

L'accès à une variable volatile synchronise toutes les variables copiées en cache dans la RAM. Volatile ne peut être appliqué qu'aux variables d'instance de type object ou private. Une référence à un objet volatile peut être nulle.

Exemple

public class MyRunnable implémente Runnable( private volatile boolean active; public void run())( active = true; while (active)( // line 1 // some code here) ) public void stop() (active = false; // line 2 ) )

Typiquement, run() est appelé sur un thread (c'est la première fois que vous utilisez Runnable en Java) et stop() est appelé sur un autre thread. Si la valeur mise en cache active est utilisée sur la ligne 1, la boucle ne peut pas s'arrêter tant que vous n'avez pas défini active sur false sur la ligne 2.

Dans la prochaine leçon, nous aborderons les opérateurs de base utilisés dans le langage Java. Cette section vous donnera un aperçu de la façon dont vous pouvez les utiliser lors du développement d'applications.

Ici, nous allons essayer de considérer presque tous les cas d'utilisation de modificateurs d'accès. La seule exception est leur utilisation pour imbriqué ( imbriqué) et interne ( intérieur), ainsi que pour les interfaces, car nous n'avons pas encore abordé ces sujets.

Les classes et les packages utilisés conjointement avec les modificateurs d'accès servent de moyen d'encapsulation, c'est-à-dire un moyen de masquer les détails d'implémentation derrière une interface simple.

Les modificateurs d'accès peuvent être appliqués aux classes et à leurs membres - champs et méthodes. Il y a quatre modificateurs d'accès au total, et ici nous en donnerons une brève description, puis nous examinerons chacun en détail.

• Publique- tout composant déclaré comme Publique, accessible depuis n'importe quel code
• protégé- permet l'accès au composant dans le package et les classes aux descendants
• privé- permet l'accès aux composants de la classe
• défaut(pas de mot-clé) - permet d'accéder aux composants du package

Les classes descendantes sont des classes héritées d'une classe. L'héritage que nous n'avons pas encore étudié.

Accès aux cours

Par défaut, les classes de niveau supérieur sont disponibles dans le package dans lequel elles sont définies.. Cependant, si la classe de niveau supérieur est déclarée comme Publique, alors il est disponible partout (ou partout où le package lui-même est disponible). Nous avons limité cette instruction aux classes de niveau supérieur car les classes peuvent être déclarées comme membres d'autres classes. Étant donné que ces classes internes sont membres de la classe, elles sont soumises aux règles de contrôle d'accès pour les membres de la classe..

Accès aux membres de la classe

Les membres du cours sont toujours disponibles au sein du corps du cours. Défaut les membres de la classe sont également disponibles dans le package dans lequel la classe est définie.

modificateur public

Pour une classe non imbriquée, un seul des deux niveaux d'accès possibles peut être spécifié : donné défaut Et Publique . Lorsque la classe est déclarée comme Publique, ce devrait être le seul Publique classe déclarée dans le fichier, et le nom du fichier doit correspondre au nom de la classe.

Comment Publique les classes, les champs, les méthodes et les constructeurs peuvent être déclarés.

modificateur protégé

Nous discuterons de ce modificateur en détail dans le sujet de l'héritage de classe. Si l'héritage n'est pas utilisé, alors ce modificateur fonctionne, tout comme le modificateur par défaut.

La seule chose que l'on peut maintenant dire brièvement est que pour les composants déclarés comme protégé, aura accès n'importe quelle classe enfant de n'importe quel forfait ou n'importe quelle classe du même package.

Comment protégé les champs, les méthodes, les constructeurs, les classes imbriquées et les interfaces imbriquées peuvent être déclarés.

protégé .

modificateur privé

C'est le modificateur d'accès le plus restrictif. Éléments déclarés comme privé disponible uniquement au sein de la même classe et non à quiconque en dehors de la classe.

Comment privé les champs, les méthodes, les constructeurs, les classes imbriquées et les intérêts imbriqués peuvent être déclarés.

Les classes et les interfaces de niveau supérieur ne peuvent pas être déclarées comme privé .

Essentiellement, les modificateurs d'accès sont un sujet simple, mais nous y reviendrons plus tard. Pour l'instant, ce n'était qu'une introduction. Et maintenant, place à la pratique...

J'ai créé les classes Mod02.java, DefMod.java, ProMod.java et PrvMod.java qui appartiennent au package pro.java.pkg002, et la classe PubMod.java qui appartient au package pro.java.pkg003. Ensuite, je vais juste donner des captures d'écran de ces classes et le résultat du programme :

Dernière mise à jour : 03.10.2019

Tous les membres d'une classe - champs, méthodes, propriétés - ils ont tous modificateurs d'accès. Les modificateurs d'accès vous permettent de définir la portée autorisée pour les membres de classe. Autrement dit, les modificateurs d'accès définissent le contexte dans lequel une variable ou une méthode donnée peut être utilisée. Dans les rubriques précédentes, nous l'avons déjà rencontré lorsque nous avons déclaré des champs de classe publics (c'est-à-dire avec le modificateur public).

C# utilise les modificateurs d'accès suivants :

public : public, classe publique ou membre de la classe. Un tel membre de classe est accessible de n'importe où dans le code, ainsi que d'autres programmes et assemblages.

privé : classe privée ou membre de la classe. Représente l'exact opposé du modificateur public. Une telle classe privée ou un tel membre de classe n'est accessible qu'à partir du code de la même classe ou du même contexte.

protected : Un tel membre de classe est accessible de n'importe où dans la classe courante ou dans les classes dérivées. Dans ce cas, les classes dérivées peuvent se trouver dans d'autres assemblys.

internal : une classe et les membres de la classe avec un modificateur similaire sont accessibles de n'importe où dans le code du même assembly, mais il n'est pas accessible aux autres programmes et assemblys (comme c'est le cas avec le modificateur public).

protected internal : combine les fonctionnalités de deux modificateurs. Les classes et les membres de classe avec ce modificateur sont accessibles à partir de l'assembly actuel et des classes dérivées.

private protected : un tel membre de classe est accessible de n'importe où dans la classe actuelle ou dans les classes dérivées définies dans le même assembly.

Nous pouvons définir explicitement le modificateur d'accès, par exemple :

État de la classe protégée privée ( interne int a; protégé void Print() ( Console.WriteLine($"a = (a)"); ) )

Ou nous ne pouvons pas spécifier:

État de la classe ( int a; void Print() ( Console.WriteLine($"a = (a)"); ) )

Si aucun modificateur d'accès n'est défini pour les champs et les méthodes, le modificateur privé est appliqué par défaut.

Les classes et les structures déclarées sans modificateur ont un accès interne par défaut.

Toutes les classes et structures définies directement dans les espaces de noms et non imbriquées dans d'autres classes ne peuvent avoir que des modificateurs publics ou internes.

Prenons un exemple et créons la classe State suivante :

Public class State ( // peu importe si private int defaultVar; int defaultVar; // le champ n'est accessible qu'à partir de la classe actuelle private int privateVar; // accessible à partir de la classe actuelle et des classes dérivées définies dans le même project protected private int protectedPrivateVar ; // accessible à partir de la classe actuelle et des classes dérivées protected int protectedVar ; // disponible n'importe où dans le projet actuel internal int internalVar ; // disponible n'importe où dans le projet actuel et à partir des classes dérivées d'autres projets protected internal int protectedInternalVar; // disponible partout dans le programme, ainsi que pour d'autres programmes et assemblages public int publicVar; // par défaut, il a le modificateur private void defaultMethod() => Console.WriteLine($"defaultVar = (defaultVar)" ); // la méthode n'est disponible que depuis la classe courante private void privateMethod() => Console.WriteLine($"privateVar = (privateVar)"); // accessible depuis la classe courante et les classes dérivées qui sont définies dans la même clause projet protégé privé void protectedPrivateMethod() => Console.WriteLine($"protectedPrivateVar = (protectedPrivateVar)"); // accessible depuis la classe courante et les classes dérivées protected void protectedMethod()=> Console.WriteLine($"protectedVar = (protectedVar)"); // disponible n'importe où dans le projet en cours internal void internalMethod() => Console.WriteLine($"internalVar = (internalVar)"); // accessible n'importe où dans le projet en cours et depuis les classes dérivées d'autres projets protected internal void protectedInternalMethod() => Console.WriteLine($"protectedInternalVar = (protectedInternalVar)"); // disponible n'importe où dans le programme, ainsi que pour d'autres programmes et assemblages public void publicMethod() => Console.WriteLine($"publicVar = (publicVar)"); )

Étant donné que la classe State est déclarée avec le modificateur public, elle sera accessible de n'importe où dans le programme, ainsi que d'autres programmes et assemblys. La classe State comporte cinq champs pour chaque niveau d'accès. Plus une variable non modifiée qui est privée par défaut.

Il existe également six méthodes qui afficheront les valeurs des champs de classe à l'écran. Veuillez noter que puisque tous les modificateurs vous permettent d'utiliser des membres de classe dans cette classe, toutes les variables de classe, y compris les variables privées, sont disponibles pour toutes ses méthodes, puisqu'elles sont toutes dans le contexte de la classe State.

Voyons maintenant comment nous pouvons utiliser nos variables de classe dans le programme (c'est-à-dire dans la méthode Main de la classe Program), si les classes State et Program sont dans le même projet :

Class Program ( static void Main(string args) ( State state1 = new State(); // nous ne pourrons pas attribuer de valeur à la variable defaultVar, // puisqu'elle a un modificateur privé et que la classe Program ne voit pas it // Et l'environnement ne voit pas cette ligne soulignée comme incorrecte state1.defaultVar = 5 ; // Erreur, inaccessible // idem pour la variable privateVar state1.privateVar = 5 ; // Erreur, inaccessible // affectation la valeur de la variable protectedPrivateVar ne fonctionnera pas, // puisque la classe Program n'est pas une classe qui hérite de la classe State state1.protectedPrivateVar =5 ; // Erreur, inaccessible // l'attribution d'une valeur à la variable protectedVar échouera également, // parce que la classe Program n'est pas une classe qui hérite de la classe State state1.protectedVar = 5; // Erreur, inaccessible // la variable internalVar avec le modificateur interne est disponible de n'importe où dans le projet en cours // donc nous peut lui attribuer en toute sécurité une valeur state1.internalVar = 5 ; // La variable protectedInternalVar est également accessible de n'importe où dans le projet en cours state1.protectedInternalVar = 5; // variable publicVar est public state1.publicVar = 5; ) )

Ainsi, nous n'avons pu définir que les variables internalVar, protectedInternalVar et publicVar, car leurs modificateurs nous permettent de les utiliser dans ce contexte.

Il en est de même pour les méthodes :

Class Program ( static void Main(string args) ( State state1 = new State(); state1.defaultMethod(); //Erreur, inaccessible state1.privateMethod(); // Erreur, inaccessible state1.protectedPrivateMethod() ; // Erreur, inaccessible state1.protectedMethod(); // Erreur, inaccessible state1.internalMethod(); // ok state1.protectedInternalMethod(); // ok state1.publicMethod(); // ok ) )

Ici, seules trois méthodes se sont avérées disponibles pour nous : internalMethod, protectedInternalMethod, publicMethod, qui ont respectivement les modificateurs internal, protected internal, public.

Grâce à un tel système de modificateurs d'accès, il est possible de cacher certains aspects de l'implémentation de la classe à d'autres parties du programme.

Malgré le fait que les modificateurs publics et internes sont similaires dans leur effet, ils ont une grande différence. Les classes et les membres de classe avec le modificateur public seront également disponibles pour d'autres programmes, si la classe donnée est placée dans une dll de bibliothèque dynamique, puis utilisée dans ces programmes.