⬅

#android

Aprenda Kotlin 2026: Guia Completo para Iniciantes

Um guia estruturado, lição por lição, para aprender a linguagem de programação Kotlin. Cada lição leva cerca de 30 minutos e inclui código real que você pode executar e finalizar com um desafio para testar você mesmo.

—

Começar em programação parece mais difícil do que realmente é. No início, tudo soa novo: linguagem, editor, projeto, execução, saída no console. A boa notícia é que você não precisa entender tudo de uma vez. Basta dar o primeiro passo na ordem certa.

Este guia foi pensado para quem está começando do absoluto zero com Kotlin. A ideia é construir uma base sólida, sem pular etapas, para que você entenda o que está fazendo sem copiar código sem contexto.

Ao longo deste começo, você vai aprender o essencial para sair do "não sei por onde começar" e chegar ao "consigo escrever meus primeiros programas Kotlin".

Cada lição foi planejada para levar cerca de 30 minutos e termina com um pequeno desafio para você testar o que acabou de aprender.

Importante: Cada etapa se apoia na anterior. Siga na ordem certa e você terá uma base sólida em Kotlin, pronta para o desenvolvimento de aplicativos reais.

Etapa 1: Introdução ao Kotlin

Todo desenvolvedor começou exatamente onde você está agora. Os primeiros passos não precisam ser perfeitos, eles só precisam ser claros. Nesta primeira etapa, o foco é entender o ambiente, escrever sua primeira linha de código e reconhecer como o Kotlin se comporta.

Você não precisa de formação em computação para acompanhar. Precisa apenas de uma ferramenta para escrever e executar código Kotlin, como o Playground Kotlin, Android Studio ou uma IDE compatível com Kotlin. O importante agora é ter um lugar para testar ideias rapidamente.

IDE: Integrated Development Environment. É o Ambiente de Desenvolvimento Integrado, isto é, a ferramenta que fornece um kit para o programador programar.

No fim desta etapa, você vai entender como um programa Kotlin é organizado, como o código é executado e por que os primeiros exemplos parecem simples, mas são a base de tudo o que vem depois.

1.1 O primeiro programa na linguagem Kotlin

Prefere assistir ao video? Assista o video desta lição

O que é Kotlin?

Kotlin é uma linguagem de programação moderna, criada para ser clara, concisa e produtiva. Muito usada nos dias atuais para aplicativos e outros softwares.

Em termos simples, uma linguagem de programação é uma forma organizada de dar instruções para o computador. Você escreve essas instruções em uma sintaxe que a ferramenta entende e, depois, a máquina executa o que foi pedido.

Pense em uma receita. Uma receita tem formato, ordem e instruções objetivas porque precisa ser lida e seguida corretamente. Kotlin funciona do mesmo jeito: ele oferece uma estrutura para você expressar lógica de forma que o computador consiga interpretar.

Hoje, Kotlin é amplamente usado no desenvolvimento Android, mas também pode ser aplicado em outras áreas, como backend e aplicações multiplataforma. Quando você aprende Kotlin, está aprendendo uma linguagem que o ecossistema Android adotou oficialmente e que é muito valorizada no mercado.

Como iniciante, você tem algumas opções, mas duas delas se destacam:

Kotlin Playground

É uma opção no navegador, em play.kotlinlang.org, onde você pode escrever Kotlin e ver o resultado imediatamente, sem instalação. Se você quer começar rápido e testar exemplos sem configurar nada, essa é a escolha mais simples.

IntelliJ IDEA

É uma IDE muito forte para Kotlin, especialmente fora do contexto Android. Ela também é bastante usada em projetos backend e em estudos mais avançados da linguagem. Para quem quer praticar Kotlin com liberdade, é uma excelente opção.

Se você estiver começando agora, o caminho mais natural é usar o Kotlin Playground para "brincar". Ele já traz tudo o que você precisa para escrever código Kotlin, testar exemplos e evoluir sem instalar nada no começo. E depois, para se profissionalizar, com certeza você vai precisar instalar o IntelliJ.

Como se parece um programa Kotlin?

O exemplo mais simples possível é uma linha que imprime texto no console:

Console: É a área onde o programa mostra o resultado da execução. Quando você usa println(), é ali que a saída aparece. 

fun main() {
    println("Olá, mundo!")
}

Esse trecho diz ao computador: execute a função principal e mostre a mensagem no console. Quando você roda esse código em um projeto Kotlin, essa saída aparece imediatamente. 

Olá mundo!

Vamos quebrar isso em partes:

PARTE SIGNIFICADO
fun main() É o ponto de entrada do programa, a ignição (falaremos disso mais à frente).
{ } Delimitam o bloco/escopo de código que será executado.
println("Olá, mundo!") Escreve texto na saída padrão e pula uma linha ao final.

Um erro muito comum de iniciante é esquecer aspas ao escrever texto. Se você digitar algo como println(Olá) em vez de println("Olá"), o Kotlin vai interpretar o Olá como um identificador de código - uma instrução - não como uma frase. Aspas dizem ao compilador que aquilo é texto literal, não instrução de máquina.

Como o Kotlin executa o código?

Quando você aperta executar , o Kotlin processa o código na ordem em que ele foi escrito. Em exemplos simples isso parece óbvio, mas essa ideia fica muito importante quando os programas começam a ter várias linhas, funções e decisões condicionais.

Compilador: É a ferramenta que traduz seu código Kotlin para algo que o computador consiga executar. Se houver um erro de sintaxe, ele interrompe a compilação e mostra onde está o problema.

A importância dos comentários.

Agora, se você quiser por notas no seu código para lembrar ou documentar ele, você pode usar comentários que informam ao compilador para ignorar estes textos, pois eles não fazem parte do código como instrução. Veja o exemplo abaixo: 

/*
  Este é um bloco de comentário
  E o compilador vai ignorar/descartar
  Então, não haverá erros aqui.
 */
fun main() {
    // Este é um comentário também só que em 1 linha
    println("Olá, mundo!")
}

No exemplo acima, existe o bloco de comentários onde tudo o que estiver dentro de /* */ será ignorado em multiplas linhas ou se for uma únicado linha, tudo após //.

❗Desafio da Aula

Crie um pequeno programa Kotlin que imprima três linhas sobre você: Diga seu nome, sua cidade e o motivo pelo qual você quer aprender Kotlin.

Use três chamadas separadas de println(), cada uma em sua própria linha. Rode o programa e confira se as três mensagens aparecem corretamente na saída do console.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique em português simples o que acontece quando eu aperto executar em um Kotlin Playground. O que o computador faz com meu código?

Prompt #2:

Sou iniciante em Kotlin. Qual é a diferença entre Kotlin, IntelliJ IDEA e Kotlin Playground? Explique primeiro, antes de mostrar exemplos de código.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo em Kotlin que use println() de 5 formas diferentes: texto, números, várias coisas ao mesmo tempo e linhas em branco. Adicione um comentário em cada linha explicando o que ela faz, para alguém que nunca programou.

1.2 println() — Exibindo saída do seu código

Prefere assistir ao video? Assista o video desta lição

Você já usou println() na última aula. Agora é hora de entender de verdade o que ela faz.

Essa é provavelmente a ferramenta mais importante para quem está começando, porque permite enxergar exatamente o que está acontecendo dentro do código.

println() faz mais do que mostrar texto. Pode mostrar números, resultados de cálculos e até múltiplos valores ao mesmo tempo. 

// Imprimindo texto (texto precisa estar entre aspas)
println("Estou aprendendo Kotlin")

// Imprimindo um número
println(42)

// Imprimindo resultado de cálculo
println(10 + 5)

// Imprimindo múltiplos valores
// Maneira 1
println("A resposta é " + 42 + " da minha prova")
// Maneira 2
println("O jeito elegante de ${2026} para textos")

// Linha em branco
println()

Resultado: 

Estou aprendendo Kotlin
42
15
A resposta é 42 da minha prova
O jeito elegante de 2026 para textos
O que você escreveu O que Kotlin faz
println("Estou aprendendo Kotlin") Mostra exatamente o texto entre aspas
println(42) Mostra o número 42
println(10 + 5) Calcula primeiro e imprime 15
println("A resposta é " + 42 + " da minha prova") Une os valores (concatenar)
println("O jeito elegante de ${2026} para textos") Faz interpolação do conjunto de caracteres
println() Imprime uma linha vazia

Concatenação é quando você junta pedaços de texto manualmente.

Na concatenação, você pega uma coisa e cola na outra. Fica como se fosse: "Olá," + "Kotlin", e o resultado vira "Olá, Kotlin".

É basicamente isso: pegar partes separadas e unir em uma frase só.

Interpolação faz a mesma coisa, mas de um jeito mais natural. Em vez de ficar juntando pedaço por pedaço, você escreve a frase normalmente e coloca o que muda dentro dela.

