Modificateurs Java

Le langage Java fournit de nombreux modificateurs, principalement divisés en deux catégories suivantes :

  • Modificateurs d'accès
  • Modificateurs non d'accès

Les modificateurs sont utilisés pour définir des classes, des méthodes ou des variables, et sont généralement placés tout au début d'une instruction. Nous allons l'illustrer avec 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) { //Corps de méthode }

Modificateurs de contrôle d'accès

En Java, les modificateurs de contrôle 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 niveaux d'accès différents.

  • default(c'est-à-dire par défaut, rien d'écrit) : Visible au sein du même package, sans utiliser aucun modificateur. S'applique à : classes, interfaces, variables, méthodes.

  • private: Visible au sein de la même classe. S'applique à : variables, méthodes.Remarque : Impossible de modifier les classes (classes externes)

  • public: Visible par toutes les classes. S'applique à : classes, interfaces, variables, méthodes

  • protected: Visible par les classes du même package et toutes les sous-classes. S'applique à : variables, méthodes.Remarque : Impossible de modifier les classes (classes externes)。

Nous pouvons illustrer les niveaux d'accès avec le tableau suivant :

Contrôle d'accès
Modificateur Classe courante Même package Sous-classes (même package) Sous-classes (package différent) Autres packages
public Y Y Y Y Y
protected Y Y Y Y/N（Description） N
default Y Y Y N N
private Y N N N N

Modificateur d'accès par défaut - Sans utiliser aucun mot-clé

Si aucun modificateur d'accès n'est spécifié dans la définition d'une classe, d'une variable, d'une méthode ou d'un constructeur, ceux-ci auront par défaut le modificateur d'accès par défaut.

Le niveau d'accès du modificateur d'accès par défaut est au niveau du package, ce qui signifie qu'il n'est accessible que par les autres classes du même package.

Comme le montre l'exemple ci-dessous, les variables et les méthodes peuvent être déclarées sans utiliser de modificateur.

Exemple

// MyClass.java class MyClass { //Modificateur d'accès par défaut int x = 10; //Modificateur d'accès par défaut void display() { //Modificateur d'accès par défaut System.out.println("La valeur de x est : " + x); } } // MyOtherClass.java class MyOtherClass { public static void main(String[] args) { MyClass obj = new MyClass(); obj.display(); //Accéder aux variables et méthodes avec le modificateur d'accès par défaut dans MyClass } }

Dans l'exemple ci-dessus, la classe MyClass ainsi que sa variable membre x et sa méthode display() sont toutes définies à l'aide du modificateur d'accès par défaut. La classe MyOtherClass se trouve dans le même package, elle peut donc accéder à la classe MyClass ainsi qu'à ses variables et méthodes membres.

Modificateur d'accès Private - private

Le modificateur d'accès private est le niveau d'accès le plus restrictif, donc les méthodes, variables et constructeurs déclarés commeprivateles méthodes, variables et constructeurs ne peuvent être accédés que par la classe propriétaire, et les classes et interfaces ne peuvent pas être déclarées commeprivate。

Les variables déclarées avec le type d'accès private ne peuvent être accédées par des classes externes que via des méthodes getter de type public dans la classe.

L'utilisation du modificateur d'accès Private vise principalement à 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 private :

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 format dans la classe Logger est une variable private, donc les autres classes ne peuvent pas directement obtenir ou définir la valeur de la variable. Afin de permettre à d'autres classes de manipuler la variable, deux méthodes de type public sont définies : getFormat() (renvoie la valeur de format) et setFormat(String) (définit la valeur de format)

Modificateur d'accès Public - public

Les classes, méthodes, constructeurs et interfaces déclarés comme public peuvent être accessibles à toute autre classe.

Si plusieurs classes déclarées public qui s'accèdent mutuellement sont réparties dans différents paquetages, vous devez importer le paquetage contenant les classes déclarées public correspondantes. En raison de l'héritage des classes, toutes les méthodes et variables public d'une classe peuvent être héritées par ses sous-classes.

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

public static void main(String[] arguments) { // ... }

La méthode main() d'un programme Java doit être déclarée public, sinon l'interpréteur Java ne pourra pas exécuter la classe.

Modificateur d'accès protégé - protected

protected doit être analysé et expliqué à partir des deux points suivants :

  • La sous-classe et la classe de base sont dans le même paquetage :: Les variables, méthodes et constructeurs déclarés comme protected sont accessibles à toute autre classe du même paquetage ;

  • La sous-classe et la classe de base ne sont pas dans le même paquetage :: Alors, dans la sous-classe, une instance de sous-classe peut accéder aux méthodes protected héritées de la classe de base, mais ne peut pas accéder aux méthodes protected d'une instance de la classe de base.

protected peut modifier les membres de données, les constructeurs et les membres de méthode.Ne peut pas modifier les classes (sauf les classes internes)。

Les interfaces et leurs variables membres et méthodes ne peuvent pas être déclarées comme protected. Vous pouvez voir l'illustration ci-dessous :

Les sous-classes peuvent accéder aux méthodes et variables déclarées avec le modificateur protected, empêchant ainsi des classes non apparentées d'utiliser ces méthodes et variables.

La classe parente suivante utilise le modificateur d'accès protected, et la sous-classe redéfinit la méthode openSpeaker() de la classe parente.

class AudioPlayer { protected boolean openSpeaker(Speaker sp) { //Détails de l'implémentation } } class StreamingAudioPlayer extends AudioPlayer { protected boolean openSpeaker(Speaker sp) { //Détails de l'implémentation } }

Si la méthode openSpeaker() est déclarée comme private, alors aucune classe autre que AudioPlayer ne pourra accéder à la méthode.

Si openSpeaker() est déclarée comme public, alors toutes les classes pourront accéder à la méthode.

Si nous voulons que la méthode ne soit visible que pour les sous-classes de sa classe, alors déclarez la méthode comme protected.

protected est l'un des modificateurs d'accès aux membres de classe Java les plus difficiles à comprendre. Pour plus de détails, veuillez consulterExplication détaillée du mot-clé protected de Java。

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

Veuillez noter les règles suivantes pour l'héritage des méthodes :

  • Les méthodes déclarées comme public dans la classe parente doivent également être public dans la sous-classe.

  • Les méthodes déclarées comme protected dans la classe parente doivent être déclarées comme protected ou public dans la sous-classe, et ne peuvent pas être déclarées comme private.

  • Les méthodes déclarées comme private dans la classe parente ne peuvent pas être héritées par la sous-classe.

Modificateurs non liés à l'accès

Afin de mettre en œuvre d'autres fonctionnalités, Java fournit également de nombreux modificateurs non liés à l'accès.

modificateur static, utilisé pour modifier les méthodes de classe et les variables de classe.

modificateur final, utilisé pour modifier des classes, des méthodes et des variables. Les classes modifiées par final ne peuvent pas être héritées, les méthodes modifiées par final ne peuvent pas être redéfinies par les classes dérivées, et les variables modifiées par final sont des constantes et ne peuvent pas être modifiées.

modificateur abstract, utilisé pour créer des classes abstraites et des méthodes abstraites.

modificateurs synchronized et volatile, principalement utilisés dans la programmation de threads.

Modificateur static

  • 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, sa variable statique n'a qu'une seule copie. Les variables statiques sont aussi appelées variables de classe. Les variables locales ne peuvent pas être déclarées comme variables statiques.

  • Méthodes statiques :

    Le mot-clé static est utilisé pour déclarer des méthodes statiques qui sont indépendantes des objets. Les méthodes statiques ne peuvent pas utiliser les variables non statiques de la classe. Les méthodes statiques obtiennent des données à partir de la liste de paramètres, puis calculent les données.

L'accès aux variables et méthodes de classe peut se faire directement en utilisantclassname.variablenameetclassname.methodnamela méthode d'accès.

Comme le montre l'exemple ci-dessous, 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("En commençant par " + InstanceCounter.getCount() + " instances"); for (int i = 0; i < 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }

La sortie de l'exécution de l'exemple ci-dessus est la suivante :

Starting with 0 instances
Created 500 instances

Modificateur final

variables final :

final signifie « dernier » ou « final ». Une fois qu'une variable a reçu une valeur, elle ne peut pas être réaffectée. Les variables d'instance modifiées par final doivent explicitement spécifier une valeur initiale.

Le modificateur final est généralement utilisé avec le modificateur static pour créer des constantes de classe.

Exemple

public class Test{ final int value = 10; //Voici un exemple de déclaration de constantes public static final int BOXWIDTH = 6; static final String TITLE = "Manager"; public void changeValue(){ value = 12; //affichera une erreur } }

méthodes final

les méthodes final d'une classe parente peuvent être héritées par les sous-classes, mais ne peuvent pas être redéfinies par les sous-classes.

L'objectif principal de déclarer une méthode final est d'empêcher la modification du contenu de la méthode.

Comme indiqué ci-dessous, déclarez une méthode à l'aide du modificateur final.

public class Test{ public final void changeName(){ //Corps de la méthode } }

classe final

Une classe final ne peut pas être héritée, et aucune classe ne peut hériter des caractéristiques d'une classe final.

Exemple

public final class Test { //Corps de la classe }

Modificateur abstract

Classe abstraite :

Une classe abstraite ne peut pas être utilisée pour instancier des objets ; le seul but de déclarer une classe abstraite est d'étendre la classe à l'avenir.

Une classe ne peut pas être modifiée à la fois par abstract et final. Si une classe contient des méthodes abstraites, alors la classe doit être déclarée comme une classe abstraite, sinon une erreur de compilation se produira.

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

Exemple

abstract class Caravan{ private double price; private String model; private String year; public abstract void goFast(); //Méthode abstraite public abstract void changeColor(); }

Méthode abstraite

Une méthode abstraite est une méthode sans aucune implémentation ; l’implémentation spécifique est fournie par les sous-classes.

Les méthodes abstraites ne peuvent pas être déclarées comme final ou static.

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 également une classe abstraite.

Si une classe contient plusieurs méthodes abstraites, alors la classe doit être déclarée comme une classe abstraite. Une classe abstraite n'a pas besoin de contenir des méthodes abstraites.

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

Exemple

public abstract class SuperClass{ abstract void m(); //Méthode abstraite } class SubClass extends SuperClass{ //Implémentation des méthodes abstraites void m(){ ......... } }

synchronized Modificateur

Une méthode déclarée avec le mot-clé synchronized ne peut être accédée que par un seul thread à la fois. Le modificateur synchronized peut être appliqué aux quatre modificateurs d'accès.

Exemple

public synchronized void showDetails(){ ....... }

transient Modificateur

Lorsqu'un objet sérialisé contient des variables d'instance modifiées par transient, la machine virtuelle Java (JVM) ignore cette variable particulière.

Ce modificateur est inclus dans l'instruction définissant la variable et est utilisé pour prétraiter les types de données des classes et des variables.

Exemple

public transient int limit = 55; //Non persisté public int b; //Persisted

Modificateur volatile

Une variable membre modifiée par volatile force les threads à relire la valeur de cette variable membre depuis la mémoire partagée à chaque fois qu'elle est accédée. De plus, lorsque la variable membre change, les threads sont forcés 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 pour une variable membre donnée.

Une référence d'objet volatile peut être null.

Exemple

public class MyRunnable implements Runnable { private volatile boolean active; public void run() { active = true; while (active) //Première ligne { //code } } public void stop() { active = false; //Deuxième ligne } }

Normalement, dans un thread, la méthode run() est appelée (dans un thread démarré par Runnable), et dans un autre thread, la méthode stop() est appelée. SiPremière lignela valeur active dans le tampon est utilisée, alorsDeuxième ligneLorsque la valeur de active est false, la boucle ne s'arrêtera pas.

Mais dans le code ci-dessus, nous avons utilisé volatile pour modifier active, donc la boucle s'arrêtera.

Autres extensions