La langue Java fournit de nombreux modificateurs, principalement divisés en les deux catégories suivantes:
Les modificateurs sont utilisés pour définir des classes, des méthodes ou des variables, et sont généralement placés à l'avant d'une instruction. Utilisons les exemples suivants pour illustrer:
classe publique classe classname {// ...} private boolean myflag; static final doubles semaines = 9,5; protégé statique final int boxwidth = 42; public static void main (string [] arguments) {// Method Body}}Modificateur de contrôle d'accès
En Java, les contrôles d'accès peuvent être utilisés pour protéger l'accès aux classes, aux variables, aux méthodes et aux constructeurs. Java prend en charge 4 autorisations d'accès différentes.
La valeur par défaut, également connue sous le nom de défaut, est visible dans le même package sans utiliser de modificateurs.
Privé, spécifié avec le modificateur privé, visible dans la même classe.
Common, spécifié par le modificateur public, visible par toutes les classes.
Protégé, spécifié avec le modificateur protégé, visible par les classes et toutes les sous-classes dans le même package.
Modificateur d'accès par défaut - aucun mot-clé n'est utilisé
Les variables et les méthodes déclarées par défaut des modificateurs d'accès sont visibles aux classes du même package. Toutes les variables de l'interface sont implicitement déclarées par défaut de finale statique publique, tandis que les méthodes de l'interface sont publiques par défaut.
Exemple:
Comme le montre l'exemple suivant, la déclaration de variables et de méthodes peut être sans modificateurs.
String version = "1.5.1"; Boolean ProcessOrder () {return true;}Modificateur d'accès privé - privé
Les modificateurs d'accès privé sont le niveau d'accès le plus strict, donc les méthodes, les variables et les constructeurs déclarés comme privés ne peuvent être accessibles que par la classe à laquelle ils appartiennent, et les classes et les interfaces ne peuvent pas être déclarées privées.
Les variables déclarées comme type d'accès privé ne peuvent être accessibles que par des classes externes via des méthodes de Getter public dans la classe.
L'utilisation du modificateur d'accès privé est principalement utilisée pour masquer les détails de l'implémentation de la classe et protéger les données de la classe.
La classe suivante utilise un modificateur d'accès privé:
Classe publique Logger {Format de chaîne privée; public String getformat () {return this.format; } public void setFormat (string format) {this.format = format; }}Dans l'exemple, la variable de format dans la classe Logger est une variable privée, de sorte que d'autres classes ne peuvent pas obtenir directement et définir la valeur de la variable. Pour permettre à d'autres classes de manipuler la variable, deux méthodes publiques sont définies: getFormat () (renvoie la valeur du format) et setFormat (String) (définit la valeur du format)
Modificateur d'accès public - public
Les classes, méthodes, constructeurs et interfaces déclarés comme public peuvent être accessibles par toute autre classe.
Si plusieurs classes publiques qui se consacrent les unes aux autres sont distribuées dans différents packages, vous devez importer le package où se trouve la classe publique correspondante. En raison de l'héritage de la classe, toutes les méthodes publiques et variables de la classe peuvent être héritées par ses sous-classes.
Les fonctions suivantes utilisent le contrôle d'accès public:
public static void main (string [] arguments) {// ...}La méthode principale () d'un programme Java doit être définie en public, sinon, l'interprète Java ne pourra pas exécuter la classe.
Modificateur d'accès protégé - protégé
Les variables, les méthodes et les constructeurs déclarés comme protégés peuvent être accessibles par toute autre classe du même package, ou par des sous-classes dans différents packages.
Le modificateur d'accès protégé ne peut pas modifier les classes et les interfaces. Les méthodes et les variables des membres peuvent être déclarées protégées, mais les variables des membres et les méthodes des membres de l'interface ne peuvent pas être déclarés protégés.
Les sous-classes peuvent accéder aux méthodes et variables déclarées par le modificateur protégé, afin qu'ils puissent protéger les classes non liées de l'utilisation de ces méthodes et variables.
La classe parent suivante utilise le modificateur d'accès protégé et la sous-classe surcharge la méthode OpenSpeaker () de la classe parent.
classe AudioPlayer {Boolean OpenSpeaker protégé (Speaker SP) {// Détails d'implémentation}} classe StreamingAudiOplayer {Boolean OpenSpeaker (haut-parleur SP) {// Détails d'implémentation}}Si la méthode OpenSpeaker () est déclarée privée, les classes autres que AudioPlayer ne pourront pas accéder à la méthode. Si OpenSpeaker () est déclaré public, toutes les classes peuvent accéder à la méthode. Si nous voulons que la méthode soit visible uniquement pour une sous-classe de la classe dans laquelle il se trouve, alors déclarez la méthode protégée.
Contrôle d'accès et héritage
Veuillez noter les règles de succession suivantes:
Modificateur non accessible
Pour implémenter d'autres fonctions, Java fournit également de nombreux modificateurs non-access.
Le modificateur statique est utilisé pour créer des méthodes de classe et des variables de classe.
Le modificateur final est utilisé pour modifier les classes, les méthodes et les variables. La classe modifiée par final ne peut pas être héritée, la méthode modifiée ne peut pas être redéfinie par la classe héritée, et la variable modifiée est une constante et ne peut pas être modifiée.
Résumé RODIFICATEUR, utilisé pour créer des classes abstraites et des méthodes abstraites.
Les modificateurs synchronisés et volatils sont principalement utilisés pour la programmation de threads.
Modificateur statique
Le mot-clé statique est utilisé pour déclarer des variables statiques indépendamment des objets. Peu importe le nombre d'objets qu'une classe instancie, il n'a qu'une seule copie de sa variable statique. Les variables statiques sont également appelées variables de classe. Les variables locales peuvent être déclarées comme variables statiques.
Le mot-clé statique est utilisé pour déclarer des méthodes statiques indépendamment des objets. Les méthodes statiques ne peuvent pas utiliser les variables non statiques de la classe. La méthode statique obtient les données de la liste des paramètres, puis calcule les données.
L'accès aux variables et méthodes de classe est accessible directement à l'aide de className.variabbleName et className.MethodName.
Comme le montre l'exemple suivant, le modificateur statique est utilisé pour créer des méthodes de classe et des variables de classe.
classe publique InstanceCounter {private static int numInStances = 0; protégé static int getCount () {return numInStances; } private static void addInstance () {numInStances ++; } InstanceCounter () {instanceCounter.addinstance (); } public static void main (string [] arguments) {System.out.println ("commençant par" + instanceCounter.getCount () + "instances"); pour (int i = 0; i <500; ++ i) {new instanceCounter (); } System.out.println ("créé" + instanceCounter.getCount () + "instances"); }}Les exemples ci-dessus sont exécutés et modifiés comme suit:
Commencé avec 0 instances
Créé 500 instances
Modificateur final
Variables finales:
Les variables finales peuvent être explicitement initialisées et ne peuvent être initialisées qu'une seule fois. Les références aux objets déclarés comme final ne peuvent pas pointer vers différents objets. Mais les données de l'objet final peuvent être modifiées. En d'autres termes, la référence à l'objet final ne peut pas être modifiée, mais la valeur à l'intérieur peut être modifiée.
Les modificateurs finaux sont généralement utilisés avec des modificateurs statiques pour créer des constantes de classe.
Exemple:
Classe publique Test {final int value = 10; // ci-dessous est un exemple déclarant un boxWidth intrie statique statique constant = 6; Title de chaîne finale statique = "Manager"; public void ChangeValue () {value = 12; // Une erreur sera sortie}}Méthode finale
La méthode finale de la classe peut être héritée par la sous-classe, mais ne peut pas être modifiée par la sous-classe.
L'objectif principal de déclarer une méthode finale est d'empêcher la modification du contenu de la méthode.
Comme indiqué ci-dessous, déclarez la méthode à l'aide du modificateur final.
Test de classe publique {public final void changeName () {// Method Body}}Classe finale
Les classes finales ne peuvent pas être héritées et aucune classe ne peut hériter de fonctionnalités des classes finales.
Exemple:
Test de classe finale publique {// Classe Body}Rabordant abstrait
Classe abstraite:
Les classes abstraites ne peuvent pas être utilisées pour instancier des objets. Le seul but de déclarer les classes abstraites est d'élargir la classe à l'avenir.
Une classe ne peut pas être modifiée par abstraite et finale en même temps. Si une classe contient des méthodes abstraites, la classe doit être déclarée comme une classe abstraite, sinon une erreur de compilation se produira.
Les classes abstraites peuvent contenir des méthodes abstraites et des méthodes non abstraites.
Exemple:
Classe abstraite Caravan {double prix privé; modèle de chaîne privé; Année de chaîne privée; Abstract public void gofast (); // Méthode abstraite public abstract void changecolor ();}Méthodes abstraites
Une méthode abstraite est une méthode sans aucune implémentation, et l'implémentation spécifique de la méthode est fournie par une sous-classe. 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 parent à moins que la sous-classe soit également une classe abstraite.
Si une classe contient plusieurs méthodes abstraites, la classe doit être déclarée comme une classe abstraite. Les classes abstraites peuvent ne pas contenir de méthodes abstraites.
La déclaration d'une méthode abstraite se termine par un point-virgule, par exemple: échantillon abstrait public ();
Exemple:
Classe abstraite publique Superclass {Résumé Void m (); // Méthode abstraite} La sous-classe de classe étend Superclass {// implément la méthode abstraite void m () {.........}}Modificateur synchronisé
La méthode déclarée par le mot-clé synchronisé ne peut être accessible qu'en un seul thread en même temps. Le modificateur synchronisé peut être appliqué à quatre modificateurs d'accès.
Exemple:
public synchronisé void showdetails () {......}Modificateur transitoire
Lorsqu'un objet sérialisé contient une variable d'instance modifiée transitoire, la machine virtuelle Java (JVM) saute cette variable spécifique.
Ce modificateur est inclus dans une instruction qui définit une variable et est utilisée pour prétraiter les types de données de classes et de variables.
Exemple:
LIMIT INT transitoire public = 55; // ne persistera pas Int B; // persistera
modificateur volatil
Les variables de membres modifiées volatiles sont obligées de revoir la valeur de la variable membre à partir de la mémoire partagée chaque fois qu'ils sont accessibles par un thread. De plus, lorsque la variable membre change, le thread est obligé de réécrire la valeur de modification en mémoire partagée. De cette façon, à tout moment, deux threads différents voient toujours la même valeur d'une certaine variable de membre. Une référence d'objet volatile peut être nul.
Exemple:
classe publique Myrunnable Implements Runnable {private volatile booléen actif; public void run () {active = true; while (active) // line 1 {// code}} public void stop () {active = false; // ligne 2}}Généralement, la méthode run () est appelée dans un thread et la méthode stop () est appelée dans un autre thread. Si la valeur de la ligne 1 active dans le tampon est utilisée, la boucle ne s'arrêtera pas lorsque la ligne active de la ligne 2 est définie sur false.
Ce qui précède est tout le contenu de cet article. J'espère que le contenu de cet article sera d'une aide à l'étude ou au travail de chacun. J'espère également soutenir plus Wulin.com!