Programmation Java/Modificateur
Modificateurs d'accès modifier
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.
Pour plus de détails sur les restrictions d’accès, voir le chapitre « Encapsulation ».
abstract modifier
Le modificateur abstract indique qu'une classe ou méthode est abstraite.
final modifier
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 final modifier
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 finale modifier
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 finale modifier
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.
static modifier
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.
synchronized modifier
Le modificateur synchronized indique que la méthode ne peut être exécutée que par un seul 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).
transient modifier
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.
native modifier
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.
strictfp modifier
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.
volatile modifier
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.