Criando um CLI de Código Morse com Java Moderno

Introdução

Nem todo código precisa começar com um projeto estruturado, build tool (maven/gradle) e dezenas de dependências.

Com as evoluções recentes do Java, especialmente nas versões mais novas como o Java 25, ficou muito mais simples escrever pequenos utilitários diretamente como scripts.

Neste artigo, vamos explorar isso na prática construindo um CLI que converte texto para código Morse.

E tem um detalhe interessante: o dia 27 de abril marca o nascimento de Samuel Morse (1791–1872), criador do código Morse, por isso essa data é lembrada como o Dia do Código Morse.

O Objetivo

Queremos algo direto ao ponto:

./morse "hello world"

E obter:

.... . .-.. .-.. --- / .-- --- .-. .-.. -..

O objetivo deste CLI é receber uma string via argumentos de linha de comando, consolidar essa entrada preservando os espaços e convertê-la para Código Morse Internacional, suportando letras, números, espaços e pontuação comum, enquanto caracteres não reconhecidos são representados por ? na saída.

Sem setup. Sem projeto. Apenas código.

O Código

Aqui está o programa completo:

#!/usr/bin/java --source 25

void main(String... args) {
    var input = String.join(" ", args).trim();
    if (input.isEmpty()) {
        IO.println("");
        return;
    }
    IO.println(toMorse(input));
}

static String toMorse(String text) {
    var sb = new StringBuilder();
    var first = true;
    for (char c : text.toUpperCase().toCharArray()) {
        String code = switch (c) {
            case 'A' -> ".-"; case 'B' -> "-..."; case 'C' -> "-.-."; case 'D' -> "-..";
            case 'E' -> "."; case 'F' -> "..-."; case 'G' -> "--."; case 'H' -> "....";
            case 'I' -> ".."; case 'J' -> ".---"; case 'K' -> "-.-"; case 'L' -> ".-..";
            case 'M' -> "--"; case 'N' -> "-."; case 'O' -> "---"; case 'P' -> ".--.";
            case 'Q' -> "--.-"; case 'R' -> ".-."; case 'S' -> "..."; case 'T' -> "-";
            case 'U' -> "..-"; case 'V' -> "...-"; case 'W' -> ".--"; case 'X' -> "-..-";
            case 'Y' -> "-.--"; case 'Z' -> "--..";
            case '0' -> "-----"; case '1' -> ".----"; case '2' -> "..---"; case '3' -> "...--";
            case '4' -> "....-"; case '5' -> "....."; case '6' -> "-...."; case '7' -> "--...";
            case '8' -> "---.."; case '9' -> "----.";
            case ' ' -> "https://dev.to/";
            case '.' -> ".-.-.-"; case ',' -> "--..--"; case '?' -> "..--.."; case '!' -> "-.-.--";
            case ':' -> "---..."; case ';' -> "-.-.-."; case '(' -> "-.--."; case ')' -> "-.--.-";
            case '"' -> ".-..-."; case ''' -> ".----."; case '@' -> ".--.-."; case '&' -> ".-...";
            default -> "?";
        };
        if (!first) sb.append(' ');
        sb.append(code);
        first = false;
    }
    return sb.toString();
}

Esse código utiliza o modo script com --source 25 no topo, o que permite escrever o programa como um único arquivo executável, eliminando a necessidade de compilação, estrutura de projeto e até mesmo o boilerplate tradicional de classes.

Além disso, o código tira proveito de recursos modernos da linguagem:

• var para reduzir ruído na declaração de variáveis.

• switch expression com ->, deixando o mapeamento direto e legível.

• String.join para lidar com argumentos de forma simples.

O resultado é um código enxuto.

Como executar

Para rodar o script, é necessário ter o Java 25 (ou uma versão mais recente) instalado.

Você pode executá-lo de duas formas:

Como script executável:

chmod +x morse
./morse Hello World

Ou via Java:

java --source 25 morse Hello World

O resultado será:

.... . .-.. .-.. --- / .-- --- .-. .-.. -..

Conclusão

Esse exemplo simples mostra como o Java evoluiu para reduzir significativamente o boilerplate, permitindo escrever código mais direto e focado no problema. Hoje, já é possível criar scripts em Java sem precisar de um processo explícito de compilação ou até mesmo conhecer shell scripting, tornando a linguagem uma opção viável para automações e pequenas ferramentas.