Programmation Java/Modificateur

Modificateurs d'accèsModifier

En Java, la déclaration d'une classe, d'une méthode ou d'un membre peut être précédée par un modificateur d'accès.

Un modificateur indique si les autres classes de l'application pourront accéder ou non à la classe/méthode/membre (qualifié par la suite d'« item »).

Ces modificateurs sont au nombre de quatre :

  • public : toutes les classes peuvent accéder à l'item
  • protected : seules les classes dérivées et les classes du même package peuvent accéder à l'item
  • private : l'item est seulement accessible depuis l'intérieur de la classe où il est défini.
  • (par défaut) : sans modificateur d'accès, seules les classes du même package peuvent accéder à l'item.

L'utilisation des modificateurs permet au programmeur de contrôler la visibilité des différents items et permet d'empêcher que des actions illégales soient effectuées sur les items.

abstractModifier

Le modificateur abstract indique qu'une classe ou méthode est abstraite.

finalModifier

Le modificateur final indique une non modification de l'entité déclarée. Il s'applique aux attributs d'une classe, aux méthodes et aux classes.

Attribut finalModifier

Ajouté devant un attribut, il le rend immuable, dès lors qu'il est initialisé. Il n'est pas obligatoire de l'initialiser dès la déclaration, contrairement à d'autres langages. Cependant l'initialisation doit être faite par le constructeur ou un bloc de code d'initialisation, car leur code est appelé une seule fois. L'initialisation ne peut être assurée par une méthode car une méthode peut être appelée n'importe quand, et un nombre de fois indéterminé.

Pour les types primitifs, final fige la valeur, pour les objets, final fige la référence, et non la valeur de la référence (i.e. seule l'instanciation est figée).

Devant une variable locale (dans une méthode, donc), il a le même comportement que pour un attribut.

Méthode finaleModifier

Devant une méthode, il indique que cette méthode ne peut pas être modifiée dans une classe dérivée. Les méthodes static et private sont implicitement final.

Classe finaleModifier

Devant une classe, il indique que cette classe ne peut pas avoir de sous-classes. Les méthodes de cette classe sont donc également finales.

staticModifier

Le modificateur static indique, pour une méthode, qu'elle peut être appelée sans instancier sa classe (syntaxe : Classe.methode()).

Pour un attribut, qu'il s'agit d'un attribut de classe, et que sa valeur est donc partagée entre les différentes instances de sa classe.

De plus, il est possible de déclarer dans une classe un bloc d'initialisation statique, qui est un bloc d'instruction précédé du modificateur static.

synchronizedModifier

Le modificateur synchronized indique que la méthode ne peut être exécutée que par un thread à la fois. Le verrou ne s'active que pour l'objet sur lequel la méthode a été appelée (une même méthode synchronized peut être exécutée en même temps par deux threads différents sur deux objets différents).

transientModifier

Le modificateur transient indique que lors de la sérialisation de l'objet, cet attribut n'est pas sérialisé et donc il est ignoré. Cela signifie que lorsque l'on désérialise l'objet, l'attribut portant le modificateur transient n'est pas défini dans l'objet désérialisé. Il s'agit en général d'attributs qui peuvent être recalculés à partir des autres attributs de l'objet.

nativeModifier

Ce modificateur permet d'indiquer que cet item est défini dans une bibliothèque externe écrite dans un autre langage de programmation, utilisant l'API JNI.

strictfpModifier

Pour une méthode, une classe ou une interface, le modificateur strictfp (abréviation de strict floating point) force la JVM à évaluer les opérations à virgules flottantes (sur les double et float) conformément à la spécification Java, c'est-à-dire de la gauche vers la droite. Cela permet d'avoir un comportement identique d'une JVM à une autre et d'éviter certains dépassements de valeur limite pour les résultats intermédiaires.

volatileModifier

Pour une variable, le modificateur volatile force la JVM, avant et après chaque utilisation de la variable, à la rafraîchir à partir de la mémoire principale au lieu d'utiliser un cache local. Cela permet de synchroniser la valeur de la variable entre plusieurs threads.