É como escrever: "Olá, nome", e o Kotlin automaticamente troca "nome" pelo valor real, por exemplo "Tiago".

Comentários: notas dentro do código

Você viu linhas começando com //. Já falamos sobre comentários.

Eles servem para deixar notas para você mesmo ou para outros programadores.

O compilador simplesmente ignora comentários. 

// Esta linha é um comentário
println("Essa linha executa") // comentário ao lado

Resultado: 

Essa linha executa

Crie o hábito de comentar seu código.

No começo parece desnecessário, mas depois de alguns dias você vai agradecer por ter explicado para si mesmo o que estava fazendo.

Matemática básica dentro do println()

Kotlin entende operadores matemáticos normalmente: 

println(10 + 3) // Soma -> 13
println(10 - 3) // Subtração -> 7
println(10 * 3) // Multiplicação -> 30
println(10 / 3) // Divisão inteira -> 3
println(10 % 3) // Resto -> 1

Resultado: 

13
7
30
3
1

NOTA: Por que 10 / 3 vira 3?

Porque ambos são inteiros (Int).

Quando você divide dois números inteiros em Kotlin, o resultado também será inteiro.

A parte decimal é descartada.

Se quiser preservar casas decimais: 

println(10.0 / 3)

Resultado: 

3.3333333333333335

Use println() para debug

Programadores usam println() o tempo inteiro.

Quando algo quebra, imprimir valores intermediários ajuda muito a entender: o valor que chegou, onde mudou e onde deu errado. Debug começa com println(). Sempre.

Debug é o processo de descobrir o que está acontecendo no seu código quando algo não funciona como esperado.

Programar é dar instruções para o computador. Às vezes você acha que pediu uma coisa, mas na real cometeu um erro na lógica. O debug existe para investigar isso.

❗Desafio da Aula

Imagine que você comprou 3 itens: Um produto de 12 reais, outro produto de 8 reais e outro produto de 25 reais. Agora, crie um programa Kotlin que imprima cada valor em uma linha, deixe uma linha em branco e por fim, imprima o total calculado.

Não digite o total manualmente.

Faça o Kotlin calcular.

A saída aproximada seria algo como: 

Produto 1 = 12
Produto 2 = 8
Produto 3 = 25

Total a pagar = 45

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Acabei de aprender println() em Kotlin. Me faça perguntas, uma de cada vez, sobre o que println() faz em diferentes situações. Se eu errar, explique o motivo.

Comentários no código

Prompt #2:

Estou aprendendo Kotlin e entendi que // /**/ inicia um comentário. Explique quando eu realmente devo comentar meu código. Mostre exemplos de comentários úteis e comentários inúteis.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo curto em Kotlin mostrando 6 formas diferentes de usar println(): texto, número, cálculo, interpolação, linha vazia e algo criativo. ainda não use variáveis. Mostre as pegadinhas.

Comente cada linha explicando o que ela faz.

Escreva para um iniciante absoluto.

1.3 Variáveis e Constantes: Memória do seu Código

Prefere assistir ao video? Assista o video desta lição

Até aqui, você já usou valores diretamente no código, digitou números e textos sem pensar muito sobre onde eles ficam guardados. Mas programas reais precisam armazenar informação e reutilizá-la em vários lugares. É exatamente para isso que servem variáveis e constantes.

Pense como uma caixa com etiqueta

Imagine uma caixa de papelão com uma etiqueta na frente. Você coloca algo dentro e, quando precisar de novo, se refere a essa caixa pelo nome da etiqueta em vez de olhar o conteúdo toda hora.

Variáveis e constantes funcionam assim: você dá um nome para uma informação e usa esse nome ao longo do código, como referência para o conteúdo. 

// Cria uma variável chamada limite e coloca 0 dentro dela
var limite = 0

// Usa o valor armazenado em limite
println(limite)

// Altera o valor guardado em limite
limite = 10
println(limite)

// Você pode fazer conta usando a variável
limite = limite + 5
println(limite)

Resultado: 

0
10
15
O que você escreveu O que Kotlin faz
var limite = 0 Cria uma nova variável chamada limite e guarda o valor 0 nela. O var diz ao Kotlin que esse valor pode mudar depois.
println(limite) O Kotlin procura o valor armazenado em limite e imprime esse valor. Repare que não há aspas, porque limite é uma variável, não texto.
limite = 10 Troca o valor atual da variável. O 0 sai e o 10 entra no lugar.
limite = limite + 5 Lê o valor atual de limite, soma 5 e guarda o novo resultado de volta na mesma variável.

Agora, as vezes você tem informação que não deveria mudar. Por exemplo, o número de dias em uma semana ou a sua data de nascimento. Nesses casos, use val em vez de var. 

// Uma constante - esse valor não vai mudar
val diasDaSemana = 7

println(diasDaSemana)

// Isto causaria erro - você não pode alterar uma constante:
// diasDaSemana = 8

Resultado: 

7

Se você tentar mudar uma constante, o Kotlin não vai deixar o programa compilar. Isso é uma proteção útil para evitar mudanças acidentais em valores que deveriam permanecer fixos.

var vs val: uma boa regra para iniciantes é começar com val. Se o Kotlin reclamar que você precisa alterar o valor, aí você troca para var. Na prática, desenvolvedores Kotlin preferem val sempre que possível porque isso deixa o código mais seguro e mais fácil de entender.

Nomeando suas variáveis

Nomes de variáveis podem ser quase qualquer coisa, mas existem regras e boas práticas importantes:

Se o nome da sua variável for em português como preço, use preco no lugar.

Porque a programação funciona em inglês, e caracteres como acentos e cedilha não existem no idioma. Ou seja, sempre que precisar declarar algo que remeta à lingua portuguesa, remova os acentos e caracteres especiais.

camelCase: é o padrão de escrever nomes compostos começando com letra minúscula e colocando a próxima palavra com inicial maiúscula, como nomeDoJogador ou limiteMaximo. Se você seguir isso desde o começo, seu código vai ficar muito mais legível. 

// Bons nomes - claros e descritivos
var nomeDoJogador = "Tiago"
var limiteMaximo = 1500
val totalPontos = 3

// Kotlin usa camelCase - sem espaços e com cada nova palavra começando em maiúscula
var itensNoCarrinho = 0

// Estes exemplos causariam erro:
// var 1jogador = "Tiago"    // não pode começar com número
// var nome do jogador = "Tiago" // não pode ter espaços

❗Desafio da Aula

Crie uma variável chamada pontos e comece com o valor 0. Depois, simule um jogo em que o jogador ganha 10 pontos, perde 3 pontos e ganha mais 7 pontos. Após cada mudança, imprima o valor atual.

No final, use uma constante para guardar o nome do jogador e imprima uma mensagem final com o nome e a pontuação total.

A saída deve mostrar quatro valores diferentes da pontuação, incluindo o valor inicial, e depois uma linha final com o nome do jogador e a pontuação final.

Exemplo de saída: 

10
7
14
Tiago tem 14 pontos

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Acabei de aprender var e val em Kotlin. Me faça perguntas, uma de cada vez, sobre quando eu deveria usar cada um. Se eu errar, explique o motivo.

var vs. val no código

Prompt #2:

Em Kotlin, por que é importante usar `var` ou `val` se eu sou o único que está escrevendo o código? Explique os motivos práticos pelos quais um iniciante deveria se importar com essa distinção.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo curto em Kotlin mostrando 3 situações com var e val: uma variável que muda, uma constante e um cálculo usando a variável. Mostre também um exemplo de nome ruim e um de nome bom. Comente cada linha explicando o que ela faz. Escreva para um iniciante absoluto.

1.4 Tipos de dados que ajudam o programador

Prefere assistir ao video? Assista o video desta lição

Quando você cria uma variável, o Kotlin precisa saber que tipo de valor ela vai guardar. É texto? Um número inteiro? Um número com casas decimais? Verdadeiro ou falso? Cada um desses casos é um tipo de dado diferente, e o Kotlin trata cada um de um jeito.

Na aula anterior, você criou variáveis sem escrever o tipo explicitamente. Isso funciona porque o Kotlin consegue descobrir muita coisa sozinho. Agora vamos entender o que está acontecendo por baixo dos panos.

Os quatro tipos mais importantes

Esses são os tipos que você vai usar o tempo todo no começo:

Tipo Serve para
String Texto, como nomes, mensagens e frases
Int Números inteiros, sem casas decimais
Double Números com casas decimais
Boolean Valores de verdadeiro ou falso

String

String é qualquer texto: uma palavra, uma frase, ou até um caractere solto. Em Kotlin, texto sempre fica entre aspas. 

val nome: String = "Tiago"
val cidade = "São Paulo"   // Kotlin descobre que isso é String
val textoVazio = ""     // String vazia ainda é String

Uma String é como uma sequência de caracteres. Se tem aspas e representa texto, o Kotlin entende que é String.

Int

