Desvendando o método main do Java

Fala galera blz 😀

Hoje vamos falar sobre um método que sempre usamos e é praticamente o primeiro método que executamos quando estamos aprendendo a linguagem Java. Sim, estou falando do método main, aquele onde executamos o famoso “Hello World” – “Olá Mundo” quando entramos nesse mundo da programação.

Porque falar sobre ele? Porque eu me “toquei” que nunca tinha visto artigo sobre o main e achei isso meio triste rsrsrsr.

Ele tem alguns pontos interessantes e curiosos você sabia?

O método main é o ponto de entrada de qualquer programa Java e desde a primeira versão, ele tinha a seguinte assinatura:

public static void main(String[] args) {}

public static void main(String[] args) {}

Mas, você sabia que temos outras formas de usar o método main?

A partir do Java 8, podemos usar a interface funcional Consumer para nos dar mais “poder” com o método:

public static void main(String[] args, Consumer<String[]> consumer) {}

public static void main(String[] args, Consumer<String[]> consumer) {}

Com essa alteração, podemos criar um Consumer que processe um ou mais argumentos passados para o programa.

Suponha que você tem um programa Java que faz alguma manipulação qualquer em um array de strings. Então você deseja permitir que o usuário forneça o array de entrada a partir da linha de comando. Você pode usar o Consumer<String[]> para aceitar esse array de entrada, como mostrado no exemplo abaixo:

public class MeuPrograma {
    public static void main(String[] args, Consumer<String[]> consumer) {
        // Chama a função fornecida pelo usuário com o array de argumentos da linha de comando
        consumer.accept(args);
      
       // Faz alguma manipulação no array de entrada
    }
}

public class MeuPrograma {
    public static void main(String[] args, Consumer<String[]> consumer) {
        // Chama a função fornecida pelo usuário com o array de argumentos da linha de comando
        consumer.accept(args);
      
       // Faz alguma manipulação no array de entrada
    }
}

Em seguida, o usuário pode fornecer uma função para manipular o array de entrada, como mostrado abaixo:

public class Teste {
    public static void main(String[] args) {
        MeuPrograma.main(args, (input) -> {
            // Imprime o array de entrada (input) 
            System.out.println("Array de entrada: " + Arrays.toString(input));
        });
    }
}

public class Teste {
    public static void main(String[] args) {
        MeuPrograma.main(args, (input) -> {
            // Imprime o array de entrada (input) 
            System.out.println("Array de entrada: " + Arrays.toString(input));
        });
    }
}

O método main do programa MeuPrograma é chamado a partir do método main do programa Teste, e é passado um lambda como o segundo parâmetro.

        //lambda que imprime o array
        (input) -> {
            // Imprime o array de entrada (input) 
            System.out.println("Array de entrada: " + Arrays.toString(input));
        }

        //lambda que imprime o array
        (input) -> {
            // Imprime o array de entrada (input) 
            System.out.println("Array de entrada: " + Arrays.toString(input));
        }

O lambda simplesmente imprime o array de entrada fornecido pelo usuário. Quando o método MeuPrograma.main é chamado, ele chama a função fornecida pelo usuário com o array de argumentos da linha de comando e, em seguida, faz alguma manipulação no array de entrada.

/> java Teste argumento1 argumento2

Array de entrada: [argumento1, argumento2]

/> java Teste argumento1 argumento2

Array de entrada: [argumento1, argumento2]

Bacana né? Sabia dessa?

A título de curiosidade, podemos também a partir do Java 9, “omitir” o método main em determinadas situações, se o programa não tiver uma carga de inicialização específica . Nesse caso, podemos usar a opção -m do comando java para especificar o módulo que deve ser executado.

É necessário para isso, que o programa seja organizado em um módulo e que esse módulo especifique a classe que deve ser executada, por meio de um arquivo de configuração module-info.java, dessa forma o metodo main será inferido a partir do arquivo module-info.java.

Essa abordagem pode ser útil em projetos grandes que utilizam módulos para organizar o código e reduzir as dependências entre as classes. Com essa opção, podemos especificar qual classe deve ser executada de forma mais clara e legível.

Porém, não quero entrar nesse ponto, pois quero mostrar a mudança na assinatura do método, então voltemos ao main 😀

Olha o tanto de coisa que envolve um simples método main, não é ?

//primeira variante, versão tradicional e mais usada
public static void main(String[] args) {}

//segunda variante, a partir do Java 8
public static void main(String[] args, Consumer<String[]> consumer) {}

//primeira variante, versão tradicional e mais usada
public static void main(String[] args) {}

//segunda variante, a partir do Java 8
public static void main(String[] args, Consumer<String[]> consumer) {}

E ai gostou de saber mais sobre o método main? Sabia dessas variantes? Já usou alguma?

Eu particularmente uso o que normalmente a IDE me entrega/gera, então estou na primeira opção rsrsr,. Enfim, independente do qual você utiliza e a forma que utiliza, o importante é entender o que está fazendo.

Até a próxima 😉