Java Méthode principale, bon style de codage

Question

J'ai eu une assez longue discussion avec un de mes amis sur la bonne et bonne utilisation de la méthode principale en Java. En fait, nous avons une classe comme ceci:

public class AnImporter implements Runnable { 
    // some methods, attributes, etc. 
} 

Mais où mettre la principale méthode? Je l'ai concider une bonne pratique de « garder le code où il appartient », transformant ainsi le code ci-dessus dans

public class AnImporter implements Runnable { 
    public static void main(String [] args){ 
    // Startup code for Importer App here 
    } 
    // some methods, attributes, etc. 
} 

Alors que mon copain soutient que « le code de démarrage n'a rien à voir avec l'application elle-même », il devrait donc être placé dans une autre classe, comme ceci:

public class AnImporter implements Runnable { 
    // some methods, attributes, etc. 
} 

public class AnApplication { 
    // Nothing here 
    public static void main(String [] args){ 
    AnImporter a = new AnImporter(); 
    // Startup code here 
    } 
    // Nothing here 
} 

Malgré le fait que nous avons discuté de la question pendant un certain temps nous avons tous deux fini sans conclusion sur quelle manière est la meilleure approche en Java. Quelle est votre opinion sur ce sujet? Où et surtout, pourquoi placez-vous votre méthode principale où vous l'avez placé?

Answer 1

Je suis d'accord avec votre ami. Vous construisez un service potentiellement réutilisable dans AnImporter qui pourrait potentiellement être utilisé dans plusieurs programmes avec plusieurs main. Donc, faire un spécial principal et l'intégrer dans AnImporter n'a pas beaucoup de sens.

Answer 2

Je ne polluerais pas une classe Runnable avec une méthode principale. La même chose vaut pour n'importe quelle classe qui fait n'importe quoi dans votre application. En général, je vais avoir une classe comme ceci:

public class App { 
    public static void main(String args[]) { 
    Thread t = new Thread(new Blah()); 
    t.start(); 
     synchronized (t) { 
     t.wait(); 
     } 
    } 
} 

public class Blah implements Runnable { 
    public void run() { 
    // do normal stuff 
    } 
} 

au lieu de:

public class Blah implements Runnable { 
    public void run() { 
    // do normal stuff 
    } 

    public static void main(String args[]) { 
    Thread t = new Thread(new Blah()); 
    t.start(); 
    synchronized (t) { 
     t.wait(); 
    } 
    } 
} 

On se sent plus propre.

Answer 3

J'irais probablement avec votre ami comme je préférerais sortir de la classe avec la méthode principale aussi rapidement que possible. Cela facilite les tests quand vous voulez tester atomiquement (juste la classe exécutable) ou vous voulez vous moquer des choses. Le plus tôt vous sortez de la méthode principale, plus vous avez d'options. Si vous avez une classe avec la méthode principale et d'autres choses, cela pourrait devenir désordonné rapidement. (même si cela ne semble pas être le cas avec un exemple simple comme celui que vous décrivez)

Mais je dirais que la lisibilité et la testabilité sont deux bonnes raisons de sortir de la méthode principale (et de sa classe englobante) dès que possible. . Mais hey..that est juste moi;)

Answer 4

Je sépare toujours le principal du reste du code, pour plusieurs raisons:

1) principale est, en quelque sorte, un hack pour que votre démarrage du programme à partir de la ligne de commande. Toute classe qui le contient devrait avoir une seule responsabilité: laisser le programme démarrer à partir de la ligne de commande. En le mettant avec votre runnable primaire, vous polluez le runnable.

2) Vous pourriez finir par avoir plusieurs réseau (par exemple, avec certains paramètres par défaut, avec des modes spéciaux, etc.)

3) Vous pourriez finir par exécuter le programme à partir d'un environnement différent (par exemple, un Eclipse plugin ou module OGSI, applet, outil web, etc.). Dans ce cas, vous voudriez restreindre l'accès à votre main. Le mettre avec la fonctionnalité empêche cela. 4) Il est parfois plus facile de laisser votre main dans le paquetage par défaut pour accélérer l'exécution (par exemple, java myblabla par1 par2 par3), mais vous ne voulez certainement pas le reste du code dans le paquet par défaut .

Answer 5

L'interface vers main (une liste de chaînes) est à peu près inutile, à l'exception du shell du système d'exploitation.

Votre principal devrait avoir aussi peu de code que possible humainement dedans.

En effet, votre public class ThisIsMyApp {...} ne devrait être rien de plus que l'interface OS du vrai travail, qui est ailleurs.

Answer 6

Je voudrais séparer la méthode principale du code.

Bien que j'ai aussi un type de projet différent. Il ne comprend pas un vrai programme de travail pour une solution. Ici, j'ai besoin d'exécuter différentes solutions pour différents problèmes en utilisant (et en développant) la même bibliothèque. Différents problèmes ne sont pas parallèles. J'ai besoin d'exécuter un seul problème de mon IDE. J'ai trouvé pratique d'utiliser le même projet avec un grand nombre de classes avec les méthodes PSVM.

Ce projet contient des solutions de concours de programmation pour plus de 400 problèmes différents. Avez-vous une meilleure organisation pour cela?