Int é abreviação de integer, ou seja, número inteiro. Use esse tipo quando o valor não precisa de casas decimais. 

val idade: Int = 28
val pontos = 1500      // Kotlin entende que isso é Int
val temperatura = -5   // números negativos também funcionam

Int serve bem para idade, contagem, pontuação e quantidade de itens.

Double

Double é usado para números com casas decimais. É a escolha certa quando você quer guardar valores como preço, altura ou média. 

val preco: Double = 9.99
val altura = 1.75
val pi = 3.14159

Se o valor tem ponto decimal, o Kotlin normalmente entende como Double.

Boolean

Boolean só aceita dois valores: true ou false. Ele é útil para representar estados e condições. 

val usuarioLogado: Boolean = false
val compraAprovada = true
val admin = false

Você vai usar Boolean o tempo todo em programas reais: o usuário está logado? o carrinho tem itens? a tarefa foi concluída?

Inferência de tipos: o Kotlin é esperto

Na maioria das vezes, você não precisa escrever o tipo à mão. O Kotlin consegue inferir o tipo a partir do valor que você atribui. 

// Com tipo explícito
val nome: String = "Tiago"
val preco: Double = 4.99

// Sem escrever o tipo
val sobrenome = "Aguiar"   // Kotlin vê aspas e entende String
val desconto = 4.99      // Kotlin vê número decimal e entende Double
val idade = 36        // Kotlin vê número inteiro e entende Int
val vendido = true      // Kotlin vê true/false e entende Boolean

Os dois estilos funcionam. No começo, muita gente prefere deixar o Kotlin descobrir sozinho porque isso reduz a quantidade de coisas para digitar e ler.

Por que você não pode misturar tipos

Depois que uma variável recebe um tipo, ela continua com esse tipo. Você não pode guardar texto em uma variável criada para números. 

var pontos = 100   // pontos é Int

// Isto causaria erro:
// pontos = "cem"

// Isto funciona:
pontos = 200

Se você tentou colocar um valor do tipo errado, o Kotlin não vai compilar. Isso é uma proteção útil, porque evita bugs bobos e deixa o código mais previsível.

Regra prática: se o valor é texto, use String. Se é número inteiro, use Int. Se tem casa decimal, use Double. Se é uma decisão de sim ou não, use Boolean.

❗Desafio da Aula

Crie um conjunto de variáveis para representar um usuário fictício em um app. Você precisa guardar:

  • o nome
  • a idade
  • o saldo da conta
  • se a pessoa é premium ou não

Use o tipo mais apropriado para cada valor e decida se cada um deve ser var ou val. Depois, imprima todos os valores.

Exemplo de saída: 

Ana
28
1540.75
true

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Acabei de aprender sobre String, Int, Double e Boolean em Kotlin. Me faça perguntas, uma de cada vez, sobre que tipo de dado eu deveria usar em cada situação. Se eu errar, explique o motivo.

Tipos de dados no código

Prompt #2:

Em Kotlin, por que é importante escolher o tipo certo de dado se eu sou iniciante? Explique com exemplos simples por que String, Int, Double e Boolean existem.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo curto em Kotlin mostrando 4 variáveis: uma String, um Int, um Double e um Boolean. Comente cada linha explicando o que ela faz. Mostre também um exemplo de erro ao tentar colocar texto em uma variável numérica. Escreva para um iniciante absoluto.

1.5 Interpolação de strings: misturando variáveis e texto

Prefere assistir ao video? Assista o video desta lição

Você já sabe imprimir texto. Já sabe guardar valores em variáveis. Agora é hora de juntar as duas coisas e montar frases com valores que mudam.

Em Kotlin, isso se chama string interpolation ou string templates. Na prática, você usa um cifrão dentro da string para inserir o valor de uma variável no meio do texto.

O problema que isso resolve

Sem interpolação, você teria que juntar texto e valor com uma técnica mais manual: 

val pontuacao = 150
println("Sua pontuação é " + pontuacao)

Isso funciona, mas fica menos elegante quando a frase cresce. Com interpolação, o código fica mais limpo e mais fácil de ler.

Interpolação de strings: use `$` dentro da string

Para mostrar o valor de uma variável dentro de uma frase, escreva o nome dela depois do cifrão: 

val pontuacao = 150
val nomeJogador = "Ana"

println("Sua pontuação é $pontuacao")
println("Bom trabalho, $nomeJogador!")
println("$nomeJogador tem $pontuacao pontos.")

Regra rápida: se for só o nome da variável, use $variavel. Se precisar de uma expressão ou de mais controle, use ${ }.

Você pode colocar expressões dentro de `${ }`

Não precisa limitar a interpolação ao nome de variáveis. Você também pode colocar cálculos e combinações de valores dentro das chaves. 

val itens = 3
val precoPorItem = 4.99

println("Total: R$${itens * precoPorItem}")

val primeiroNome = "João"
val sobrenome = "Silva"
println("Nome completo: ${primeiroNome} ${sobrenome}")

val contaPremium = true
println("Conta premium: $contaPremium")

Observação importante: Se você não quiser aplicar a interpolação e realmente imprimir o símbolo $ e depois o nome da variável, use \$ para que o Kotlin não aplique a interpolação.

Exemplo: 

val dolar = 4.99
println("Dólar: \$dolar $dolar")

Dólar: $dolar 4.99

O que acontece em cada caso

Sintaxe O que faz
$pontuacao Insere o valor de uma variável simples
$nomeJogador Insere o valor de uma String dentro da frase
${primeiroNome} ${sobrenome} Junta duas variáveis com um espaço no meio
${itens * precoPorItem} Calcula o valor primeiro e depois insere o resultado
\$ Mostra o símbolo de cifrão como texto normal

Um erro comum: esquecer as chaves

Se você colocar uma expressão mais complexa sem ${ }, o Kotlin não vai entender do jeito certo. Use chaves sempre que a parte dentro do texto não for só o nome de uma variável. 

val itens = 3
val precoPorItem = 4.99

// Correto
println("Total: R$${itens * precoPorItem}")

// Também correto para nomes simples
println("Itens: $itens")

❗Desafio da Aula

Crie um pequeno programa Kotlin para representar um usuário em um app. Você precisa guardar:

  • o nome
  • o nível atual
  • a quantidade de moedas
  • se as notificações estão ativadas

Depois, use interpolação de strings para imprimir uma mensagem de boas-vindas natural, como algo que um app realmente mostraria. O texto final deve ler como uma frase, não como uma lista de valores.

Exemplo de saída: 

Bem-vindo de volta, Ana! Você está no nível 7 com 320 moedas. Notificações ativadas: true.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Acabei de aprender interpolação de strings em Kotlin. Me faça perguntas, uma de cada vez, para eu descobrir quando devo usar $variavel e quando devo usar ${ }. Se eu errar, explique o motivo.

Interpolação no código

Prompt #2:

Em Kotlin, por que interpolação de strings é melhor do que concatenar texto com + em muitos casos? Explique com exemplos simples e focados em leitura de código.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo curto em Kotlin mostrando interpolação de strings com uma String, um Int, um Double e um Boolean. Mostre também um exemplo com uma expressão dentro de ${ }. Comente cada linha explicando o que ela faz. Escreva para um iniciante absoluto.

Etapa 2: Tomando Decisões

Agora que você já sabe imprimir valores, usar variáveis e entender os tipos básicos, chegou a hora de ensinar o Kotlin a tomar decisões.

Na prática, isso começa com uma pergunta simples: um valor é maior que o outro? Dois textos são iguais? Um número passou de um limite? Quando você aprende a responder esse tipo de pergunta, você abre a porta para escrever código que reage ao mundo real e toma decisões com base no usuário.

Nesta etapa, você vai aprender a comparar valores e descobrir o que o Kotlin devolve quando faz essas comparações. O resultado quase sempre será um Boolean, ou seja, true ou false.

2.1 Operadores de comparação

Prefere assistir ao video? Assista o video desta lição

Antes do seu código conseguir decidir qualquer coisa, ele precisa conseguir comparar valores.

Pense em um segurança conferindo um documento. Ele olha a idade da pessoa, compara com a idade mínima permitida e decide se a resposta é sim ou não. O seu código faz a mesma coisa: compara dois valores e devolve um resultado lógico.

Em Kotlin, esse resultado é um Boolean. Você já viu esse tipo antes na Etapa 1. Agora vai entender de onde ele aparece de verdade. 

val minhaIdade = 20
val idadeMinima = 18

val idadeSuficiente = minhaIdade >= idadeMinima
println(idadeSuficiente)

val souIgual = minhaIdade == idadeMinima
println(souIgual)

val maisNovo = minhaIdade < idadeMinima
println(maisNovo)

Resultado: 

