Modificateurs Java

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

• Modificateurs d'accès

• Modificateurs non d'accès

Les modificateurs définissent la classe, la méthode ou la variable, généralement placés au début de la phrase. Nous expliquons cela à l'aide de 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 la méthode
}

Modificateurs de contrôle d'accès

Dans Java, vous pouvez utiliser les modificateurs d'accès pour protéger l'accès aux classes, variables, méthodes et constructeurs. Java prend en charge 4 différents niveaux d'accès.

• default (c'est-à-dire par défaut, sans rien écrire) : Visible à l'intérieur du même paquet, sans utiliser de modificateurs. Utilisation : classes, interfaces, variables, méthodes.

• private : Visible à l'intérieur de la même classe. Utilisation : variables, méthodes. Remarque : Ne peut pas modifier la classe (classe externe)

• public : Visible pour toutes les classes. Utilisation : classes, interfaces, variables, méthodes

• protected : Visible pour les classes du même paquet et toutes les sous-classes. Utilisation : variables, méthodes. Remarque : Ne peut pas modifier la classe (classe externe)。

Nous pouvons expliquer les droits d'accès à l'aide du tableau suivant :

Contrôle d'accès

Modificateur d'accès par défaut-Ne pas utiliser de mots-clés

Les variables et méthodes déclarées avec le modificateur d'accès par défaut sont visibles pour les classes du même paquet. Les variables dans les interfaces sont implicitement déclarées comme public static final, et les méthodes dans les interfaces ont par défaut un accès public.

Comme indiqué dans l'exemple suivant, la déclaration de variables et de méthodes peut ne pas utiliser de modificateurs.

package　defaultPackage;
class　Logger　{
　　　　void　message(){
　　　　　　　　System.out.println("This　is　a　message");
　　　　}
}

Dans ce cas, la classe Logger a un modificateur d'accès par défaut. Et cette classe est visible pour toutes les classes du paquet defaultPackage. Mais si nous essayons d'utiliser la classe Logger dans une autre classe en dehors de defaultPackage, nous obtenons une erreur de compilation.

Le modificateur d'accès privé-private

Le modificateur d'accès privé est le niveau d'accès le plus strict, donc il est déclaré private les méthodes, variables et constructeurs ne peuvent être accédés que par la classe appartenant et les classes et interfaces ne peuvent pas être déclarées private。

Les variables déclarées comme privées ne peuvent être accédées par les classes externes que via les méthodes getter publiques de la classe.

L'utilisation du modificateur d'accès privé est principalement utilisée pour cacher les détails de l'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 format de la classe Logger est une variable privée, donc d'autres classes ne peuvent pas obtenir et définir directement la valeur de cette variable. Pour permettre à d'autres classes de manipuler cette variable, deux méthodes public ont été définies : getFormat() (retourne 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 en tant que public peuvent être accédés par toute autre classe.

Si plusieurs classes public mutuellement accessibles sont réparties dans des paquets différents, il est nécessaire d'importer le paquet contenant les classes public correspondantes. En raison de l'héritabilité des classes, toutes les méthodes et variables publiques des classes peuvent être héritées par les 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 en tant que publique, sinon, l'interpréteur Java ne pourra pas exécuter cette classe.

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

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

• Le sous-class et le parent class sont dans le même paquet：Les variables, méthodes et constructeurs déclarés en tant que protected peuvent être accédés par toutes les autres classes du même paquet;

• Le sous-class et le parent class ne sont pas dans le même paquet：dans le sous-class, l'exemple du sous-class peut accéder aux méthodes protected héritées du parent class, mais ne peut pas accéder aux méthodes protected de l'exemple du parent class.

protected peut être utilisé pour modifieur de données membres, méthodes constructeurs, méthodes membres,Il ne peut pas être utilisé pour modifieur de classe (à l'exception des classes internes)。

Les membres des interfaces et des variables de membres des interfaces ne peuvent pas être déclarés en tant que protected.

Le sous-class peut accéder aux méthodes et variables déclarées avec le modificateur protected, de sorte qu'il puisse protéger que les classes non pertinentes utilisent ces méthodes et variables.

Le parent class utilise l'accessibility modificateur protected, et le sous-class réécrit la méthode openSpeaker() du parent class.

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 nous déclarons la méthode openSpeaker() comme private, seules les classes AudioPlayer ne pourront pas accéder à cette méthode.

Si nous déclarons openSpeaker() comme public, toutes les classes pourront accéder à cette méthode.

Si nous voulons que la méthode soit visible uniquement pour les sous-classes de la classe où elle est déclarée, nous devons déclarer cette méthode comme protected.

Protected est le mot-clé d'accès le plus difficile à comprendre parmi les membres d'accès de la classe 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 public dans la classe parente doivent également être déclarées public dans la classe fille.

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

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

Modificateurs non d'accès

Pour réaliser d'autres fonctions, Java propose également de nombreux modificateurs non d'accès.

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

Le modificateur final, utilisé pour modifiez les classes, les méthodes et les variables. Les classes marquées final ne peuvent pas être héritées, les méthodes marquées final ne peuvent pas être redéfinies par une classe héritant, et les variables marquées final sont des constantes, non modifiables.

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

Les modificateurs synchronized et volatile, principalement utilisés pour la programmation des threads.

Modificateur static

• Variables statiques :

  Le mot-clé static est utilisé pour déclarer des variables statiques indépendantes de l'objet, que ce soit pour un nombre quelconque d'instances de la classe, ses variables statiques ne sont qu'une seule copie. Les variables statiques sont également 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 indépendantes de l'objet. Les méthodes statiques ne peuvent pas utiliser des variables non statiques de la classe. Les méthodes statiques obtiennent des données à partir de la liste des paramètres, puis calculent ces données.

L'accès aux variables et aux méthodes de la classe peut être effectué directement en utilisant classname.variablename et classname.methodname d'une manière.

Comme illustré dans l'exemple suivant, le modificateur static est utilisé pour créer des méthodes 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("À partir de ",　+
　　　　　　InstanceCounter.getCount()　+　" instances commencent");
　　　　　　for (int i = 0; i <　500;　++i){
　　　　　　　　　new InstanceCounter();
　　　　　　　　　　}
　　　　　　System.out.println("Created ",　+
　　　　　　InstanceCounter.getCount()　+　"instances");
　　　}
}

