Só consigo programar seguindo tutorial: como ganhar autonomia?

Durante a aula, você acompanha a explicação e o código parece fazer sentido. Mas, quando fecha o vídeo e tenta construir algo, não sabe por onde começar. Essa diferença pode ser frustrante, principalmente depois de dedicar bastante tempo aos estudos.

Na aula, alguém escolheu a ordem dos passos, o arquivo que precisava mudar e o momento de conferir o resultado. Ganhar autonomia exige praticar essas decisões: escolher uma alteração pequena, investigar o código e verificar se ela resolveu o problema. Você pode continuar consultando materiais e pedindo ajuda durante esse processo.

Não precisa abandonar os tutoriais. Precisa criar um espaço entre acompanhar uma solução e procurar a próxima: um momento em que a pergunta é sua e a resposta ainda não está pronta na tela.

Comece com uma mudança que caiba no projeto que você conhece

Se você acabou uma aplicação de estudo, aproveite o que já funciona. Escolha uma mudança que consiga descrever em uma frase e cujo resultado possa conferir. Refazer o projeto inteiro ou acrescentar várias tecnologias cria mais decisões simultâneas do que você precisa para esse treino.

Vamos trabalhar com uma calculadora de pedido em Java. Ela soma os produtos e acrescenta R$ 15 de frete. A mudança será oferecer frete grátis quando o subtotal chegar a R$ 100. O interesse está no caminho até a solução: esclarecer a regra, encontrar onde ela deve entrar e demonstrar que funciona.

Este exercício pressupõe que você já leu programas com variáveis, arrays, condições e métodos. Se esses conceitos ainda forem novos, faça primeiro o orçamento para começar programação do zero. Aqui vamos usá-los para tomar decisões sobre um código existente.

Esclareça o que a mudança precisa fazer

“Colocar frete grátis” deixa perguntas abertas. O valor mínimo inclui o frete? A promoção vale exatamente em R$ 100? Descontos interferem no cálculo? Resolver isso antes de editar evita que uma escolha acidental no código se transforme na regra do produto.

Neste exercício, o subtotal é a soma dos preços dos produtos. A partir de R$ 100, inclusive, o frete é zero; abaixo disso, custa R$ 15. Não há descontos. Os preços já chegam como inteiros não negativos em centavos, e consideramos apenas pedidos com produtos. Usaremos valores pequenos: tanto o subtotal quanto o total com frete precisam caber em um int, cujo máximo é 2.147.483.647. O exemplo não verifica esse limite automaticamente.

Anote exemplos que tornem essa decisão verificável:

Subtotal dos produtos	Frete	Total
R$ 99	R$ 15	R$ 114
R$ 100	R$ 0	R$ 100
R$ 120	R$ 0	R$ 120

O total cair entre R$ 99 e R$ 100 é consequência da promoção definida. Se isso não fizer sentido para quem pediu a mudança, a conversa é sobre o requisito. Alterar a comparação por conta própria apenas esconderia a dúvida.

Encontre o lugar da regra antes de escrever a solução

Use JDK 21 e salve o programa abaixo em PedidoDemo.java. No terminal aberto nessa pasta, execute java PedidoDemo.java. Os exemplos foram verificados com OpenJDK 21.0.2, sem dependências externas.

Ao chamar um método, você fornece valores chamados argumentos; aqui, o argumento será um array de preços. return devolve o resultado para quem fez a chamada. A palavra static permite chamar calcularPedido pela própria classe, sem criar um objeto PedidoDemo.

O programa usa um record, uma forma de reunir dados em Java. Pedido guarda subtotal e frete; seu método total() soma os dois. O método calcularPedido recebe um array de preços e monta esse resultado. main fornece os dados do exemplo e mostra o total.

public class PedidoDemo {
    record Pedido(int subtotal, int frete) {
        int total() {
            return subtotal + frete;
        }
    }

    static Pedido calcularPedido(int[] precosEmCentavos) {
        int subtotal = 0;
        for (int preco : precosEmCentavos) {
            subtotal += preco;
        }
        int frete = 1500;
        return new Pedido(subtotal, frete);
    }

    public static void main(String[] args) {
        Pedido pedido = calcularPedido(new int[] {6000, 4000});
        System.out.println("Total em centavos: " + pedido.total());
    }
}

A saída é Total em centavos: 11500: R$ 100 de produtos mais R$ 15 de frete. Esse é o comportamento anterior à promoção. Executá-lo primeiro confirma um ponto de partida conhecido.

Agora acompanhe os dados. subtotal += preco soma cada preço ao valor acumulado. Depois da repetição, o subtotal está pronto. O frete é definido e os dois valores formam o Pedido. A impressão no terminal acontece depois de tudo isso.

A condição deve entrar quando o subtotal já existe, antes de criar o resultado. Colocá-la somente na impressão poderia mostrar uma mensagem de promoção enquanto o pedido continuasse cobrando R$ 15.

