Accueil
Accueil
Le
Club
Delphi
Kylix
C
C++
Java
J2EE
DotNET
& C#
Visual
Basic
Access
Pascal
Dev
Web
PHP
ASP
XML
UML
SQL
SGBD
Win
Linux
Autres



Que signifient les mots-clés public, private et protected ?
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.


Que signifie le mot-clé static ?
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); //affiche la valeur de PI System.out.println(Math.abs(-1)); //affiche la valeur absolue de -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"); //etc . } }
lien : Que signifie le mot-clé final ?

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).


Que signifient les mots-clés this et super ?
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 appelle ici le constructeur de la classe mère } /** On peut aussi accéder aux constructeurs de la classe elle-même*/ public MaClasse(String uneValeur){ this("une valeur par défaut"); //on appelle ici le constructeur définis un peu plus haut } /** En général l'appel à this est superflu lors d'appels à une méthode*/ public void uneMethode(){} public void doubleAppel(){ //les deux lignes suivantes sont équivalentes 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; //ici, la variable de classe prend la valeur de la variable //passée en paramètre de la méthode } /** On peut aussi faire appel aux méthodes de la super-classe*/ public void uneAutreMethode(){ //on peux faire quelque chose en plus avant super.uneAutreMethode(); //mais aussi après } }
Ces deux mots-clés sont très liés au concept d'héritage. Pour plus d'informations, voir Qu'est-ce que l'héritage ?

lien : Qu'est-ce que l'héritage ?

Que signifie le mot-clé strictfp ?
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.


Que signifie le mot-clé transient ?
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.

// la classe que nous allons sérialiser class Writeable implements java.io.Serializable { // entier transient public transient int var1 = 4; // entier normal 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 ?

Que signifie le mot-clé volatile ?
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.


Et le goto en Java ?
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) { // instructions if( condition ) { // quitte la boucle break; } if( condition ) { // retourne au début de la boucle continue; } }
Pour plus d'informations sur break et continue, regardez le lien ci dessous.

lien : Comment utiliser les mots-clés break et continue ?

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.
Vos questions techniques : forum d'entraide PHP - Publiez vos articles, tutoriels et cours
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Copyright 2000..2004 www.developpez.com