Este guia é um material de apoio para quem está começando na linguagem Kotlin, especialmente para estudantes que já possuem uma base em lógica de programação.

Kotlin é uma linguagem moderna, estaticamente tipada, que roda na JVM (a mesma máquina virtual do Java) e também pode ser compilada para JavaScript ou código nativo. Desde 2019, é a linguagem oficialmente recomendada pelo Google para desenvolvimento Android — é a linguagem usada no projeto Saudações em Android deste curso, e também no Saudações em Kotlin puro (console, sem Android).

🔹 Por que Kotlin em vez de Java no Android?

Kotlin foi desenhado para ser 100% interoperável com Java (você pode chamar código Java de dentro do Kotlin e vice-versa), mas corrige vários pontos de atrito histórico do Java:

  • Null safety: o sistema de tipos distingue String (nunca nulo) de String? (pode ser nulo) — muitos erros de NullPointerException viram erro de compilação em vez de crash em produção.
  • Sintaxe mais concisa: menos código boilerplate que Java pra fazer a mesma coisa (getters/setters automáticos, inferência de tipos, funções de extensão).
  • Interoperabilidade total: bibliotecas Java existentes continuam funcionando normalmente.

🛠️ Instalação e Configuração do Ambiente

Para programar em Kotlin, você precisa do JDK (Java Development Kit) e do compilador Kotlin.

Instalação do JDK

Baixe e instale o OpenJDK (versão 17 ou mais recente). Verifique no terminal:

java -version

Instalação do Kotlin

Baixe o compilador via site oficial ou gerenciador de pacotes do seu sistema. Verifique:

kotlinc -version

IDE

IntelliJ IDEA (da JetBrains, criadora do Kotlin) e Android Studio (baseado no IntelliJ) têm suporte nativo completo a Kotlin — são as IDEs recomendadas.

🚀 Seu Primeiro Programa em Kotlin

Crie um arquivo chamado:

main.kt

Escreva:

fun main() {
    println("Ola, Universo Kotlin!")
}

Compile e execute:

kotlinc main.kt -include-runtime -d main.jar
java -jar main.jar

O resultado será:

Ola, Universo Kotlin!

Análise do Código

  • fun main() declara a função principal — repare em fun, não function nem def.
  • println() exibe texto no console, com quebra de linha automática.
  • Não há necessidade de declarar uma classe envolvendo main, diferente do Java.

📊 Tipos de Dados e Variáveis

Kotlin tem inferência de tipos — você raramente precisa escrever o tipo explicitamente, mas ele existe e é checado em tempo de compilação.

val nome: String = "Ana Souza"
val idade: Int = 25
val salario: Double = 6200.75
val estudante: Boolean = true

val declara uma referência imutável (não pode ser reatribuída); var declara uma mutável:

var contador = 0
contador = contador + 1

Null safety

var nome: String = "Ana"
// nome = null   // ERRO de compilação: String não aceita null

var apelido: String? = null   // "?" permite null explicitamente

Se apelido pode ser null, o compilador obriga você a tratar esse caso antes de usar o valor — com ?., !! ou if (apelido != null).

🔢 Operadores

Aritméticos

Operador Significado
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto da divisão

Comparativos

Operador Significado
== Igual (compara valor)
!= Diferente
>, <, >=, <= Comparação numérica

Nota: diferente de Java, == em Kotlin já compara valor (não referência) por padrão — para comparar referência, usa-se ===.

Lógicos

Operador Significado
&& E (AND)
|| OU (OR)
! NÃO (NOT)

📤 Saída de Dados

fun main() {
    val idade = 25
    val salario = 6200.75
    val nome = "Ana Souza"

    println("IDADE = $idade") println("SALARIO =$salario")
    println("NOME = $nome")
}

O $variavel dentro de uma string faz interpolação direta — não precisa de + nem .format() para casos simples. Para expressões, usa-se ${...}:

println("Ano que vem: ${idade + 1}")

📥 Entrada de Dados

fun main() {
    print("Digite seu nome: ")
    val nome = readLine() ?: ""
    println("Ola, $nome!")
}

