O método principal deve ser composto apenas por criações de objetos e chamadas de método?

Um amigo meu me disse que, a melhor prática é que o mainmétodo que contém classe deve ser nomeado Maine contém apenas mainmétodo. O mainmétodo também deve apenas analisar entradas, criar outros objetos e chamar outros métodos. A Mainclasse e o mainmétodo não devem fazer mais nada. Basicamente, o que ele está dizendo que o mainmétodo que contém a classe deve ser:

public class Main
{
    public static void main(String[] args)
    {
        //parse inputs
        //create other objects
        //call methods
    }
}

É a melhor prática?

O argumento de seu amigo é que um aplicativo deve ser apenas inicializado pelo método principal e nada mais. Por ter o método principal em sua própria classe, você simplesmente reforça esse fato, mantendo-o independente de qualquer lógica de aplicativo. O papel do método principal seria analisar quaisquer entradas e inicializar o aplicativo com essas e possivelmente outras entradas.

public static void main(String[] args){
    new Foo().start(args[0]);
}

A idéia é que você não precisa do método principal para inicializar Foo. Isso permite que você inicialize e inicie facilmente Fooem outro contexto, potencialmente com diferentes semânticas.

public Foo initSomewhereElse(String arg){
    Foo f = new Foo();
    f.start(arg);
    return f;
}

O método main () é um retrocesso feio para a programação procedural, fornecendo o ponto de entrada no aplicativo. São feitas tentativas em várias linguagens de programação para encapsulá-lo, mas sua própria natureza torna isso difícil (deve ser público e estático, mas NUNCA deve ser chamado de qualquer outra coisa no programa, o que é altamente contraditório). O WPF obteve êxito (ocultando main () de você nas entranhas do projeto de aplicativo WPF e fornecendo "ganchos" configuráveis ​​para processamento personalizado), assim como o Java (da mesma forma para aplicativos Android), mas o WinForms e a maioria dos outros tipos de os aplicativos ainda fazem você lidar com main ().

Portanto, a maioria dos especialistas diz que o LOC da função main () deve ser o mais baixo possível. Existe uma abordagem (que eu acho que é um pouco exagerada) na qual a função main () tem uma linha:

public class Program
{
   private Program(string[] args)
   {
      //parse args and perform basic program setup
   }

   //Reduce the ugliness to the absolute minimum
   public static void main(string[] args)
   {
      new Program(args).Run();  
   }

   private void Run()
   {
      //kick off the driving O-O code for the app; i.e. Application.Run()
   }    
}

Isso é um pouco demais, mas eu concordo com o princípio básico; main () deve o mínimo possível para colocar seu aplicativo orientado a objetos e orientado a eventos em um estado "pronto".

Em idiomas que suportam funções, mainé apenas uma função regular e, portanto, não há mais nada que você possa fazer além do que disse. E também existem linguagens idiotas que descartam funções em favor de que tudo seja um objeto, o que significa que toda vez que você deseja uma função, precisa envolvê-la em uma classe desnecessária .

Bem, chega de divagações. O ponto que estou tentando destacar é que Mainnão é realmente uma classe, mas uma função e, portanto, você não deve fazer nada além de analisar entradas, criar outros objetos e chamar outros métodos, porque é tudo o que uma função pode fazer.