Em um projeto maior, faça esse mesmo mapa curto: de onde vem o valor, onde ele é transformado e quem recebe o resultado. Registre a versão inicial no Git ou mantenha uma cópia. Adie reorganizações de pastas e mudanças de bibliotecas para conseguir avaliar o efeito desta alteração separadamente.

Use a documentação para resolver a dúvida que apareceu

Talvez você saiba onde mudar, mas não lembre como escrever “maior ou igual” em Java. Essa é uma consulta sobre o operador >=. Talvez lembre a sintaxe, mas ainda esteja somando o frete antes de comparar. Nesse caso, precisa voltar ao significado de subtotal.

A seção de operadores nos fundamentos de Java ajuda na primeira dúvida. A tabela de resultados ajuda na segunda. Identificar qual pergunta está aberta evita trocar uma investigação pequena por outro tutorial completo de loja.

Se pedir ajuda, mostre a tentativa e a divergência: “Com produtos de R$ 99, meu programa deu frete grátis. Comparei o total com R$ 100. Qual valor deveria representar o critério?”. Há informação suficiente para discutir o raciocínio sem alguém reconstruir o projeto por você.

Depois da consulta, volte ao arquivo e faça sua tentativa. Conseguir usar uma explicação no próprio contexto é uma parte importante da prática; ler a resposta e reconhecê-la não revela se você já consegue aplicá-la.

Confira a regra com casos que distinguem soluções parecidas

A mudança é pequena: começar o frete em 1500 e zerá-lo quando subtotal >= 10000. Mas ver apenas um pedido funcionando não basta. Precisamos conferir abaixo do limite, exatamente nele e acima dele.

A versão completa abaixo inclui essas verificações. conferir compara o pedido calculado com o esperado e lança um AssertionError se houver diferença. Isso interrompe o programa e identifica o caso que falhou. É um teste local simples, sem biblioteca adicional.

public class PedidoDemo {
    record Pedido(int subtotal, int frete) {
        int total() {
            return subtotal + frete;
        }
    }

    static Pedido calcularPedido(int[] precosEmCentavos) {
        int subtotal = 0;
        for (int preco : precosEmCentavos) {
            subtotal += preco;
        }
        int frete = 1500;
        if (subtotal >= 10000) {
            frete = 0;
        }
        return new Pedido(subtotal, frete);
    }

    static void conferir(String caso, int[] precos, Pedido esperado) {
        Pedido atual = calcularPedido(precos);
        if (!atual.equals(esperado)) {
            throw new AssertionError(caso + ": " + atual);
        }
    }

    public static void main(String[] args) {
        conferir("abaixo", new int[] {9900}, new Pedido(9900, 1500));
        conferir("um centavo antes", new int[] {9999},
                 new Pedido(9999, 1500));
        conferir("no limite", new int[] {6000, 4000},
                 new Pedido(10000, 0));
        conferir("acima", new int[] {12000}, new Pedido(12000, 0));
        System.out.println("Regra de frete verificada");
    }
}

Substitua o conteúdo de PedidoDemo.java por essa versão e execute novamente. A saída deve ser Regra de frete verificada. O equals de um record compara seus componentes, por isso o teste detecta diferenças tanto no subtotal quanto no frete.

Troque >= por > e execute. O caso no limite deve falhar. Restaure o operador. Depois experimente comparar subtotal + frete >= 10000: o caso abaixo deve falhar, porque a implementação está contando o transporte para conceder o benefício. Restaure o código novamente.

Esses experimentos mostram por que escolhemos os casos. Eles distinguem a regra combinada de duas implementações plausíveis, mas erradas. Ainda não tratamos carrinho vazio, entradas inválidas, descontos ou cobrança real; isso precisaria de outros requisitos e testes.

Faça uma segunda mudança com menos orientação

Agora permita que o valor mínimo da promoção seja informado ao método. Antes de escrever, escolha dois limites diferentes e calcule exemplos no papel. Reaproveite os testes anteriores com limite de R$ 100 e acrescente os novos. Essa variação exige decidir como passar a informação sem mudar a regra por acidente.

Ao terminar, explique o caminho sem ler o artigo: qual era o comportamento, qual decisão faltava, onde você alterou e como verificou. Se uma parte não sair, você encontrou um ponto específico para revisar.

Guarde também a dúvida que resolveu e a fonte que consultou. Esse registro permite retomar o raciocínio e mostrar a evolução de um projeto. O roteiro de portfólio backend além do tutorial ajuda a transformar essas mudanças em uma demonstração que você consegue sustentar.

Se percebeu lacunas nos fundamentos e quer uma sequência acompanhada, compare os conteúdos da formação Build & Run com o que travou durante a tentativa. A próxima aula pode responder a uma necessidade que você já reconhece no seu código.

Referências consultadas em 04/11/2026: fundamentos de Java, classes record no JDK 21 e execução de arquivos no JDK 21.