true
false
false
Expressão O que ela faz
minhaIdade >= idadeMinima Verifica se 20 é maior ou igual a 18. Como é, o resultado é true.
minhaIdade == idadeMinima Verifica se 20 é exatamente igual a 18. Não é, então o resultado é false.
minhaIdade < idadeMinima Verifica se 20 é menor que 18. Não é, então o resultado é false.
idadeSuficiente Guarda o resultado de uma comparação. Em Kotlin, comparações sempre retornam Boolean.

Os seis operadores de comparação

Kotlin tem seis operadores principais para comparar valores: 

println(5 == 5)             // true
println(5 != 6)             // true
println(3 < 10)             // true
println(10 > 3)             // true
println(3 <= 5)             // true
println(5 >= 5)             // true

Resultado: 

true
true
true
true
true
true
Operador O que ele verifica
== Dois valores são exatamente iguais?
!= Dois valores são diferentes?
< O valor da esquerda é menor que o da direita?
> O valor da esquerda é maior que o da direita?
<= O valor da esquerda é menor ou igual ao da direita?
>= O valor da esquerda é maior ou igual ao da direita?

Dica de memória: a abertura do símbolo sempre aponta para o número menor.

Em 3 < 10, a abertura do operador fica virada para o 3, que é o menor valor. Em 10 > 3, a abertura também aponta para o 3, porque ele continua sendo o menor.

O operador de negação.

Se você tiver um Boolean e quiser inverter a forma com que você lida com o valor, você pode negar a operação.

Por exemplo, ao invés de falar, souNovo, você quer falar, naoSouNovo.

Então você faria: 

val souNovo = minhaIdade < idadeMinima
println(souNovo)

val naoSouNovo = !souNovo
println(naoSouNovo)

O sinal ! inverte um Boolean. Então se ele é verdadeiro o resultado é falso e se ele é falso o resultado é verdadeiro.

Um erro muito comum: x = y não é comparação

Em Kotlin, um sinal de igual sozinho (=) serve para atribuir um valor.

Dois sinais de igual (==) servem para comparar dois valores. 

val idade = 20
val maiorDeIdade = idade >= 18

println(maiorDeIdade)   // true

Se você tentar escrever algo como idade = 18 em um lugar onde o Kotlin espera uma comparação, vai acabar trocando o valor em vez de testar se ele é igual.

Resumo rápido:

  • = atribui
  • == compara

Comparando textos também funciona

Os operadores de igualdade também funcionam com String. 

println("Kotlin" == "Kotlin")   // true
println("Kotlin" == "kotlin")   // false
println("casa" != "carro")      // true

Isso acontece porque Kotlin é sensível a maiúsculas e minúsculas. "Kotlin" e "kotlin" são textos diferentes.

Quando isso começa a ser útil?

Comparações aparecem o tempo todo em programas reais:

  • verificar se a senha tem tamanho suficiente
  • confirmar se um saldo passou de um limite
  • descobrir se uma idade permite acesso
  • comparar notas, preços, quantidades e status

Se algo precisa virar sim ou não, comparação é quase sempre o primeiro passo.

❗Desafio da Aula

Imagine que você está criando um sistema simples de login.

O usuário digitou uma senha, e você precisa descobrir:

  • Se a senha está correta
  • Como inverter um Boolean usando !

Regras do exercício

  • Crie uma variável chamada senhaCorreta com o valor "kotlin123".
  • Crie uma variável chamada senhaDigitada com algum valor qualquer (teste tanto correto quanto errado).
  • Compare as duas senhas e guarde o resultado em uma variável senhaValida.
  • Crie uma variável chamada senhaInvalida usando negação (!).

  • Imprima todos os resultados no terminal.

    Possíveis saídas esperadas:

    SUCESSO: 

    Senha é valida: true
A senha digita é kotlin123
A senha é invalida: false

    FALHA: 

    Senha é valida: false
A senha digita é kotlin1234
A senha é invalida: true

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique em português simples o que os operadores de comparação fazem em Kotlin. Use uma analogia do mundo real e depois me faça perguntas uma por uma para eu praticar.

Prompt #2:

Qual é a diferença entre = e == em Kotlin? Explique como se eu estivesse confundindo os dois pela primeira vez.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo curto em Kotlin usando todos os seis operadores de comparação ==, !=, <, >, <=, >= em um cenário realista. Comente cada linha explicando o que ela faz para um iniciante absoluto.

2.2 if / else if / else

Prefere assistir ao video? Assista o video desta lição

Agora que você já consegue comparar valores e obter um resultado true ou false, precisa de uma forma de agir com base nesse resultado. É exatamente isso que um bloco if faz. Ele permite que o código siga caminhos diferentes dependendo de uma condição.

Pense em um semáforo. Quando o sinal está verde, os carros andam. Quando está amarelo, eles reduzem a velocidade. Quando está vermelho, eles param. Cada cor dispara uma ação diferente. Um bloco if funciona do mesmo jeito: se a condição for verdadeira, faça uma coisa; senão, faça outra.

Essa é uma das ideias mais importantes de toda a programação. Todo aplicativo usa if o tempo todo para verificar se você está logado, se um formulário foi preenchido, se uma nota é suficiente ou se um preço passou de um limite. Quando você entende isso, começa a escrever código que realmente responde ao que acontece. 

val nota = 75            // A nota de um aluno, de 0 a 100

if (nota >= 90) {        // Verifica se a nota é 90 ou maior
    println("A")         // Só executa quando a condição acima é verdadeira
} else if (nota >= 80) { // Só é verificado se a primeira condição for falsa
    println("B")         // Executa quando a nota está entre 80 e 89
} else if (nota >= 70) { // Só é verificado se as anteriores forem falsas
    println("C")         // 75 cai aqui, então este bloco executa
} else {                 // Executa quando nenhuma condição anterior for verdadeira
    println("F")         // Cobre qualquer nota abaixo de 70
}

Resultado: 

Conceito: C
Parte O que ela faz
if (nota >= 90) { } A primeira condição que o Kotlin verifica. Se for verdadeira, o código dentro das chaves executa e o restante é ignorado.
else if (nota >= 80) { } Só é avaliado se a primeira condição for falsa. Você pode encadear quantos else if precisar.
else { } A rede de segurança. Executa quando nenhuma outra condição correspondeu. Não é obrigatório, mas costuma ser uma boa prática.
As chaves { } Tudo entre { e } pertence àquela condição. Esse conjunto de linhas é chamado de bloco.

Comportamento-chave: o Kotlin para de verificar assim que encontra a primeira condição verdadeira. No exemplo acima, quando nota >= 70 é verdadeira, o bloco else é ignorado completamente. Apenas um ramo executa por vez, mesmo que mais de uma condição possa ser verdadeira.

As Três Formas de um if

val estaChovendo = true

if (estaChovendo) {                       // Um Boolean já é verdadeiro ou falso, sem precisar de == true
    println("Não esqueça o guarda-chuva!") // Só executa quando estaChovendo é true
}
// Se estaChovendo fosse false, nada seria impresso, e tudo bem

O formato mais simples. Não precisa de else se você só quer agir quando a condição for verdadeira. Repare que você não escreve estaChovendo == true - um Boolean pode ser usado diretamente. 

val estaLogado = false

if (estaLogado) {
    println("Bem-vindo de volta!")   // Executa quando estaLogado é true
} else {
    println("Por favor, entre.")     // Executa quando estaLogado é false
}

Exatamente um dos dois blocos sempre executa. É perfeito para decisões binárias: logado ou não, dia ou noite, aprovado ou reprovado. 

val hora = 14                        // 14h no formato de 24 horas

if (hora < 12) {
    println("Bom dia!")              // Horas de 0 a 11
} else if (hora < 18) {
    println("Boa tarde!")            // Horas de 12 a 17 - 14 entra aqui
} else {
    println("Boa noite!")            // Horas de 18 em diante
}

Adicione quantos else if quiser. O Kotlin verifica de cima para baixo e para no primeiro caso verdadeiro. 

val temIngresso = true
val idade = 16

if (temIngresso) {                     // Primeira verificação: a pessoa tem ingresso?
    if (idade >= 18) {                 // Segunda verificação - só acontece se tiver ingresso
        println("Aproveite o show!")
    } else {
        println("Desculpe, apenas maiores de idade.") // Tem ingresso, mas é menor de 18
    }
} else {
    println("Sem ingresso, sem entrada.")
}

Você pode aninhar blocos if dentro de outros if. O importante é manter a indentação clara para identificar a qual bloco cada } pertence. Em seguida, você verá uma forma mais limpa de lidar com várias condições ao mesmo tempo usando operadores lógicos.

Dica de indentação

O editor geralmente ajusta a indentação quando você pressiona Enter depois de abrir uma chave. Se a estrutura parecer bagunçada, selecione o código e reindente tudo. Uma indentação consistente facilita encontrar bugs.

❗Desafio da Aula

Crie um programa que mostre uma mensagem diferente com base na temperatura.

