Vamos ser sinceros, o Java nunca foi exatamente amigável para iniciantes. Para quem está dando os primeiros passos na programação, até mesmo exibir um simples “Hello World” exigia lidar com uma quantidade considerável de código boilerplate.

O tradicional public static void main(String[] args) já introduz diversos conceitos de uma só vez, como métodos estáticos, arrays e a própria estrutura de execução da aplicação. Para quem ainda está tentando entender o que são variáveis, isso pode ser bastante intimidador.

Além disso, tarefas simples como entrada e saída de dados no console também não ajudavam. Enquanto a escrita com System.out.println é relativamente direta, a leitura de dados exige a criação de um objeto Scanner, adicionando mais complexidade logo no início do aprendizado.

Esse conjunto de barreiras acabava afastando muitos iniciantes do ecossistema Java.

Arquivos Fonte Compactos

Com as novidades do Java 25, não é mais necessário declarar explicitamente o método main como public static em cenários mais simples. Além disso, caso a aplicação não utilize argumentos de linha de comando, também não há necessidade de incluir o tradicional String[] args.

Na prática, isso reduz significativamente o código inicial, tornando a linguagem mais acessível para quem está começando.

// Estrutura Original do método main

public class MainOriginal {
    public static void main(String[] args) {
        System.out.println("Olá Mundo Java");
    }
}

// Estrutura Nova do main

public class Main {
    void main() {
        System.out.println("Olá Mundo Java");
    }
}

Com essa mudança, também passamos a poder utilizar variáveis de instância diretamente no método main. Antes, como o ponto de entrada da aplicação era um método estático, só era possível acessar diretamente atributos estáticos da classe.

Agora, com um main não estático, o código se torna mais natural, e permite trabalhar com estado de instância desde o início.

public class Main{

    private String linguagem = "Java";

    void main(){
        System.out.println("Olá Mundo " +this.linguagem);
    }
}

Outra simplificação importante é a possibilidade de escrever um arquivo Java executável sem a necessidade de declarar explicitamente uma classe.

Na prática, isso permite criar programas mais diretos, com menos código estrutural, focando apenas na lógica da aplicação, algo especialmente útil para iniciantes ou para exemplos rápidos.

// Arquivo Main.java

String linguagem = "Java";

String saudacao(){
    return "Olá Mundo "+this.linguagem;
}

void main(){
    System.out.println( this.saudacao() );
}

Note que, no exemplo acima, definimos um atributo chamado linguagem, criamos o método saudacao() que utiliza esse atributo e, por fim, chamamos esse método dentro do main. Tudo isso sem declarar explicitamente uma classe.

Esse recurso é especialmente útil para criar scripts simples ou até mesmo para fazer demonstrações rápidas, reduzindo a quantidade de código estrutural e permitindo focar diretamente na lógica.

💡 Além disso, é possível executar esse tipo de arquivo diretamente, sem a necessidade de compilar manualmente o código fonte para bytecode.

java Main.java

Saída esperada:

Olá Mundo Java

Mesmo com essa forma simplificada de execução, o código fonte ainda é compilado para bytecode. A diferença é que esse processo acontece em memória, sem a geração explícita de um arquivo .class no disco.

Na prática, isso torna a execução mais simples para o desenvolvedor, eliminando a necessidade de uma etapa manual de compilação.

Entrada e Saída Simplificadas (I/O)

Outro ponto importante é a introdução de uma classe utilitária para operações de entrada e saída, que reúne métodos mais simples e diretos para lidar com I/O no dia a dia.

Com essa abordagem, tarefas como leitura e escrita de dados se tornam mais intuitivas, reduzindo a complexidade inicial e eliminando a necessidade de utilizar classes mais verbosas logo no começo.

Veja os principais métodos:

  • IO.print(String): Escreve no console a String informada, sem adicionar quebra de linha.
  • IO.println(String): Escreve no console a String informada e adiciona uma quebra de linha ao final.
  • IO.readln(): Lê uma linha completa do console (até o usuário pressionar Enter) e retorna o valor como String.
  • IO.readln(String): Exibe uma mensagem no console e, em seguida, realiza a leitura de uma linha, retornando o valor informado como String.
void main(){
    IO.println( "Informe seus dados:" );

    String nome = IO.readln("Nome: ");
    int idade = Integer.parseInt( IO.readln("Idade: ") );
    double altura = Double.parseDouble( IO.readln("Altura: ") );
    
    IO.println( "Nome informado: " + nome );
    IO.println( "Idade informada: " + idade );
    IO.println( "Altura informada: " + altura );
}

Esses novos recursos tornam o Java muito mais acessível para iniciantes (e também para professores 😁), eliminando boa parte do boilerplate pelo qual a linguagem sempre foi criticada.

Além disso, essas simplificações não beneficiam apenas quem está aprendendo. Elas também abrem espaço para o uso do Java em cenários mais leves, como a criação de scripts e pequenos programas, algo que tradicionalmente não era o foco da linguagem.

Então era isso. T++