Modélisation : Un "main" générique pour mon projet

Bonjour à tous,

Je travaille sur un assez gros projet (à mon échelle) et je bloque sur un problème de modélisation, j'ai besoin de vos conseils avisés !

J'ai un ensemble de classes que j'utilise pour générer des exécutables (.jar) indépendants, ils sont différents mais possèdent la même structure.
Je me retrouve donc à tester les paramètres à chaque fois, appeler toujours la même méthode à la fin, etc ...

En bon programmeur je me suis dis qu'il devait exister un moyen d'automatiser cela. Dans un premier temps j'ai essayé de créer un classe abstraite générique qui possède un main du type :
Code:

1 2 3 4 5 6 7 public static void main(String[] args) { check(args); methodeA(); methodeB(); methodeC(); }
Avec les 3 méthodes abstraites à écrire pour chaque exécutable. Mais évidement le main étant static ca ne rime pas a grand chose.

Donc au final je ne sais pas trop où chercher, ni même si ce que j'essaie de faire est possible ou utile.

Salut,

Comme on ne peut redéfinir une méthode statique, tu ne peux évidement pas procéder comme ça. Mais on peut tout simplement faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public abstract AbstractLauncher {
 
      public AbstractLauncher() {
      }
 
      public void launch(String[] args) {
            check(args);
            run(); // je sépare cette partie pour montrer qu'on peut avoir des méthodes intermédiaires redéfinissables au besoin dans les classes concrètes
      }
 
      protected void run() {
             // si l'enchainement suivant est propre à l'implémentation concrète, rédéfinir la méthode dans la classe concrète pour y mettre l'enchainement, au lieu de le mettre ici (et faire éventuellement run() abstract)
            methodeA();
            methodeB();
            methodeC();
      }
 
      protected abstract void check(String[] args); // cette méthode peut être implémentée ici au besoin (ou dans une abstraction intermédiaire s'il y a différentes façons standard d'interpréter les arguments)
      protected abstract void methodeA();
      protected abstract void methodeB();
      protected abstract void methodeC();
 
}

et

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void class MonProgram1 extends AbstractLauncher {
 
       public void static main(String[] args) {
               new MonProgram1().launch(args);
       }
 
      protected void check(String[] args) {
           /* ... */
      }
      protected void methodeA() {
           /* ... */
      }
      protected void methodeB() {
           /* ... */
      }
      protected void methodeC() {
           /* ... */
      }
 
}

On est obligé de dupliquer la méthode main() en instanciant la bonne classe à chaque fois, mais c'est peu coûteux. Si vraiment tu veux avoir à récrire le minimum, tu peux procéder par introspection (reflection), en ajoutant cette méthode statique dans l'abstraction :

Code:

1
2
3
4
5
6
7
8
9
10
11
public abstract AbstractLauncher {
 
    /* ... */
 
    protected static <T extends AbstractLauncher> T createAndLaunch(Class<T> launcherClass, String[] args) {
             T launcher = (T)launcherClass.newInstance();
             launcher.launch(args);
             return launcher;
    }
 
}

Que tu peux appeler comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
public void class MonProgram1 extends AbstractLauncher {
 
       public void static main(String[] args) {
               createAndLaunch(MonProgram1.class, args);
               // ou MonProgram1 monProgram1 = createAndLaunch(MonProgram1.class, args); si tu veux pouvoir enchainer d'autres appels sur l'instance par la suite
       }
 
       /* ... */
 
}

On peut même passer des paramètres au constructeur au besoin, par l'introspection. On peut même passer le nom de la classe en argument d'ailleurs (voir Class.forName(String)

Parfait, merci beaucoup pour cette réponse.

J'hésite encore entre ces 2 méthodes, je vais essayer et voir ce que ca donne.