Regras do exercício

  • Crie uma variável chamada temperaturaC com a temperatura de hoje em Celsius.
  • Escreva uma cadeia if / else if / else que imprima mensagens diferentes:
    • abaixo de 0: "Congelando! Se agasalhe."
    • de 0 a 14: "Frio. Pegue um casaco."
    • de 15 a 25: "Clima agradável hoje!"
    • acima de 25: "Muito quente! Beba água."
  • Teste alterando o valor e executando novamente.

Dica: você vai precisar de quatro ramos. Comece do mais frio para o mais quente, de cima para baixo. O Kotlin para no primeiro teste verdadeiro, então a ordem das verificações importa.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique em português simples o que um bloco if faz em Kotlin. Use um exemplo do mundo real e depois me faça perguntas uma por uma para eu praticar.

Prompt #2:

Qual é a diferença entre escrever vários if separados e usar uma cadeia if / else if / else em Kotlin? Explique primeiro o conceito, antes de mostrar código.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo em Kotlin usando if, if / else e if / else if / else em um cenário realista, como mostrar mensagens com base em pontuação ou desconto. Comente cada linha explicando o que ela faz para um iniciante absoluto.

2.3 Operadores lógicos (&& || !)

Prefere assistir ao video? Assista o video desta lição

Até agora você verificou uma condição por vez. Mas decisões reais geralmente envolvem mais de uma coisa. "Você pode assistir a este filme se tiver 18 anos ou mais E tiver uma assinatura." "Você ganha desconto se for seu aniversário OU se você for membro." Esses são exemplos de várias condições combinadas em uma única decisão.

O Kotlin oferece três operadores lógicos para isso. && significa E, || significa OU, e ! significa NÃO. Eles permitem combinar ou inverter valores Boolean para expressar condições mais complexas sem precisar aninhar vários blocos if dentro de outros blocos if.

A boa notícia é que esses operadores funcionam como as palavras "e", "ou" e "não". Quando você faz essa conexão, eles ficam muito mais naturais de ler e escrever. 

val idade = 20                         // A idade do usuário
val temAssinatura = true               // Se ele tem uma assinatura ativa
val aniversario = false              // Se hoje é o aniversário dele

// E: as duas condições precisam ser verdadeiras
if (idade >= 18 && temAssinatura) {
    println("Aproveite o conteúdo!")   // Executa: as duas condições são true
}

// OU: pelo menos uma condição precisa ser verdadeira
if (temAssinatura || aniversario) {
    println("Você ganhou um bônus!")   // Executa: temAssinatura é true
}

// NÃO: inverte um Boolean de true para false, ou de false para true
if (!aniversario) {
    println("Sem bônus de aniversário hoje.") // Executa: !false vira true
}

Resultado: 

Aproveite o conteúdo!
Você ganhou um bônus!
Sem bônus de aniversário hoje.
Operador O que significa
&& (E) Os dois lados precisam ser true para o resultado ser true. Se qualquer lado for false, a condição inteira vira false.
II (OU) Pelo menos um lado precisa ser true. A condição inteira só vira false quando os dois lados são false.
! (NÃO) Inverte um Boolean. !true vira false. !false vira true. Coloque diretamente antes do Boolean.

&&: E - todas as condições precisam passar

val temDocumento = true
val estaNaLista = false

if (temDocumento && estaNaLista) {          // Os dois precisam ser true
    println("Pode entrar!")
} else {
    println("Desculpe, você precisa dos dois.") // Executa: estaNaLista é false
}

Com &&, um único valor falso já é suficiente para tornar a condição inteira falsa. Isso substitui o padrão de if aninhado da aula 2.2 por uma escrita mais limpa e mais próxima da linguagem natural.

||: OU - qualquer condição verdadeira é suficiente

val estudante = false
val idoso = true

if (estudante || idoso) {              // Pelo menos um precisa ser true
    println("Ingresso com desconto!")      // Executa: idoso é true
} else {
    println("Preço cheio.")
}

Com ||, a condição só falha quando todas as partes são falsas. Mesmo que dez coisas sejam falsas, uma única parte verdadeira faz a condição inteira ser verdadeira.

!: NÃO - inverte o valor Boolean

var jogoAcabou = false

if (!jogoAcabou) {                         // Leia: "se NÃO jogoAcabou"
    println("Continue jogando!")           // !false vira true, então executa
}

Coloque ! diretamente antes de um Boolean: !jogoAcabou. Muitas vezes isso fica mais limpo do que escrever jogoAcabou == false.

Combinando operadores com parênteses

val fimDeSemana = true
val temTarefas = false
val amigosDisponiveis = true

// Pode sair se: é fim de semana E (não tem tarefas OU os amigos estão livres)
if (fimDeSemana && (!temTarefas || amigosDisponiveis)) {
    println("Vamos sair!")                 // Executa: todas as condições foram satisfeitas
}

Use parênteses para agrupar condições quando misturar operadores. A parte entre parênteses é avaliada primeiro, como na matemática. Sem parênteses, && tem prioridade maior que ||, mas os parênteses deixam sua intenção explícita e tornam o código mais fácil de ler.

Atenção ao !: escreva !jogoAcabou. O operador ! deve ficar diretamente antes do valor que ele está invertendo.

Priorize legibilidade

Se uma condição estiver ficando longa e difícil de acompanhar, divida em constantes Boolean com nomes claros. 

val idade = 19
val temIngresso = true
val podeEntrar = idade >= 18 && temIngresso

if (podeEntrar) {
    println("Entrada liberada.")
}

A lógica é a mesma, mas if (podeEntrar) é muito mais fácil de entender de relance.

❗Desafio da Aula

Crie um programa que verifique se uma pessoa pode ir em um brinquedo de parque.

Regras do exercício

  • O brinquedo tem duas regras:
    • a pessoa precisa ter pelo menos 120 cm de altura;
    • a pessoa não pode ter medo de altura.
  • Crie uma variável alturaCm do tipo Int.
  • Crie uma variável temMedoDeAltura do tipo Boolean.
  • Escreva um if / else que imprima "Aproveite o brinquedo!" quando os dois requisitos forem atendidos.
  • Se não puder ir, imprima uma mensagem específica explicando qual requisito não foi atendido.
  • Tente mostrar uma mensagem diferente para cada cenário de falha.

Dica: para verificar se a pessoa pode ir, você vai combinar && e !. Para as mensagens de falha, pense em usar ramos else if verificando cada condição individualmente.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique os operadores &&, || e ! em Kotlin usando uma analogia que não envolva programação, como entrar em um parque, conseguir um desconto ou passar por uma verificação. Depois me faça cinco perguntas de verdadeiro ou falso, uma por vez, para eu descobrir o resultado de combinar dois Booleans.

Prompt #2:

Explique o que é avaliação de curto-circuito em Kotlin. Quero entender por que às vezes o Kotlin nem verifica a segunda condição. Explique o conceito em português simples antes de mostrar qualquer código.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo em Kotlin que use &&, || e ! juntos em um cenário realista de aplicativo, como verificar se um usuário pode acessar conteúdo premium ou se uma compra deve receber desconto. Use os três operadores pelo menos uma vez e comente cada linha explicando a lógica para um iniciante.

2.4 Expressões com when

Prefere assistir ao video? Assista o video desta lição

Até agora você usou if / else if / else para lidar com várias condições. Isso funciona muito bem, mas quando você está verificando um valor específico contra uma lista de possibilidades, o Kotlin oferece uma opção mais limpa: when.

Pense em uma máquina de salgadinhos. Você digita A1 e recebe batata. Digita B2 e recebe uma bebida. Digita C3 e recebe chocolate. A máquina não precisa explicar uma condição gigante para cada possibilidade; ela olha para o código digitado e escolhe a resposta correspondente. O when funciona com essa mesma ideia.

Em outras linguagens, você talvez veja algo chamado switch. Em Kotlin, o equivalente moderno é when. Ele consegue comparar valores exatos, agrupar várias opções, testar intervalos e até retornar um valor. 

val dia = "segunda"                    // O valor que queremos verificar

when (dia) {                           // Começa o when usando a variável dia
    "segunda" -> {
        println("De volta aos estudos.") // Executa: dia é "segunda"
    }
    "sexta" -> {
        println("Quase fim de semana!")
    }
    "sábado", "domingo" -> {           // Dois valores podem compartilhar o mesmo bloco
        println("Aproveite o fim de semana!")
    }
    else -> {                          // Cobre qualquer valor que não apareceu acima
        println("Mais um dia comum.")
    }
}

Resultado: 

De volta aos estudos.
Parte O que ela faz
when (dia) { } Diz ao Kotlin qual valor será comparado.
"segunda" -> { } Se dia for igual a "segunda", o bloco depois da seta executa.
"sábado", "domingo" -> { } Permite agrupar vários valores que devem produzir a mesma resposta.
else -> { } Funciona como o else do if. Executa quando nenhum caso anterior combina.

Diferença importante: em Kotlin, você não precisa escrever break no final de cada caso. Quando um ramo do when executa, o Kotlin não continua executando os próximos ramos automaticamente.

