Kotlin para Android: fundamentos de sintaxe e recursos

O que é Kotlin?

Kotlin é uma linguagem de programação estaticamente tipada criada pela JetBrains (desenvolvedora do IntelliJ IDEA) e lançada em 2016 sob licença Apache 2.0. Kotlin compila para bytecode JVM, JavaScript e código nativo (via Kotlin/Native). Suas principais áreas de aplicação são desenvolvimento Android, aplicações servidoras e projetos multiplataforma.

O Google anunciou Kotlin como linguagem oficial de desenvolvimento Android no Google I/O 2017. Segundo o Google (Android Developer Blog, 2026), mais de 85% dos novos projetos no Google Play usam Kotlin. A linguagem também é ativamente usada em desenvolvimento server-side (Spring Boot, Ktor) e projetos multiplataforma (Kotlin Multiplatform Mobile).

Kotlin é totalmente compatível com Java — você pode chamar código Java do Kotlin e vice-versa no mesmo projeto. As ferramentas de build (Gradle, Maven) suportam ambas as linguagens, permitindo migração gradual de Java para Kotlin sem paradas no desenvolvimento.

Por que Kotlin é mais popular que Java para Android

As principais razões: concisão — Kotlin requer em média 40% menos linhas de código que Java para a mesma tarefa. Null safety — o compilador proíbe o uso de tipos nullable sem verificação. Capacidades funcionais — funções de alta ordem, lambdas, extension functions e corrotinas tornam o código mais expressivo e seguro.

Fundamentos de sintaxe

A sintaxe básica do Kotlin combina concisão com clareza. Variáveis são declaradas usando val (imutável) e var (mutável). O compilador usa inferência de tipos, mas a declaração explícita de tipos é suportada. Funções são declaradas com a palavra-chave fun.

package com.example.intro

// Constantes e variáveis
val appName: String = "KotlinApp"  // imutável
var version = 1.0  // mutável, tipo inferido

// Função com expression body
fun sum(a: Int, b: Int) = a + b

// String templates
fun greet(name: String) = "Olá, $name! Versão ${appName}_$version"

// Default and named arguments
fun createUser(
    name: String,
    age: Int = 18,
    email: String? = null
)

A expressão when substitui switch em Java e é mais flexível: suporta verificações de tipo, intervalos, condições e ramos sem break. O compilador verifica cobertura exaustiva para enum e sealed classes. Smart casts convertem tipos automaticamente após uma verificação is, eliminando casts explícitos.

fun analyzeValue(value: Any) = when (value) {
    is String -> "String de comprimento ${value.length}"  // smart cast
    is Int -> "Número inteiro: $value"
    in 1..10 -> "Número no intervalo 1-10"
    else -> "Tipo desconhecido"
}

Null safety e operadores Elvis

Null safety é um recurso chave do Kotlin que elimina NullPointerException em tempo de compilação. Em Kotlin, os tipos não podem ser null por padrão. Para permitir null, adicione ? ao tipo: String?. O compilador exige verificação explícita de cada valor nullable.

// Tipos nullable e non-null
val nonNull: String = "Sempre não null"
val nullable: String? = null  // permitido

// Safe call — executa apenas se não for null
val length: Int? = nullable?.length

// Operador Elvis — valor padrão
val text: String = nullable ?: "Default text"

// Let — executar bloco com valor non-null
nullable?.let { value ->
    println("Valor: $value")
}

O operador safe call (?.) retorna null se o objeto antes do operador for null, e chama o método/propriedade caso contrário. O operador Elvis (?:) fornece um valor padrão se o lado esquerdo for null. A assertiva not-null (!!) lança NullPointerException se o valor for null — use apenas quando tiver 100% de certeza que o valor existe.

Tipos platform — tipos Java do código Java chamado que Kotlin não pode marcar como nullable ou non-null. O tipo é exibido como String! (com ponto de exclamação). O desenvolvedor é responsável pela null safety ao trabalhar com código Java.

Data classes e desestruturação

As data classes em Kotlin geram automaticamente equals(), hashCode(), toString(), copy() e componentN(). Isso elimina o boilerplate dos modelos Java (POJO) e torna o código mais limpo. Declarar uma data class ocupa uma linha em vez de 20-30 em Java.

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int? = null
)

// Uso
val user = User(1, "Ana", "anna@example.com")
val updatedUser = user.copy(age = 25)

// Desestruturação
val (id, name) = user
println("Usuário #$id: $name")

A desestruturação permite decompor uma data class em variáveis em uma única linha. Isso é conveniente ao trabalhar com pares, triplas e outros valores compostos. A desestruturação é suportada para data classes, coleções padrão (List, Map) e qualquer classe com operator fun componentN().

Funções de extensão

As funções de extensão são um mecanismo do Kotlin para adicionar novos métodos a classes existentes sem herança. As extensões são compiladas em métodos estáticos com um parâmetro receiver, portanto herança não é necessária e dispatch virtual não é suportado.

// Função de extensão para String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Propriedade de extensão
val String.isPhoneNumber: Boolean
    get() = this.matches(Regex("^\\+?[\\d-]{10,15}$"))

// Extensão genérica para coleções
fun List<Int>.sumOfEvens(): Int {
    return this.filter { it % 2 == 0 }.sum()
}

// Uso
println("test@mail.com".isEmail())  // true

Extensões são amplamente usadas no Android SDK e bibliotecas. Por exemplo, as Activity extensions no Android KTX são extension functions para Activity, Fragment, View e outras classes. Extensões podem ser declaradas como funções top-level em um arquivo ou como member extensions de uma classe.

Corrotinas para programação assíncrona

As corrotinas são um mecanismo de programação assíncrona em Kotlin que permite escrever código não bloqueante em estilo sequencial. Uma corrotina suspende a execução em uma função suspend sem bloquear a thread e retoma após a conclusão da operação. É uma alternativa às cadeias de callbacks do RxJava e AsyncTask.

import kotlinx.coroutines.*

// Função suspend — pode ser pausada
suspend fun fetchUserData(userId: Int): User {
    // delay — função suspend, não bloqueia a thread
    delay(500)
    return User(userId, "User $userId", "user@example.com")
}

// Iniciar em corrotina
fun loadData() {
    CoroutineScope(Dispatchers.Main).launch {
        val user = fetchUserData(1)  // pausa aqui
        updateUI(user)  // continuar na thread Main
    }
}

Os Dispatchers determinam o pool de threads para uma corrotina: Dispatchers.Main (thread de UI), Dispatchers.IO (operações de rede/disco), Dispatchers.Default (tarefas intensivas em CPU). A concorrência estruturada garante que uma corrotina não permaneça ativa após a conclusão do escopo — isso evita vazamentos de memória.

// Execução paralela via async/await
suspend fun loadDashboard(): Dashboard = coroutineScope {
    val user = async { fetchUserData(1) }
    val orders = async { fetchOrders(1) }
    val stats = async { fetchStats() }
    
    Dashboard(user.await(), orders.await(), stats.await())
}

Kotlin vs Java: comparação

A escolha entre Kotlin e Java para um novo projeto Android é uma decisão arquitetural fundamental. Kotlin oferece uma sintaxe mais moderna e mecanismos de segurança integrados, enquanto Java tem um grupo maior de desenvolvedores e bibliotecas maduras.

Desempenho de Kotlin e Java é comparável — ambos compilam para bytecode JVM. Kotlin às vezes adiciona micro-overhead em corrotinas e inlining, mas é insignificante para aplicativos móveis. Google e JetBrains investem ativamente em Kotlin: Kotlin Multiplatform, Kotlin/Wasm e melhorias de desempenho do compilador K2.