# Como começar programação do zero: o que estudar e como praticar
Comece programação com uma sequência de fundamentos em Java e aprenda a praticar: acompanhe os dados, confira resultados e investigue seus primeiros erros.
Por Bruno Rana
Publicado em: 2026-11-04
Atualizado em: 2026-11-04
Artigo original: https://buildrun.com.br/blog/como-comecar-programacao-do-zero/
Um primeiro programa parte de valores conhecidos e produz uma resposta que você consegue conferir.
Se você está começando, a quantidade de assuntos pode dar a impressão de que precisa aprender tudo antes de fazer alguma coisa. Cada busca abre outra lista: linguagem, banco de dados, framework, nuvem. Fica difícil distinguir o que vem primeiro do que pode esperar.
**Seu primeiro objetivo é conseguir escrever um programa pequeno, acompanhar o que ele faz e mudar uma parte entendendo o resultado.** Para isso, comece por valores, variáveis, operações, condições e repetições. Escolha uma linguagem para praticar esses fundamentos e dê tempo para eles fazerem sentido.
Você não precisa definir toda a carreira agora. Ao construir e investigar programas pequenos, vai reunir experiências melhores para escolher o próximo assunto. É esse começo que vamos organizar aqui, usando Java.
## Estude os fundamentos enquanto resolve uma pergunta pequena
“Aprender lógica” parece uma tarefa enorme quando não há nada concreto para resolver. A lógica começa a aparecer quando você precisa decidir quais informações usar, em que ordem trabalhar com elas e como reconhecer uma resposta correta.
Vamos calcular quanto resta de um orçamento. Há um limite de R$ 100 e três despesas fictícias: R$ 30 de mercado, R$ 20 de transporte e R$ 10 de alimentação. Os gastos somam R$ 60; portanto, sobram R$ 40. Você já consegue conferir essa conta no papel, o que será útil quando o programa não responder como esperava.
Descreva o caminho em português: começar o total em zero, somar uma despesa por vez, subtrair o total do limite e mostrar o saldo. Essa sequência de passos é um **algoritmo**. A linguagem será a forma de escrever esses passos para o computador executar.
Cada fundamento passa a ter uma função nesse caminho:
| O que estudar | Para que vamos usar |
| --- | --- |
| Valores, tipos e variáveis | Representar o limite e o total gasto. |
| Operações aritméticas | Somar as despesas e calcular a diferença. |
| Arrays e repetições | Agrupar os gastos e percorrê-los um por vez. |
| Condições | Escolher a mensagem conforme o saldo. |
| Métodos | Depois, reutilizar o cálculo para outras semanas. |
Uma variável dá nome a um valor; seu tipo determina que espécie de valor ela pode guardar. Um **array** reúne uma quantidade definida de elementos do mesmo tipo. Um **método** organiza instruções que podem ser chamadas em outra parte do programa. Primeiro vamos acompanhar o cálculo inteiro; a separação em métodos pode vir depois.
## Prepare o ambiente e execute uma primeira versão
Para escrever o arquivo, você precisa de um editor. Para compilar e executar Java, precisa do **JDK**, o conjunto de ferramentas de desenvolvimento da linguagem. Uma IDE reúne editor e outras ferramentas, mas não substitui a necessidade de um JDK compatível.
Use JDK 21 neste exercício. O [guia oficial de primeiros passos em Java](https://dev.java/learn/getting-started/) apresenta a preparação do ambiente. No terminal, a janela onde você digita comandos, execute `java --version` e confira se aparece a versão 21. Os exemplos deste artigo foram verificados com OpenJDK 21.0.2.
Crie uma pasta para o exercício e salve o código abaixo em um arquivo chamado `Orcamento.java`, respeitando a inicial maiúscula. Abra o terminal nessa pasta. O comando `java Orcamento.java` compila e executa esse arquivo diretamente, sem precisar criar um projeto com outras dependências.
Antes de ler o código, conheça sua organização: `class Orcamento` reúne o programa e `main` é o método pelo qual a execução começa. As instruções do exercício ficam dentro dele. Você pode manter essa estrutura enquanto aprende as contas; classes e métodos terão mais espaço quando começar a organizar programas maiores.
```java
public class Orcamento {
public static void main(String[] args) {
int limiteEmCentavos = 10000;
int[] despesasEmCentavos = {3000, 2000, 1000};
int totalEmCentavos = 0;
for (int despesa : despesasEmCentavos) {
totalEmCentavos = totalEmCentavos + despesa;
}
int saldoEmCentavos = limiteEmCentavos - totalEmCentavos;
System.out.println("Saldo em centavos: " + saldoEmCentavos);
if (saldoEmCentavos < 0) {
System.out.println("Limite ultrapassado");
} else {
System.out.println("Dentro do limite");
}
}
}
```
A saída deve ser `Saldo em centavos: 4000`, seguida de `Dentro do limite`. Quatro mil centavos correspondem aos R$ 40 que calculamos no papel.
Usamos `int`, um tipo de número inteiro, e representamos o dinheiro em centavos: R$ 30 vira `3000`. Assim, este pequeno exercício não precisa tratar casas decimais. Os valores são fictícios, inteiros, não negativos e pequenos; um sistema financeiro real precisaria definir validação, limites numéricos e arredondamento.
## Acompanhe o que muda a cada instrução
O símbolo `=` atribui um valor à variável. Na linha que soma a despesa, Java calcula primeiro o lado direito e guarda o resultado em `totalEmCentavos`. Por isso, o total anterior participa da próxima soma.
O `for` percorre o array. Em cada passagem, `despesa` recebe um dos valores: primeiro `3000`, depois `2000` e finalmente `1000`. O total começa em zero e passa por `3000`, `5000` e `6000`. O limite continua em `10000`.
O acumulador guarda o resultado da soma anterior. Os valores da ilustração estão em reais; o programa faz as mesmas contas em centavos.
Depois da repetição, a subtração produz o saldo. `System.out.println` escreve uma linha no terminal. O `if` testa uma condição: o saldo é menor que zero? Se for, executa a primeira mensagem. Caso contrário, executa a parte do `else`.
Você pode conferir essa leitura colocando temporariamente `System.out.println(totalEmCentavos);` dentro do `for`, logo após a soma. Compare cada linha exibida com sua conta. Esse acompanhamento ajuda a localizar onde o resultado se afastou do esperado.
## Pratique com previsões, não apenas com cópias
Agora mantenha o mesmo programa e troque somente os valores do array. Antes de executar, anote o saldo que espera encontrar:
| Despesas no código | Saldo em centavos | Mensagem esperada |
| --- | --- | --- |
| `{3000, 2000, 1000}` | 4000 | Dentro do limite |
| `{}` | 10000 | Dentro do limite |
| `{10000}` | 0 | Dentro do limite |
| `{10000, 100}` | -100 | Limite ultrapassado |
As chaves vazias representam um array sem despesas. Nesse caso, o `for` não executa nenhuma soma e o total permanece zero. Já gastar exatamente o limite deixa saldo zero: a mensagem continua sendo `Dentro do limite`, porque a condição usa `< 0`.
O caso exato separa gastar todo o orçamento de ultrapassá-lo. No código, menos um real aparece como menos cem centavos.
Para perceber a importância desse detalhe, troque `< 0` por `<= 0` e repita o caso `{10000}`. A mensagem ficará errada para a regra que combinamos. Restaure `< 0` e confira novamente. Você acabou de usar um caso de teste para detectar uma mudança de comportamento.
Quando houver uma falha, tente distinguir sua origem. Se `java` não for reconhecido, confira a instalação. Se o arquivo não for encontrado, confira nome e pasta. Se faltar um ponto e vírgula, leia o erro de compilação. Se tudo executar e o saldo vier errado, acompanhe os valores. Cada problema pede uma investigação diferente.
## Crie uma rotina que permita retomar o raciocínio
Escolha uma pequena entrega por sessão: executar o arquivo, explicar a repetição ou conferir os quatro casos. Ao parar, deixe uma anotação específica, como “a soma funciona; quero descobrir como receber outro limite sem copiar o programa”. Isso oferece um ponto de partida para o próximo estudo.
Quando conseguir reconstruir o cálculo com suas anotações, experimente colocá-lo em um método que receba o limite e as despesas e devolva o saldo. Depois pense em categorias ou armazenamento. Uma tela pode esperar até você compreender o comportamento que ela vai apresentar.
Consultar documentação e pedir ajuda fazem parte da prática. Leve sua tentativa e a diferença encontrada: “o total ficou 2000 depois da segunda despesa; esperava 5000”. Essa informação permite discutir a atribuição que ocorreu, em vez de receber outro programa inteiro para copiar.
## Use o que aprendeu para escolher o próximo assunto
Uma tela de despesas, uma regra acessada pela internet e uma análise dos gastos colocam perguntas diferentes. Experimente essas possibilidades na [comparação entre frontend, backend e dados](https://buildrun.com.br/blog/frontend-backend-ou-dados/). A escolha fica mais concreta depois que você observa o trabalho envolvido.
Se backend despertou sua curiosidade, acompanhe [o caminho de uma requisição](https://buildrun.com.br/blog/o-que-faz-desenvolvedor-backend/). Para continuar em Java, o [roteiro anterior ao Spring Boot](https://buildrun.com.br/blog/o-que-estudar-antes-spring-boot/) conecta linguagem, HTTP e SQL. Se executar ficou fácil, mas mudar o programa ainda trava, pratique [uma alteração fora do tutorial](https://buildrun.com.br/blog/como-programar-sem-tutorial/).
Guarde o orçamento e suas anotações. Eles mostram o que você já consegue explicar e onde precisa de apoio. Se procura uma sequência acompanhada de estudos, compare os [conteúdos da formação Build & Run](https://buildrun.com.br/blog/formacao-buildrun/) com essas dificuldades concretas.
Referências consultadas em 04/11/2026: [fundamentos da linguagem Java](https://dev.java/learn/language/constructs/basics/) e [comando java no JDK 21](https://docs.oracle.com/en/java/javase/21/docs/specs/man/java.html). O programa roda localmente, mantém os dados apenas durante a execução e não implementa entrada de usuários nem persistência.