Usando vários valores no mesmo ramo

Se várias opções devem fazer a mesma coisa, separe os valores por vírgula. 

val mes = 2

when (mes) {
    1, 2, 3 -> {
        println("Começo do ano")       // Executa: mes é 2
    }
    4, 5, 6 -> {
        println("Meio do primeiro semestre")
    }
    7, 8, 9 -> {
        println("Segundo semestre começou")
    }
    10, 11, 12 -> {
        println("Fim do ano chegando")
    }
    else -> {
        println("Mês inválido")
    }
}

Isso evita repetir o mesmo println várias vezes. Um único ramo cobre todas as opções que têm o mesmo significado para o programa.

Verificando intervalos com in

O when também consegue testar se um número está dentro de um intervalo usando in. 

val nota = 83

when (nota) {
    in 90..100 -> {
        println("Conceito: A")
    }
    in 80..89 -> {
        println("Conceito: B")         // Executa: 83 está entre 80 e 89
    }
    in 70..79 -> {
        println("Conceito: C")
    }
    in 0..69 -> {
        println("Conceito: F")
    }
    else -> {
        println("Nota inválida")
    }
}

O intervalo 80..89 significa "de 80 até 89, incluindo os dois números". Para classificações, faixas de preço, idade, nível ou pontuação, isso costuma ficar mais legível do que uma longa cadeia de else if.

Usando when como expressão

Uma das partes mais úteis do when é que ele pode devolver um valor. Em vez de apenas executar um println, você pode guardar o resultado em uma variável. 

val codigo = "B2"

val produto = when (codigo) {
    "A1" -> "Batata"
    "B2" -> "Refrigerante"             // Executa: produto recebe "Refrigerante"
    "C3" -> "Chocolate"
    else -> "Produto desconhecido"
}

println(produto)

Resultado: 

Refrigerante

Quando você usa when para preencher uma variável, o Kotlin precisa garantir que sempre haverá algum resultado. Por isso, o ramo else é importante quando nem todas as possibilidades foram cobertas.

when sem valor inicial

Você também pode usar when sem colocar uma variável entre parênteses. Nesse formato, cada ramo vira uma condição completa, parecido com if / else if. 

val temperatura = -5

when {
    temperatura < 0 -> {
        println("Congelando: $temperatura graus") // Executa: -5 é menor que 0
    }
    temperatura > 30 -> {
        println("Muito quente: $temperatura graus")
    }
    else -> {
        println("Temperatura agradável: $temperatura graus")
    }
}

Use esse formato quando você não está apenas comparando um valor contra opções fixas, mas quer escrever condições mais abertas.

when vs if: quando usar cada um?

Use when quando você está olhando para uma variável e escolhendo entre várias possibilidades claras: dia da semana, código de produto, status de pedido, nota, mês, tipo de usuário.

Use if quando a decisão envolve poucas condições, variáveis diferentes ou uma lógica mais livre.

Os dois podem resolver muitos dos mesmos problemas. A melhor escolha é a que deixa o código mais fácil de ler.

❗Desafio da Aula

Crie um programa que mostre uma curiosidade de gravidade para planetas do sistema solar.

Regras do exercício

  • Crie uma variável chamada planeta do tipo String.
  • Use when para imprimir uma curiosidade de gravidade para pelo menos cinco planetas.
  • Exemplo: "Marte: cerca de 0.38x a gravidade da Terra".
  • Agrupe dois planetas no mesmo ramo usando vírgula.
  • Inclua um ramo else que imprima "Planeta desconhecido".

Dica: cada ramo compara uma String. Para listar dois valores no mesmo ramo, escreva algo como "Mercúrio", "Marte" -> { ... }.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique o when em Kotlin para um iniciante. Quero entender como ele se compara com uma cadeia if / else if / else e por que ele pode deixar o código mais legível. Use uma analogia do mundo real antes de mostrar código.

Prompt #2:

Mostre um exemplo de when em Kotlin com um erro simples, como esquecer o else em uma expressão, usar um intervalo errado ou agrupar valores de forma incorreta. Peça para eu identificar o problema antes de explicar a resposta.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo em Kotlin usando when que demonstre três recursos: comparação com valores exatos, vários valores no mesmo ramo e intervalo com in. Use um cenário realista, como menu de restaurante, dificuldade de jogo ou status de entrega. Comente cada linha explicando o que ela faz para um iniciante absoluto.

Etapa 3: Repetindo Coisas

Os programas raramente fazem algo apenas uma vez. Os aplicativos reais percorrem listas, repetem ações e processam conjuntos de dados. Nesta etapa, você aprenderá como fazer seu código se repetir e como decidir qual tipo de repetição se adequa à situação.

3.1 for loop

Prefere assistir ao video? Assista o video desta lição

Imagine que você precisasse escrever println("Olá!") dez vezes seguidas. Você até conseguiria, mas seria tedioso e sem sentido. Exatamente esse tipo de problema é o que um loop resolve.

Um for loop executa um bloco de código um número definido de vezes. Pense em um contador de voltas numa pista de corrida: você decide quantas voltas, o corredor corre, e o contador acompanha para você não precisar fazer isso.

Em Kotlin, você diz ao for loop quantas vezes executar dando a ele um range (intervalo), um número inicial e um número final. Veja a versão mais simples: 

for (i in 1..5) {          // executa para i = 1, 2, 3, 4, 5
    println("Volta $i")   // imprime o número da volta atual com interpolação de string
}

Resultado: 

Volta 1
Volta 2
Volta 3
Volta 4
Volta 5
PARTE O QUE ELA FAZ
for A palavra-chave que inicia um for loop. O Kotlin entende que repetição está por vir.
i Uma variável temporária que guarda o valor atual da contagem. Ela recebe um novo valor automaticamente a cada repetição. Você pode nomear como quiser, numero, contagem, volta, o que fizer sentido.
in Conecta a variável ao range. Leia o conjunto como: "para cada valor de i, no intervalo de 1 a 5…"
1..5 O operador de range fechado. Significa "todo número de 1 até 5, incluindo o 5". Os dois pontos são o operador de range.
{ } O corpo do loop. Tudo dentro dessas chaves executa uma vez para cada número do range.
println("Volta $i") Usa interpolação de string para imprimir o valor atual de i. Na primeira volta i é 1, depois 2, e assim por diante.

Erro comum: iniciantes às vezes escrevem for (i in 1..5) e depois tentam usar i depois da chave de fechamento. Isso não funciona, i só existe dentro do loop. Quando o loop termina, ela desaparece.

Os dois operadores de range

Kotlin tem duas formas de escrever um range, e elas diferem em um ponto importante: se o último número é incluído ou não.

1..10 — Range fechado — inclui o último número 

for (i in 1..10) {
    println(i) // imprime 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
}

O operador de dois pontos (..) cria um range fechado. O loop executa para todo número de 1 até incluindo 10. Use quando quiser incluir o valor final.

1 until 10 — Range semi-aberto — exclui o último número 

for (i in 1 until 10) {
    println(i) // imprime 1, 2, 3, 4, 5, 6, 7, 8, 9 — para antes do 10
}

A palavra-chave until cria um range semi-aberto. O loop executa até, mas não incluindo, o último número. É muito comum no desenvolvimento Android porque listas começam no índice 0.

_ no lugar da variável — quando você não precisa do valor 

for (_ in 1..3) {
    println("Olá!") // imprime "Olá!" exatamente 3 vezes
}

Se você só quer executar um bloco de código um certo número de vezes e não precisa do valor atual da contagem, use _ no lugar do nome da variável. O Kotlin entende isso como "sei que há um valor aqui, mas não preciso dele".

step — contar em passos personalizados ou contar para trás 

// Contar de 2 em 2: 0, 2, 4, 6, 8, 10
for (i in 0..10 step 2) {
    println(i)
}

// Contar para trás: 10, 8, 6, 4, 2, 0
for (i in 10 downTo 0 step 2) {
    println(i)
}

Quando precisar contar em passos diferentes de 1, use step. Para contar de forma decrescente, use downTo. A palavra-chave downTo cria um range que vai do maior para o menor.

Vale saber: o nome i é uma convenção de programação abreviação de "index" (índice) ou "iteration" (iteração). Você vai ver em todo lugar. Mas é só um nome de variável comum, fique à vontade para usar algo mais descritivo como dia ou pontuacao quando isso tornar o código mais fácil de ler.

❗Desafio da Aula

Escreva um for loop que imprima a tabuada do 7, de 7 x 1 até 7 x 12. Cada linha deve ficar assim: 

7 x 1 = 7

Depois tente um bônus: use um loop com step para imprimir apenas os múltiplos pares do 7 (7 x 2, 7 x 4, 7 x 6, e assim por diante até 7 x 12).

