|
auteur :
Ioan Calapodescu | Ces trois mots clefs du langage java définissent la portée d'une variable, d'une méthode ou d'une classe. Il existe en fait quatre modificateurs d'accessibilité. Le quatrième est le modificateur vide (rien, pas de modificateur). Il ne faut pas confondre ce dernier avec public.
Voici les caractéristiques de ces modificateurs, du plus permissif au plus restrictif :
Mot-clé |
Portée |
Remarques |
public |
Les variables, méthodes ou classes publiques sont accessibles par tout objet. |
La classe principale d'un fichier .java doit obligatoirement être publique. |
"rien" |
Les variables, méthodes ou classes définies sans modificateur sont accessibles par toute classe appartenant au même package. |
Attention : les variables sans modificateur ne sont pas accessibles aux classes fille définies dans un autre package. |
protected |
Les variables, méthodes ou classes définies comme protégées ne sont accessibles que par les classes filles et classes du même package.. |
|
private |
Les variables, méthodes ou classes définies comme privées ne sont accessibles que par la classe dans laquelle elles sont définies. |
Il est fortement conseillé de déclarer comme privés tous les attributs d'une classe, et de créer des méthodes de type get/set pour y accéder. |
Naturellement, toute méthode, variable ou classe est accessible dans la classe ou elle est définie.
|
|
auteur :
Ioan Calapodescu | Le mot-clé static est utilisable pour des variables, méthodes ou blocs de code.
Devant une variable ou méthode :
Le mot clé static devant une variable (ou méthode) indique que celle-ci n'appartient pas à une instance particulière de la classe. Les variables ou méthodes statiques appartiennent à la classe elle-même. On peux ainsi les utiliser sans avoir une instance créée. De nombreuses classes ont des membres ou méthodes statiques. Par exemple la classe Math :
System.out.println(Math.PI);
System.out.println(Math.abs(-1));
Voici quelques remarques :
- On peut aussi manipuler une variable ou méthode statique à partir d'une instance de la classe.
- Pour faire des variables statiques des constantes, il faut combiner le mot-clé static avec le mot-clé final.
- Les méthodes statiques, étant indépendantes de toute instance, n'ont pas accès aux variables ou méthodes non statiques.
Devant un bloc de code :
Le mot-clé static devant un bloc de code indique que celui-ci ne sera exécuté qu'une fois. L'exécution se fait lors du chargement de la classe par le ClassLoader. On peut utiliser ces blocs, par exemple, pour initialiser des variables statiques complexes.
publioc class MaClasse{
public static Map uneVariableStatique = new HashMap();
static{
uneVariableStatique.put("une clef","une valeur");
uneVariableStatique.put("une autre clef","une autre valeur");
}
}
|
lien : Que signifie le mot-clé final ?
|
|
auteur :
Clément Cunin | Devant une méthode : On indique que cette méthode ne pourra plus être redéfinie dans une classe fille. Ce qui entraîne une certaine optimisation dans les appels à cette méthode.
Devant une classe : On ne peut pas créer de classe dérivée de celle-ci. Par exemple il est impossible de dériver une classe à partir de la classe String de la bibliothèque de base. La solution consisterait à "encapsuler" String dans une classe de notre conception.
Devant une variable membre : La variable doit être initialisée à la déclaration et ne pourra plus être modifiée (constante).
|
|
auteur :
Ioan Calapodescu | Les mots-clés this et super désignent respectivement des références sur l'instance courante et sur la classe mère. Voici un exemple qui devrais mettre en valeur cette définition plutôt succincte :
public MaClasse extends ClasseMere{
private String attribut;
/** On peut acceder aux constructeurs de la super-classe*/
public MaClasse(String uneValeur){
super(uneValeur);
}
/** On peut aussi accéder aux constructeurs de la classe elle-même*/
public MaClasse(String uneValeur){
this("une valeur par défaut");
}
/** En général l'appel à this est superflu lors d'appels à une méthode*/
public void uneMethode(){}
public void doubleAppel(){
this.uneMethode();
uneMethode();
}
/** L'appel à this peut être utile pour bien différencier
* les variables de classe des variables de méthodes
*/
public void uneMethode(String attribut){
this.attribut = attribut;
}
/** On peut aussi faire appel aux méthodes de la super-classe*/
public void uneAutreMethode(){
super.uneAutreMethode();
}
}
|
lien : Qu'est-ce que l'héritage ?
|
|
auteurs :
Romain Guy, Clément Cunin | Ce mot clé, qui est une abréviation de Strict floating point, s'applique en tant que modificateur d'accès. Ou plus simplement, on l'utilise de la même manière que les mot-clés public ou synchronized. Avec quelques restrictions : strictfp s'applique en tant que modificateurs de classes, d'interfaces ou de méthodes d'une classe et en aucun cas au constructeur ou aux méthodes d'une interface. L'entité affectée est alors dite "FP-strict".
Les effets : Comme son nom l'indique, strictfp agit sur les opérations en virgule flottante. C'est à dire sur les types primitifs double et float.
Java effectue les calculs en garantissant une priorité de la gauche vers la droite.
/** classe FP-strict */
public strictfp class FPDemo {
public static void main(String[] args) {
double d = 8e+307;
/** affiche 4 * d /2 donc 2 * d */
System.out.println(4 * d / 2);
/** affiche 2 * d */
System.out.println(2 * d);
}
}
Mathématiquement ces deux expressions sont identiques, mais interprété dans un langage, il en va autrement. Java impose un parenthésage : (4*d)/2, et dans notre cas (4*d) produit un dépassement de capacité, donc un résultat infini. En revanche, la deuxième expression produit bien un résultat correct.
Notons que le mot-clé oblige l'implémentation de la JVM à évaluer l'expression tel que prévu dans la spécification du langage. Ne pas faire usage de ce mot-clé ne garantit pas que la JVM réalisera ce calcul de la sorte. Une JVM peut en effet avoir le droit, si la méthode n'est pas FP-strict, d'utiliser des types intermédiaires différents pour éviter de provoquer un dépassement de capacité ou pour s'adapter à l'architecture de la machine. Dans ce cas les deux expressions pourraient, en fonction de la JVM, produire des résultats différents.
Conclusion : Le mot-clé strictfp permet de garantir les mêmes calculs quelle que soit la machine virtuelle sur laquelle l'opération est effectuée.
|
|
auteur :
Romain Guy | Le mot-clé transient est lié à la sérialisation des classes Java (voir : Qu'est-ce que la sérialisation ?). Il permet d'interdire la sérialisation de certaines variables d'une classe.
class Writeable implements java.io.Serializable {
public transient int var1 = 4;
public int var2 = 19;
}
Si nous sérialisons une instance de cette classe, la variable 'var1' ne sera pas sauvegardée, lors de la désérialisation elle prendra la valeur 0, malgré la présence de la valeur par défaut 4. L'attribution d'une valeur par défaut se fait lors de l'instanciation de l'objet ! Or, la méthode consistant à lire un objet depuis un fichier ne crée pas cette instance explicitement. Donc demo n'est jamais initialisé avec sa valeur par défaut. De plus, comme cet attribut est transient, il n'est pas écrit dans le fichier. Cela implique que demo ne reçoit aucune valeur et contient donc 0.
Ce mot-clé trouve des applications dès lors qu'une donnée sensible ne doit en aucun cas apparaître dans un fichier. Un mot de passe par exemple. Mais ce mot-clé peut également permettre de "remettre à zéro" certaines valeurs. Dans le cas d'un jeu, on pourra ainsi ne pas sauvegarder le temps de jeu depuis le début de la partie.
|
lien : Qu'est-ce que la sérialisation ?
|
|
auteur :
Ioan Calapodescu | Le mot-clé volatile est utilisé sur les variables qui peuvent être modifiées de manière asynchrone. C'est à dire que plusieurs threads peuvent y accéder simultanément. Ces accès peuvent être pour la lecture et/ou la modification du contenu.
En indiquant que la variable est volatile, on oblige la JVM à rafraîchir son contenu à chaque fois qu'elle est utilisée. On est ainsi certain que la valeur de la variable n'est pas une valeur mise en cache, mais bel et bien sa valeur exacte. Ainsi chaque thread à accès à la valeur la plus récente de la variable.
Remarque : ce mot-clé est relativement peu utilisé et toutes les JVM ne le prennent pas en compte.
|
|
auteur :
Clément Cunin | goto Bien que goto soit un mot réservé de Java, on ne le trouve pas dans le langage ; Java n'a pas de goto. Le mot-clé goto est aussi ancien que les langages de programmation. En effet, goto a été le premier moyen de contrôle des programmes dans les langages d'assemblage : « si la condition A est satisfaite, alors sauter ici, sinon sauter là ». Lorsqu'on lit le code assembleur finalement généré par n'importe quel compilateur, on voit qu'il comporte beaucoup de sauts.
break & continue Cependant, il existe quelque chose qui ressemble à un saut, lié aux mots-clés break et continue. Ce n'est pas vraiment un saut, mais plutôt une manière de sortir d'une instruction d'itération.
while(true) {
if( condition ) {
break;
}
if( condition ) {
continue;
}
}
Pour plus d'informations sur break et continue, regardez le lien ci dessous.
|
lien : Comment utiliser les mots-clés break et continue ?
|
|
auteur :
bulbo | Comme nous l'avons vu, il n'y a pas de goto en Java, mais il est possible d'associer un label a une instruction de boucle. Ce label, utilisé en conjonction avec l'instruction break, permet de savoir à quel niveau le break sera effectif.
Un label est une chaîne suivie de ":" et qui se place devant l'instruction de boucle.
Voici un exemple :
Boucle1: while(true)
{
System.out.println("Boucle 1");
Boucle2: for(int ind=0; ind < 10; ind++)
{
System.out.println("Boucle 2");
Boucle3: while(true)
{
System.out.println("Boucle 3");
break Boucle2;
}
}
break;
}
A votre avis, qu'affiche l'exécution de ce morceau de code ?
Remarque : le label peut aussi être utilisé en conjonction avec le mot clé continue. De la même manière, le label indique à quel niveau de boucle le continue s'applique.
|
Consultez les autres F.A.Q's
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :
- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".
- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peux en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
|
|
|