⬅

#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.

Novas aulas em breve…