Dica: use interpolação de string dentro do seu println. Você pode fazer contas diretamente dentro de ${ } — por exemplo, ${7 * i} te dá o resultado de 7 vezes i.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique a diferença entre o operador de range fechado (1..10) e o range semi-aberto com until (1 until 10) em Kotlin. Dê uma analogia do mundo real para cada um que não envolva programação. Depois me faça uma pergunta para verificar meu entendimento.

Prompt #2:

Estou aprendendo for loops em Kotlin e quero ter certeza de que realmente entendi. Sem escrever nenhum código para mim, você pode me fazer 3 perguntas sobre for loops — uma de cada vez — e me dizer se acertei ou errei antes de continuar?

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo de for loop em Kotlin que conta de 10 para 1 e depois imprime "Decolar!" no final. Adicione um comentário em cada linha explicando o que ela faz e por quê — escreva os comentários para um iniciante absoluto que nunca viu um loop antes.

3.3 while loop

Prefere assistir ao video? Assista o video desta lição

Um for loop é ótimo quando você sabe de antemão quantas vezes quer repetir algo. Mas e quando você não sabe? E se você quiser continuar até que algo mude?

Esse é o papel do while loop. Pense em uma máquina de refrigerante. Ela continua aceitando moedas enquanto o saldo for menor que o preço do item. Ela não sabe de antemão quantas moedas você vai colocar — ela só verifica a cada vez e para quando a condição é satisfeita. 

var moedas = 0      // começa com 0 moedas
val preco = 5       // o item custa 5 moedas

while (moedas < preco) {    // continua enquanto não tiver moedas suficientes
    moedas += 1             // adiciona uma moeda a cada vez
    println("Moedas inseridas: $moedas")
}

println("Comprando!")       // isso executa depois que o loop termina

Resultado: 

Moedas inseridas: 1
Moedas inseridas: 2
Moedas inseridas: 3
Moedas inseridas: 4
Moedas inseridas: 5
Comprando!
PARTE O QUE ELA FAZ
while A palavra-chave que inicia um while loop. O Kotlin continua repetindo o corpo do loop enquanto a condição for verdadeira.
moedas < preco A condição. O Kotlin verifica isso antes de cada passagem. No momento em que se torna falsa (moedas igual a 5), o loop para imediatamente.
moedas += 1 É o que muda a condição. Cada passagem adiciona 1 a moedas, então eventualmente a condição se tornará falsa. Sem essa linha, você teria um loop infinito.
Código após o } Executa uma vez depois que o loop termina. O loop precisa terminar antes do Kotlin continuar para a próxima instrução.

Zona de perigo — loops infinitos: se a condição em um while loop nunca se tornar falsa, o loop executa para sempre e seu app trava. Isso se chama loop infinito. Sempre certifique-se de que algo dentro do loop eventualmente muda a condição. No exemplo acima, moedas += 1 é o que eventualmente torna moedas < preco falso.

Variações do while loop

do-while — sempre executa pelo menos uma vez antes de verificar a condição 

var tentativas = 0

do {
    tentativas += 1
    println("Tentativa $tentativas")
} while (tentativas < 3)    // a condição é verificada APÓS cada execução

Um loop do-while é como um while loop, mas a condição é verificada no final em vez do início. Isso garante que o corpo do loop execute pelo menos uma vez, mesmo que a condição comece falsa. Use quando quiser garantir pelo menos uma tentativa — como exibir uma caixa de diálogo ou fazer uma primeira requisição de rede.

while com variável Boolean — use um flag para controlar o loop de qualquer lugar dentro dele 

var emExecucao = true   // este Boolean controla o loop
var contador = 0

while (emExecucao) {
    contador += 1
    println("Contagem: $contador")
    if (contador == 4) {
        emExecucao = false  // vira o flag para parar o loop
    }
}

Usar uma variável Boolean como "flag" de condição dá um controle claro e legível. Quando a situação que deve parar o loop ocorrer, vire o flag para false. Isso é especialmente útil quando a condição de parada pode ocorrer em lugares diferentes dentro do corpo do loop.

Quando usar while vs for: use um for loop quando você conhece a contagem exata ou tem uma coleção para percorrer. Use um while loop quando o ponto de parada depende de algo que muda enquanto o loop executa — como entrada do usuário, um estado de jogo ou uma resposta de rede chegando.

❗Desafio da Aula

Você quer economizar R$ 500. Você começa com R$ 0 e adiciona R$ 75 a cada semana. Escreva um while loop que imprima seu saldo de poupança ao final de cada semana e pare quando atingir ou ultrapassar R$ 500. Ao final, imprima também quantas semanas levou.

Bônus: tente a mesma coisa usando um loop do-while e veja se a saída é diferente.

Dica: você vai precisar de duas variáveis — uma para o saldo atual e outra para contar as semanas. A variável de saldo precisa ser var porque muda. Pense se sua condição deve ser saldo < 500 ou saldo <= 500 e qual diferença isso faz.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Explique a diferença entre um while loop e um do-while loop em Kotlin usando uma analogia do mundo real — algo que não envolva código. Depois me diga uma situação específica onde você escolheria do-while em vez de while e explique o porquê.

Prompt #2:

Quero entender o que torna um while loop diferente de um for loop em nível conceitual — não apenas sintaticamente. Quando um desenvolvedor experiente usaria um while loop em vez de um for loop? Me dê 3 cenários em português simples antes de mostrar qualquer código.

Crie um exemplo para praticar

Prompt #3:

Escreva um while loop em Kotlin que simule um jogo de adivinhação onde o "jogador" continua chutando até acertar o número correto. Use valores fixos, não números aleatórios reais — só faça parecer uma simulação. Adicione um comentário em cada linha para um iniciante.

3.4 break e continue

Prefere assistir ao video? Assista o video desta lição

Loops nem sempre precisam executar perfeitamente do início ao fim. Às vezes você encontra uma situação em que quer parar o loop inteiro antes da hora. Outras vezes você quer pular apenas uma passagem, mas continuar executando. O Kotlin te dá duas palavras-chave para isso: break e continue.

Pense numa esteira de uma fábrica. continue é como dizer "pula esse item com defeito, mas mantém a esteira funcionando". break é como apertar o botão de parada de emergência — a esteira inteira para imediatamente. 

// break: para o loop no momento em que encontramos o que precisamos
val alvo = 7

for (numero in 1..10) {
    println("Verificando: $numero")
    if (numero == alvo) {
        println("Encontrei!")
        break    // para o loop inteiro aqui mesmo
    }
}

Resultado: 

Verificando: 1
Verificando: 2
Verificando: 3
Verificando: 4
Verificando: 5
Verificando: 6
Verificando: 7
Encontrei!

Note que o loop nunca chegou a verificar 8, 9 ou 10 — o break parou tudo no momento em que encontramos o que procurávamos.

Agora veja o continue — ele pula o restante da passagem atual e vai direto para a próxima: 

// continue: pula números pares, processa só os ímpares
for (numero in 1..10) {
    if (numero % 2 == 0) {
        continue    // pula este número e vai para o próximo
    }
    println("Ímpar: $numero")
}

Resultado: 

Ímpar: 1
Ímpar: 3
Ímpar: 5
Ímpar: 7
Ímpar: 9
PALAVRA-CHAVE O QUE ELA FAZ
break Sai imediatamente do loop inteiro. O código depois da chave de fechamento do loop continua executando normalmente, mas o loop em si terminou — nenhuma passagem adicional acontece.
continue Pula apenas o restante da passagem atual do loop. O loop em si continua executando — ele só vai direto para o próximo item ou próxima contagem, pulando qualquer código abaixo do continue.

Mais padrões com break e continue

break em while — sai de um while loop quando uma condição interna é satisfeita 

var energia = 100

while (true) {
    energia -= 15
    println("Energia restante: $energia")
    if (energia <= 0) {
        println("Sem energia!")
        break    // sai do loop while true
    }
}

break também funciona em while loops. Quando combinado com while true, é a única forma de parar o loop. Esse é um padrão limpo quando a lógica de parada é complexa — coloque a condição de saída onde fizer mais sentido no corpo do loop.

continue para filtrar — use continue para processar apenas valores que atendem a uma condição 

for (numero in 1..20) {
    if (numero % 3 != 0) {    // se o número não for múltiplo de 3
        continue               // pula ele
    }
    println("Múltiplo de 3: $numero")
}

continue é ótimo para filtrar — pule os valores que não te interessam e processe apenas os que importam.

break com label — saia de um loop externo específico de dentro de um loop aninhado 

loopExterno@ for (i in 1..3) {
    for (j in 1..3) {
        if (i == 2 && j == 2) {
            println("Parando tudo em ($i, $j)")
            break@loopExterno    // sai do loop externo, não só do interno
        }
        println("($i, $j)")
    }
}

Sem um label, break só sai do loop mais interno. Adicione um label (um nome seguido de @) ao loop externo e use break@nomeDoLabel para sair daquele loop específico. Isso é menos comum, mas útil em situações de loops aninhados que você vai ver na próxima lição.

