Problèmes avec les variables final
Bonjour à tous...
Je développe est java depuis bientôt deux ans, et récemment, j'ai été confronté à un petit problème du style "effet de bord" qui énerve assez.
J'ai identifié le problème qui vient apparamment du compilo qui ferait des optimisations parfois inconvenantes... Pour mieux comprendre je vous expose le problème par deux petites sources et je vous détaille le tout.
Il faut créer un premier paquetage que l'on appelera "librairie" et qui contient une classe Lib décrite comme suit:
Code:
1
2
3
4
5
6
7
8
9
10
| package librairie;
public class Lib{
public final static String CONSTANTE = "Ma constante";
public static void methode(String arg) {
System.out.println("librairie.Lib.methode: arg = "+arg);
System.out.println("librairie.Lib.methode: CONSTANTE = "+CONSTANTE);
}
} |
Ensuite vous créez un second paquetage appelé "application" qui contient la classe Application décrite ci après:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
| package application;
import librairie.Lib;
public class Application {
public static void main(String args[]) {
System.out.println("application.Application: Lib.CONSTANTE = "+Lib.CONSTANTE);
System.out.println("application.Application: Appel de la méthode de la librairie.\n");
Lib.methode(Lib.CONSTANTE);
System.out.println("\napplication.Application: Fin");
}
} |
Vous compilez le tout et tout marche comme prévu... :D
Maintenant, imaginez que vous voulez modifier la constante CONSTANTE dans la librairie: vous modifier le code de Lib.java et vous affectez "Ma nouvelle constante" à la variable constante... Cependant, vous ne recompilez que le paquetage librairie parce que vous pensez que la modification va être impactée sur l'application...
Ben non!!! :(
Relancez application.Application après n'avoir recompilé que la librairie et une chose bien étrange vous surprendra... 8O
Apparemment, le compilo transfère toutes les constantes dans les classes qui les utilisent pour optimiser le code. Actuellement, les moyens de s'en sortir sont de ne pas déclarer ces constantes en véritables constantes (supprimer final :oops: ), ou de faire un accès aux valeurs par des méthodes: ce qui n'est pas très optimal :? !!! Un autre moyen serait de gérer les sources java par un makefile comme pour le C et le C++: mais on perd en souplesse :x !!!
:?: :?: :?:
Alors la question que je pose c'est la suivante: existe-t-il une option de compilation ou une classe de mémorisation qui permette d'obtenir le résultat voulu sans trop dégrader les performances du code et sans ajouter trop de contrainte?
:?: :?: :?:
:arrow: Ceci est quand même assez remarquable. Imaginez que vous fournissez une librairie d'objets java qui contiennent des constantes publiques. Votre client compile une première fois son application avec vos classes et tout marche très bien. Quelques temps après vous livrez une nouvelle version de votre librairie. Votre client l'installe, mais ne recompile pas son application parce que vous lui avez indiqué que les modifications ne nécessitent pas de recompilation... Et là, pof, plus rien ne marche!!!
Merci à tous ceux et à toutes celles qui pourront m'éclairer sur le sujet!!!
:wink:
A bientôt
