Especificidades do Kotlin no desenvolvimento mobile: o que é, quais construções e como funciona

Classes (data class, sealed class, object, companion object)

Kotlin estende os conceitos de classe do Java. data class, sealed class, object e companion object — construções que não existem em Java ou são implementadas de forma diferente.

data class vs sealed class

data class — uma classe que gera automaticamente equals(), hashCode(), toString(), copy() e componentN(). Ideal para modelos de dados (DTO, Entity). Requisitos: pelo menos um parâmetro no construtor primário, val/var, não pode ser open/sealed/inner. sealed class — uma classe com hierarquia de subclasses restrita. Todas as subclasses são conhecidas em tempo de compilação e declaradas no mesmo arquivo. Expressão when com sealed class não requer branch else. sealed interface (Kotlin 1.9+) — igual a sealed class, mas permite herança múltipla. object — singleton, declarado com a palavra-chave object (não class). Inicialização lazy thread-safe. companion object — membros estáticos de uma classe. Tem um nome (Companion por padrão). Pode implementar interfaces e ter extension functions.

data class — para 90% dos modelos. sealed class — para UI State e Resultado. object — para singletons. IT Sectr recomenda sealed class para todos os estados de tela (Loading, Success, Error).

Sealed class na prática

Sealed class — uma ferramenta poderosa para modelar estados. Exemplo: UiState<T> com subclasses Loading, Success(data: T), Error(message: String). A expressão when garante o tratamento de todos os estados. Sealed interface — para eventos e ações onde é necessária implementação múltipla. Value class (Kotlin 1.5+) — um wrapper para um único valor sem overhead. Usado para identificadores type-safe: @JvmInline value class UserId(val id: String).

Funções (extension, inline, higher-order, scope functions)

Extension Function — adicionar um método a uma classe existente sem herança. fun String.isEmail(): Boolean. Extension Property — o mesmo para propriedades (sem backing field). Inline Function — inserção do corpo da função no local da chamada — sem overhead de chamada. Usado para higher-order functions com lambdas. Higher-Order Function — uma função que recebe ou retorna outra função. Scope Functions — cinco funções para trabalhar com contexto de objeto: let, run, with, apply, also.

Scope Functions

let — contexto it, retorna resultado da lambda. Usado para chamadas null-safe (?.let {}). apply — contexto this, retorna contexto. Para configuração de objeto. run — contexto this, retorna resultado da lambda. Para cálculos com contexto. also — contexto it, retorna contexto. Para efeitos colaterais (logging). with — não é extension, contexto this, retorna resultado da lambda. Para um grupo de operações em um objeto. Lambda — função anônima. Destructuring Declaration — desempacotamento de data class em variáveis: val (name, age) = person.

Inline + reified

Inline function com reified — a única maneira de preservar um tipo genérico na JVM. Usado para: builders type-safe (Gson.fromJson<T>()), verificação de tipos (is T), obtenção da classe (T::class). Crossinline e Noinline — modificadores para parâmetros lambda em funções inline. crossinline — proíbe non-local return, noinline — proíbe inlining de uma lambda específica. IT Sectr recomenda inline + reified apenas ao trabalhar com tipos; para funções higher-order comuns, inline pode aumentar o tamanho do bytecode.

Corrotinas (Coroutine Builder, Dispatchers, Scope)

Corrotinas — threads leves para programação assíncrona. Não bloqueiam a thread — suspendem. suspend function — uma função que pode ser suspensa sem bloquear a thread. Só pode ser chamada de uma corrotina ou outra suspend function.

CoroutineScope

CoroutineScope — um escopo para corrotinas. Contém CoroutineContext (Job + Dispatcher). lifecycleScope — para Activity/Fragment (Lifecycle-aware). viewModelScope — para ViewModel (cancelamento automático em onCleared()). GlobalScope — escopo global (não recomendado em produção — vazamentos de memória). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (rede/disco), Dispatchers.Default (CPU-intensive), Dispatchers.Unconfined (não recomendado). launch — inicia uma corrotina: Job. async — inicia com resultado: Deferred<T>. runBlocking — ponte bloqueante. withContext — troca Dispatcher dentro de uma suspend function.