readLine() devolve String? (pode ser null se a entrada for fechada) — o operador ?: (“elvis operator”) fornece um valor padrão ("") caso seja null.

🔀 Estrutura Condicional

fun saudacaoPorHora(hora: Int): String {
    return if (hora < 6) {
        "Boa madrugada!"
    } else if (hora < 12) {
        "Bom dia!"
    } else if (hora < 18) {
        "Boa tarde!"
    } else {
        "Boa noite!"
    }
}

Em Kotlin, if é uma expressão — pode ser usado diretamente como valor de retorno, sem precisar de uma variável intermediária.

when (o switch do Kotlin)

fun saudacaoPorHora(hora: Int): String = when {
    hora < 6 -> "Boa madrugada!"
    hora < 12 -> "Bom dia!"
    hora < 18 -> "Boa tarde!"
    else -> "Boa noite!"
}

🔁 Estruturas de Repetição

// for
for (i in 1..10) {
    println(i)
}

// while
var contador = 0
while (contador < 5) {
    println(contador)
    contador++
}

1..10 é um range (intervalo) — sintaxe nativa de Kotlin, sem precisar de range() como em Python.

📏 Listas

val numeros = listOf(10, 20, 30, 40)

println(numeros[0])
println(numeros.size)

val dobrados = numeros.map { it * 2 }
val pares = numeros.filter { it % 2 == 0 }

listOf() cria uma lista imutável; mutableListOf() cria uma que aceita add/remove. { it * 2 } é uma função lambda — it é o nome implícito do único parâmetro.

🧩 Funções

fun somar(a: Int, b: Int): Int {
    return a + b
}

// Forma curta (função de expressão única)
fun somar(a: Int, b: Int): Int = a + b

Parâmetros com valor padrão

fun saudar(nome: String, saudacao: String = "Ola") {
    println("$saudacao, $nome!")
}

saudar("Ana")               // Ola, Ana!
saudar("Ana", "Bom dia")    // Bom dia, Ana!

🐘 Kotlin no Android (Jetpack Compose)

O projeto Saudações em Android deste curso usa Jetpack Compose, o toolkit moderno de UI declarativa do Android, escrito em Kotlin:

@Composable
fun GreetingScreen() {
    var horario by remember { mutableStateOf("") }
    Text(text = "Digite uma hora do dia (formato HH:MM):")
    TextField(value = horario, onValueChange = { horario = it })
}

@Composable marca uma função como um componente de UI; remember { mutableStateOf(...) } guarda estado que sobrevive a recomposições da tela — o equivalente Kotlin/Android do useState do React.

🧠 Kotlin x Java

Característica Java Kotlin
Null safety Não (NullPointerException em runtime) Sim (String vs String?, checado em compilação)
Ponto de entrada Precisa de uma classe fun main() direto
Inferência de tipos Limitada (var desde Java 10) Ampla
Interpolação de string + ou String.format "$variavel"
if como expressão Não Sim
Getters/setters Manuais ou geradas pela IDE Automáticos em val/var
Interoperabilidade — 100% compatível com bibliotecas Java

🎓 Conclusão

Kotlin é hoje a porta de entrada padrão para desenvolvimento Android, mantendo total compatibilidade com o ecossistema Java já maduro, mas com uma sintaxe mais segura e concisa. Domine os fundamentos daqui e aplique-os em um app real com Jetpack Compose — ou compare com Swift, a linguagem que ocupa esse mesmo papel no ecossistema Apple.

🔗 Recursos Pedagógicos do Capítulo

Recurso Descrição Acesso Direto
📊 Slides de Aula Apresentação visual estruturada com diagramas Ver Slides
🧠 Quiz Formativo Teste de fixação com feedback imediato por alternativa Fazer Quiz
💻 Exemplos Práticos Código executável completo e saída no console Ver Exemplos
🧩 Exercícios Progressivos Lista de atividades práticas em 4 níveis Resolver Exercícios

🧭 Navegação do Capítulo: ⬅️ Capítulo Anterior · 📚 Sumário do Módulo · ➡️ Próximo Capítulo