Confusão comum: break sai do loop, continue pula uma passagem. Um erro muito comum é usar break quando você queria continue, o que para o loop inteiro quando você só queria pular um item. Releia a saída com cuidado quando algo parecer errado.

❗Desafio da Aula

Escreva um loop que percorra os números de 1 a 50 e:

  • Pule qualquer número que seja múltiplo de 3 usando continue (não imprima nada para ele)
  • Imprima o número para qualquer outro caso
  • Pare o loop inteiro (com break) no momento em que encontrar um número maior que 30 que também seja múltiplo de 7

Dica: verifique primeiro a condição de parada com um if e break. Depois verifique o múltiplo de 3 e use continue. Tudo que ainda estiver executando depois dessas verificações é um caso normal.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Acabei de aprender sobre break e continue em loops do Kotlin. Você pode me dar 4 cenários curtos (descritos em português simples, sem código) e me pedir para decidir em cada um se break, continue, ou nenhum dos dois seria a ferramenta certa? Me diga se acertei ou errei e explique o porquê.

Prompt #2:

Em Kotlin, o que acontece exatamente quando break é executado dentro de um loop aninhado? Ele sai de todos os loops ou só do interno? E o continue — ele pula para a próxima passagem do loop interno ou do externo? Explique com um exemplo claro antes de mostrar qualquer código.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo em Kotlin que percorre um range de números e usa tanto break quanto continue — break quando uma condição específica é satisfeita, continue para pular certos valores pelo caminho. Adicione um comentário em cada linha para um iniciante, e inclua um comentário explicando exatamente quando e por que a execução salta nas linhas de break e continue.

3.5 nested loops

Prefere assistir ao video? Assista o video desta lição

Um nested loop (loop aninhado) é simplesmente um loop dentro de outro loop. O loop externo executa uma passagem, e para cada passagem do loop externo, o loop interno inteiro executa do começo ao fim. Depois o loop externo avança para a próxima passagem, e o loop interno executa tudo de novo, do zero.

Pense num relógio. O ponteiro de minutos (loop externo) avança uma vez por hora. A cada vez que ele avança, o ponteiro de segundos (loop interno) completa um ciclo inteiro de 60 segundos. Para cada 1 passo do loop externo, o loop interno dá 60 passos. 

// Imprime uma grade simples de multiplicação (3x3)
for (linha in 1..3) {        // loop externo: linhas
    for (coluna in 1..3) {   // loop interno: colunas
        println("$linha x $coluna = ${linha * coluna}")
    }
    println("---")          // executa depois de cada loop interno completo
}

Resultado: 

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
---
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
---
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
---
PARTE O QUE ELA FAZ
for (linha in 1..3) O loop externo. Ele executa 3 vezes — para linha = 1, linha = 2 e linha = 3.
for (coluna in 1..3) O loop interno. Para cada valor de linha, esse loop inteiro executa 3 vezes — para coluna = 1, 2 e 3.
Total de iterações O loop externo executa 3 vezes. O loop interno executa 3 vezes por passagem externa. Total: 3 × 3 = 9 iterações. Com loops aninhados, o trabalho total multiplica rapidamente.
println("—") (depois do loop interno) Essa linha está dentro do loop externo, mas fora do loop interno. Ela executa apenas uma vez por passagem externa — depois que o loop interno termina para aquela linha.

Padrões práticos de loops aninhados

Percorrer uma grade — combine duas variáveis para endereçar cada posição 

// Simula verificar cada assento de um cinema (5 fileiras, 8 assentos cada)
for (fileira in 1..5) {
    for (assento in 1..8) {
        println("Fileira $fileira, Assento $assento")
    }
}
// Total: 40 iterações (5 x 8)

Loops aninhados se encaixam naturalmente em qualquer dado organizado em grade — tabuleiros de jogos, planilhas, mapas de assentos, grades de pixels. Cada posição é identificada de forma única combinando a variável do loop externo com a do loop interno.

Aviso de performance: cada camada de aninhamento multiplica o número total de iterações. Um loop de 100 dentro de outro loop de 100 executa 10.000 vezes. Adicione um terceiro loop de 100 e você chega a 1.000.000 de iterações. Isso pode deixar seu app lento ou travar. Se você se encontrar escrevendo três ou mais loops aninhados, isso é um forte sinal para parar e pensar numa abordagem diferente.

Quando não usar loops aninhados

Loops aninhados são uma ferramenta legítima, mas também são uma das formas mais fáceis de escrever código lento por acidente. Aqui está uma situação para ficar atento:

Padrão a evitar — não aninhe sem necessidade, às vezes um loop é suficiente 

// Aninhamento desnecessário — isso só adiciona complexidade sem motivo

// Ruim: isso imprime cada saturação de cumprimento para cada pessoa (9 saídas)
for (pessoa in 1..3) {
    for (cumprimento in 1..3) {
        println("Cumprimento $cumprimento para a pessoa $pessoa")
    }
}

// Melhor: se você só quer uma saída por pessoa, use apenas um loop
for (pessoa in 1..3) {
    println("Olá, pessoa $pessoa!")
}

Antes de aninhar um loop, pergunte a si mesmo: "Eu realmente preciso de toda combinação entre o valor externo e o valor interno?" Se a resposta for não — se você só quer processar cada item uma vez — um único loop quase sempre é mais limpo. Só use aninhamento quando você realmente precisar processar combinações ou dados organizados em grade.

Regra geral: se seu loop aninhado está ficando difícil de ler ou parece estar fazendo mais trabalho do que deveria, isso é um sinal para pausar. Mais adiante você vai aprender sobre funções de alta ordem como map, filter e forEach que muitas vezes substituem loops aninhados por alternativas mais limpas e mais rápidas.

❗Desafio da Aula

Use loops aninhados para imprimir um padrão de triângulo de asteriscos. Para um tamanho de 5, a saída deve ficar assim: 

*
**
***
****
*****

Bônus: modifique para que o triângulo fique invertido (5 asteriscos no topo, 1 na base). Depois tente fazer um quadrado sólido (5 asteriscos de largura, 5 linhas de altura).

Dica: o loop externo controla em qual linha você está. O loop interno imprime asteriscos para aquela linha. Na linha 1 você imprime 1 asterisco, na linha 2 você imprime 2 asteriscos — ou seja, o range do loop interno depende da variável do loop externo. Você pode construir uma string começando com uma string vazia e concatenando dentro do loop interno, depois imprimir após o loop interno terminar.

🤖 Aprofundando com IA

Aprofunde seu entendimento

Prompt #1:

Acabei de aprender sobre loops aninhados em Kotlin. Sem escrever nenhum código, você pode me explicar por que aninhar um loop de 50 dentro de um loop de 50 pode causar problemas que um único loop de 100 não causaria? Use uma analogia do mundo real. Depois me pergunte se eu entendi antes de continuar.

Prompt #2:

Me dê 3 cenários do mundo real em português simples — sem código — onde loops aninhados seriam a escolha natural. Depois me dê 2 cenários onde pode parecer que você precisa de loops aninhados, mas na verdade um único loop funcionaria melhor. Explique o porquê em cada caso.

Crie um exemplo para praticar

Prompt #3:

Escreva um exemplo de loop aninhado em Kotlin que processe algum tipo de dado organizado em grade — algo que você realmente encontraria num app Android, como verificar um tabuleiro de jogo ou processar pixels de uma imagem conceitualmente. Adicione comentários detalhados em cada linha para que eu entenda tanto o que o código faz quanto por que loops aninhados foram a escolha certa aqui.

Etapa 3 Recap: O Que Você Aprendeu

Você chegou ao fim da Etapa 3! Aqui está um resumo rápido de tudo o que você aprendeu sobre repetição em Kotlin:

  • for loop — repete um bloco de código um número definido de vezes, usando um range. for (i in 1..5) executa para cada valor de 1 a 5.
  • Operadores de range — 1..10 inclui o último número (range fechado); 1 until 10 exclui o último número (range semi-aberto). downTo conta para trás, e step define o tamanho do passo.
  • while loop — repete um bloco de código enquanto uma condição for verdadeira. Útil quando você não sabe de antemão quantas vezes vai repetir.
  • do-while loop — parecido com o while, mas a condição é verificada no final, garantindo que o corpo execute pelo menos uma vez.
  • break — sai imediatamente do loop inteiro, parando toda repetição adicional.
  • continue — pula o restante da passagem atual e vai direto para a próxima.
  • Loops aninhados — um loop dentro de outro loop, úteis para processar grades e combinações, mas que multiplicam o número de iterações rapidamente — use com cuidado.

Com esses fundamentos de repetição, você já consegue escrever código que processa tarefas repetitivas de forma eficiente. Na próxima etapa, você vai aprender a organizar seu código em funções reutilizáveis.

Novas aulas em breve…