// Exemplo de corrotinas: carregando dados no ViewModel
class MainViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    fun loadData() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val data = withContext(Dispatchers.IO) {
                    repository.fetchData()
                }
                _state.value = UiState.Success(data)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message)
            }
        }
    }
}

// Requisições paralelas com async
suspend fun loadCombinedData(): CombinedData = coroutineScope {
    val users = async(Dispatchers.IO) { api.getUsers() }
    val posts = async(Dispatchers.IO) { api.getPosts() }
    CombinedData(users.await(), posts.await())
}

viewModelScope.launch — início padrão de corrotina no ViewModel. withContext(Dispatchers.IO) — troca para thread IO para requisição de rede. Dispatchers determinam em qual pool de threads a corrotina executa. IT Sectr recomenda viewModelScope para ViewModel e lifecycleScope para Activity/Fragment.

Recursos avançados (reified, destructuring, lateinit/lazy)

reified — um modificador de tipo em funções inline. Permite usar o tipo: T::class, is T, as T. Sem reified, os genéricos na JVM são apagados (type erasure). inline fun + reified — uma combinação poderosa para APIs type-safe. Destructuring Declaration — val (x, y) = point. Funciona para data class e tipos com componentN(). typealias — alias de tipo: typealias Callback = (String) -> Unit. lateinit — inicialização diferida de var (para dependency injection). Não thread-safe. lazy — inicialização lazy de val (thread-safe por padrão). lazy(LazyThreadSafetyMode.NONE) — sem sincronização. Extension function e Extension property — adicionar funcionalidade sem herança. Kotlin é uma linguagem onde extension functions resolvem 90% das tarefas de utilitários.

Propriedades Delegadas

Delegated Properties — delegar getter/setter para outro objeto. Delegados padrão: lazy, observable, vetoable, map. Delegado personalizado através dos operadores getValue/setValue. by — palavra-chave de delegação: val name by lazy { loadName() }. Propriedades delegadas são a base para delegados do ViewModel (by viewModels()). IT Sectr recomenda lazy para inicialização diferida e Delegates.observable para observar mudanças.

reified — para APIs type-safe. lazy — para carregamento diferido. delegated properties — para reutilizar lógica de propriedades. IT Sectr recomenda dominar todos esses recursos para desenvolvimento eficaz em Kotlin.

Flow e StateFlow

Flow — fluxo de dados assíncrono frio em Kotlin. Emite valores sob demanda do coletor. StateFlow — Flow quente com um único valor atual. Usado no ViewModel para UI State. SharedFlow — Flow quente para eventos (eventos únicos). flowOf, asFlow — criação de Flow a partir de coleções. catch, retry, debounce — operadores. stateIn, shareIn — conversão de Flow frio para quente. IT Sectr recomenda StateFlow para UI State e SharedFlow para eventos (Snackbar, navegação).

class SearchViewModel : ViewModel() {
    private val _query = MutableStateFlow("")
    val suggestions: StateFlow<List<String>> = _query
        .debounce(300)
        .filter { it.length >= 2 }
        .flatMapLatest { repository.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun onQueryChanged(query: String) {
        _query.value = query
    }
}

Serialização (kotlinx.serialization, Parcelize)

kotlinx.serialization — biblioteca Kotlin para serialização JSON. @Serializable — anotação. @SerialName — nome de campo personalizado. Suporta: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize para Android Parcelable (sem implementação manual). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, compile-safe, sem reflection. Moshi — anotações + codegen. IT Sectr recomenda kotlinx.serialization para novos projetos e Moshi para existentes.

@Serializable
data class ApiResponse<T>(
    val success: Boolean,
    @SerialName("data") val data: T? = null,
    val error: String? = null
)

@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Desserialização
val json = Json { ignoreUnknownKeys = true }
val response = json.decodeFromString<ApiResponse<List<User>>>(jsonString)
println("Users: ${response.data?.size ?: 0}")