Le résultat de l'exécution de l'exemple ci-dessus est le suivant :

À partir de 0 instance
Création　500 instances

modificateur final

Variable finale :

Final signifie "dernier, définitif", une variable une fois assignée ne peut pas être réassignée. Les variables marquées final doivent impérativement avoir une valeur initiale spécifiée.

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

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

Méthode finale

Les méthodes finales dans la classe parente peuvent être héritées par la classe fille, mais ne peuvent pas être redéfinies par la classe fille.

L'objectif principal de la déclaration de méthode finale est d'empêcher la modification du contenu de la méthode.

Comme indiqué ci-dessus, la méthode est déclarée en utilisant le modificateur final.

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

Classe finale

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

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

modificateur abstract

Classe abstraite :

Les classes abstraites ne peuvent pas être utilisées pour instancier des objets, l'unique objectif de déclarer une classe abstraite est de pouvoir l'étendre ultérieurement.

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

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

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

Les méthodes abstraites sont des méthodes sans implémentation, et leur implémentation spécifique est fournie par la classe dérivée.

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

Toute classe dérivée d'une classe abstraite doit implémenter toutes les méthodes abstraites de la classe parente, à moins que cette classe dérivée ne soit elle-même abstraite.

Si une classe contient plusieurs méthodes abstraites, cette classe doit être déclarée comme classe abstraite. Une classe abstraite peut ne pas contenir de méthode abstraite.

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

public abstract class SuperClass{
　　　　abstract void m();　//méthode abstraite
}
　
class SubClass extends SuperClass{
　　　　　//implémenter la méthode abstraite
　　　　　　void m(){
　　　　　　　　　　.........
　　　　　　}
}

modificateur synchronized

La méthode déclarée par la clé synchronized peut être accédée par un seul thread à la fois. Le modificateur synchronized peut être appliqué aux quatre modificateurs d'accès.

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

modificateur transient

Lorsque l'objet sérialisé contient une variable marquée par transient, le Java Virtual Machine (JVM) saute cette variable spécifique.

Ce modificateur est inclus dans l'instruction de définition de la variable et est utilisé pour prétraiter le type de données de la classe et de la variable.

public transient int limit =;　55;　　　//　ne sera pas persisté
public int b;　//　persistence

modificateur volatile

Les variables membres marquées par volatile sont obligatoirement rechargées à partir de la mémoire partagée chaque fois qu'elles sont accédées par un thread. De plus, lorsque la valeur d'une variable membre change, le thread est obligé de réécrire cette valeur dans la mémoire partagée. De cette manière, à tout moment, deux threads différents voient toujours la même valeur pour une variable membre.

A volatile object reference may be null.

public class MyRunnable implements Runnable
{
　　　　private volatile boolean active;
　　　　public void run()
　　　　{
　　　　　　　　active = true;
　　　　　　　　while (active)　//　First line
　　　　　　　　{
　　　　　　　　　　　　//　Code
　　　　　　　　}
　　　　}
　　　　public void stop()
　　　　{
　　　　　　　　active = false;　//　Second line
　　　　}
}

In most cases, a thread calls the run() method (in a thread started by Runnable), and another thread calls the stop() method. If First line If the active value of the buffer is used in Second line The loop will not stop when the active value is false.

However, in the above code, we used the volatile modifier for active, so the loop will stop.