Le langage Java propose de nombreux modificateurs, qui se répartissent principalement dans 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 au début de l'instruction. Nous illustrons cela à travers l’exemple suivant :
public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // 方法体}En Java, les contrôles d'accès peuvent être utilisés pour protéger l'accès aux classes, variables, méthodes et constructeurs. Java prend en charge 4 droits d'accès différents.
La valeur par défaut, également appelée valeur par défaut, est visible dans le même package et n'utilise aucun modificateur.
Private, spécifié avec le modificateur private, visible au sein de la même classe.
Public, spécifié avec le modificateur public, visible par toutes les classes.
Protected, spécifié avec le modificateur protected, est visible par les classes et toutes les sous-classes du même package.
Les variables et méthodes déclarées avec les modificateurs d'accès par défaut sont visibles par les classes du même package. Les variables de l'interface sont implicitement déclarées comme public static final , tandis que les méthodes de l'interface ont des autorisations d'accès public par défaut.
Exemple:
Comme le montre l'exemple suivant, les variables et les méthodes peuvent être déclarées sans aucun modificateur.
String version = "1.5.1"; boolean processOrder() { return true; }Le modificateur d'accès privé est le niveau d'accès le plus restrictif, donc les méthodes, variables et constructeurs déclarés comme privés ne sont accessibles que par la classe à laquelle ils appartiennent, et les classes et interfaces ne peuvent pas être déclarées comme privées.
Les variables déclarées comme types d'accès privés ne sont accessibles qu'aux classes externes via les méthodes getter publiques de la classe.
L'utilisation du modificateur d'accès privé est principalement utilisée pour masquer les détails d'implémentation de la classe et protéger les données de la classe.
La classe suivante utilise le modificateur d'accès privé :
public class Logger { private String format; public String getFormat() { return this.format; } public void setFormat(String format) { this.format = format; } } Dans l'exemple, la variable de format de la classe Logger est une variable privée, donc les autres classes ne peuvent pas obtenir et définir directement la valeur de la variable. Afin de permettre à d'autres classes d'exploiter cette variable, deux méthodes public sont définies : getFormat() (renvoie la valeur du format) et setFormat(String) (définit la valeur du format)
Les classes, méthodes, constructeurs et interfaces déclarés publics sont accessibles à toute autre classe.
Si plusieurs classes publiques qui accèdent les unes aux autres sont distribuées dans des packages différents, vous devez importer le package dans lequel se trouve la classe publique correspondante. En raison de l'héritage de classe, toutes les méthodes et variables publiques d'une 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 main() du programme Java doit être définie sur public, sinon l'interpréteur Java ne pourra pas exécuter la classe.
Les variables, méthodes et constructeurs déclarés comme protégés sont accessibles par n'importe quelle autre classe du même package, ou par des sous-classes dans des packages différents.
Les modificateurs d'accès protégés ne peuvent pas modifier les classes et les interfaces. Les méthodes et les variables membres peuvent être déclarées protégées, mais les variables membres et les méthodes membres des interfaces ne peuvent pas être déclarées protégées.
Les sous-classes peuvent accéder aux méthodes et variables déclarées avec le modificateur Protected, protégeant ainsi 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 remplace la méthode openSpeaker() de la classe parent.
class AudioPlayer { protected boolean openSpeaker(Speaker sp) { // 实现细节} } class StreamingAudioPlayer extends AudioPlayer { boolean openSpeaker(Speaker sp) { // 实现细节} }Si la méthode openSpeaker() est déclarée privée, les classes autres qu'AudioPlayer ne pourront pas accéder à cette méthode.
Si openSpeaker() est déclaré public, toutes les classes peuvent accéder à cette méthode.
Si nous voulons que la méthode soit visible uniquement par les sous-classes de sa classe, déclarez la méthode comme protégée.
Veuillez noter les règles suivantes pour l'héritage de méthode :
Les méthodes déclarées comme publiques dans la classe parent doivent également l'être dans la classe enfant.
Les méthodes déclarées comme protégées dans la classe parent sont soit déclarées comme protégées, soit publiques dans la sous-classe. Ne peut pas être déclaré privé.
Les méthodes déclarées comme privées dans la classe parent ne peuvent pas être héritées.
Afin d'implémenter d'autres fonctions, Java fournit également de nombreux modificateurs de non-accès.
modificateur statique, 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. Les classes modifiées par final ne peuvent pas être héritées, les méthodes modifiées ne peuvent pas être redéfinies par les classes héritées et les variables modifiées sont des constantes et ne peuvent pas être modifiées.
modificateur abstrait, utilisé pour créer des classes abstraites et des méthodes abstraites.
Les modificateurs synchronisés et volatiles sont principalement utilisés pour la programmation des threads.
Variables statiques :
Le mot-clé static est utilisé pour déclarer des variables statiques indépendantes des objets. Quel que soit le nombre d'objets qu'une classe instancie, il n'existe qu'une seule copie de ses variables statiques. Les variables statiques sont également appelées variables de classe. Les variables locales ne peuvent pas être déclarées comme variables statiques.
Méthode statique :
Le mot clé static est utilisé pour déclarer des méthodes statiques indépendantes des objets. Les méthodes statiques ne peuvent pas utiliser de variables non statiques de la classe. Les méthodes statiques récupèrent les données d'une liste de paramètres, puis calculent les données.
L'accès aux variables et méthodes de classe est directement accessible à l'aide de classname.variablename et classname.methodname .
Comme le montre l'exemple suivant, le modificateur static 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("Starting with " + InstanceCounter.getCount() + " instances"); for (int i = 0; i < 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }Les résultats de l'édition de l'exemple ci-dessus sont les suivants :
Started with 0 instances Created 500 instancesvariables finales :
Les variables finales peuvent être initialisées explicitement et une seule fois. Les références aux objets déclarés final ne peuvent pas pointer vers des objets différents. Mais les données de l'objet final peuvent être modifiées. En d’autres termes, la référence de l’objet final ne peut pas être modifiée, mais la valeur à l’intérieur peut être modifiée.
Le modificateur final est souvent utilisé avec le modificateur static pour créer des constantes de classe.
Exemple:
public class Test{ final int value = 10; // 下面是声明常量的实例public static final int BOXWIDTH = 6; static final String TITLE = "Manager"; public void changeValue(){ value = 12; //将输出一个错误} }La méthode Final d'une classe peut être héritée par les sous-classes, mais ne peut pas être modifiée par les sous-classes.
Le but principal de la déclaration d’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.
public class Test{ public final void changeName(){ // 方法体} }Les classes finales ne peuvent pas être héritées et aucune classe ne peut hériter des caractéristiques d'une classe finale.
Exemple:
public final class Test { // 类体}Classe abstraite :
Les classes abstraites ne peuvent pas être utilisées pour instancier des objets. Le seul but de la déclaration d'une classe abstraite est d'étendre la classe dans le futur.
Une classe ne peut pas être modifiée par abstract et final en même temps. Si une classe contient des méthodes abstraites, elle doit être déclarée comme 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:
abstract class Caravan{ private double price; private String model; private String year; public abstract void goFast(); //抽象方法public abstract void changeColor(); }Une méthode abstraite est une méthode sans aucune implémentation. L'implémentation spécifique de la méthode est fournie par la sous-classe. Les méthodes abstraites ne peuvent pas être déclarées finales et statiques.
Toute sous-classe qui hérite d'une classe abstraite doit implémenter toutes les méthodes abstraites de la classe parent, sauf si la sous-classe est également une classe abstraite.
Si une classe contient plusieurs méthodes abstraites, alors la classe doit être déclarée comme classe abstraite. Une classe abstraite n'a pas besoin de contenir des méthodes abstraites.
La déclaration d'une méthode abstraite se termine par un point-virgule, par exemple : public abstract sample();
Exemple:
public abstract class SuperClass{ abstract void m(); //抽象方法} class SubClass extends SuperClass{ //实现抽象方法void m(){ ......... } }La méthode déclarée avec le mot-clé synchronisé n'est accessible que par un seul thread à la fois. Le modificateur Synchronisé peut être appliqué à quatre modificateurs d'accès.
Exemple:
public synchronized void showDetails(){ ....... }Lorsque l'objet sérialisé contient une variable d'instance modifiée par un caractère transitoire, la machine virtuelle Java (JVM) ignore cette variable particulière.
Ce modificateur est inclus dans l'instruction qui définit la variable et est utilisé pour prétraiter le type de données de la classe et de la variable.
Exemple:
public transient int limit = 55; // will not persist public int b; // will persistChaque fois qu'un thread accède à une variable membre modifiée de manière volatile, la valeur de la variable membre est forcée d'être relue à partir de la mémoire partagée. De plus, lorsqu'une variable membre change, le thread est obligé de réécrire la valeur modifiée dans la mémoire partagée. De cette façon, à tout moment, deux threads différents voient toujours la même valeur d'une variable membre.
Une référence d'objet volatile peut être nulle.
Exemple:
public class MyRunnable implements Runnable { private volatile boolean active; public void run() { active = true; while (active) // line 1 { // 代码} } public void stop() { active = false; // line 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 active dans la ligne 1 du tampon est utilisée, alors la boucle ne s'arrêtera pas lorsque active dans la ligne 2 est définie sur false.