Classe ne pouvant exister qu'une seule fois et récupérable depuis partout

Je ne suis pas expert en la matière, mais l'utilisation de membres statiques ne ferait-elle pas l'affaire ?

La classe Options n'étant plus destinée à être instanciée, il faudrait passer par une méthode statique init() pour initialiser les options plutôt que par un constructeur, méthode qu'il faudrait appeler en tout début d'exécution, une bonne fois pour toutes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public final class Options { // Classe finale, pour qu'elle ne puisse pas servir d'héritage
    private static int optionA; // Les arguments sont statiques, pour ne pas avoir à instancier

    private Options() {} //Constructeur privé, pour que la classe ne puisse pas être instanciée.

    public static void init() {
        // Parser le fichier, instancier les membres et les initialiser ici...
    }

    public static int getOptionA() {
        return optionA;
    }

    public static void setOptionA(int optionA) {
        // Mettre à jour le fichier externe avec la nouvelle valeur
        // Mettre à jour Options.optionA
    }

    //...
}

1
2
3
4
5
6

class Foo{
    //...
    public void bar() {
        System.out.println(Options.optionA); // Exemple d'utilisation
    }
}

1
2
3
4
5
6

class Main {
    public static void main(String[] args) {
        Options.init(); // Initialisation
        //...
    }
}

Gérer la mise à jour des options, ça peut se faire directement dans la classe Options, via d'autres méthodes statiques. Exemple : Options.setOptionA() qui va mettre à jour le fichier externe avec la nouvelle valeur ainsi que la valeur de Options.optionA.

Ce que tu décris, si je ne m'abuse, c'est un singleton. (si tu n'as pas besoin d'une instance de la classe, effectivement tu passes uniquement par des méthodes statiques : ne pas abuser des singletons). Après dans ton cas, s'il y a un fichier de config. à lire etc. Plutôt que d'appeler une méthode init (que tu vas oublier d'appeler les 3/4 du temps) tu peux passer par un singleton.

Y'a plusieurs façons de l'implémenter en Java, notamment (de mémoire, je n'utilise plus cette façon de faire) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Options {
  private Options instance;

  private Options() {
    // ici tu lis les fichiers de config etc.
  }

  public static Options instance() {
     if (instance == null) {
       instance = new Options();
     }
     return instance;
  }
}

Ou sinon avec des enums, ce qui est conseillé dans le livre EffectiveJava de Joshua Bloch http://stackoverflow.com/questions/26285520/implementing-singleton-as-enum-in-java

EDIT : le même exemple que ci-dessus :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public enum Options {
  INSTANCE;

  private String host;
  private Options() {
    host = "localhost"; /* tu lis ton fichier... */
  }

  public getHost() {
    return host;
  }

  /* ... */
}

J'utilise de moins en moins de singletons (parce que les projets que je fais s'y prêtent peu) mais quand j'en ai besoin généralement j'utilise cette implémentation. Je la trouve plus concise et plus élégante.