Android Academy · Aula

Classes de Dados e Classes Seladas

Use classes de dados para igualdade baseada em valores e copy() e classes seladas para hierarquias de tipos exaustivas e uma modelagem de estados mais clara.

Classes de Dados e Classes Seladas é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

O que são classes de dados?

Uma classe de dados no Kotlin é uma classe cuja finalidade principal é armazenar dados. O compilador gera automaticamente métodos úteis:

equals() — compara duas instâncias por valor
hashCode() — hash consistente com base nas propriedades
toString() — representação textual legível
copy() — cria uma cópia modificada
Suporte à desestruturação

Declarando uma classe de dados

Adicione a palavra-chave data antes de class. Todas as propriedades devem estar no construtor primário:

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

fun main() {
    val u1 = User(1, "Alice", "alice@example.com")
    val u2 = User(1, "Alice", "alice@example.com")

    println(u1)          // User(id=1, name=Alice, email=alice@example.com)
    println(u1 == u2)    // true  (value equality)
    println(u1 === u2)   // false (different objects)
}

copy() — Modificar um campo

copy() cria uma nova instância com algumas propriedades alteradas. A original não é modificada (imutabilidade):

data class Product(val name: String, val price: Double, val inStock: Boolean)

fun main() {
    val original = Product("Laptop", 999.0, true)

    // Only change the price; keep everything else
    val onSale = original.copy(price = 799.0)

    println(original)  // Product(name=Laptop, price=999.0, inStock=true)
    println(onSale)    // Product(name=Laptop, price=799.0, inStock=true)
}

Declarações com desestruturação

As classes de dados são compatíveis com a desestruturação — desempacote propriedades em variáveis usando as funções componentN() geradas pelo compilador:

data class Point(val x: Int, val y: Int)

fun main() {
    val point = Point(10, 20)

    // Destructure into separate variables
    val (x, y) = point
    println("x=$x, y=$y")   // x=10, y=20

    // Also works in for loops with maps
    val scores = mapOf("Alice" to 95, "Bob" to 88)
    for ((name, score) in scores) {
        println("$name: $score")
    }
}

O que são classes seladas?

Uma classe selada é uma hierarquia de classes restrita — todas as subclasses devem ser definidas no mesmo arquivo. Isso faz com que o conjunto de tipos possíveis seja conhecido no momento da compilação.

Use classes seladas para representar um conjunto finito de estados, como resultados de rede, estados da interface ou eventos de navegação.

Sintaxe de classe selada

Declare as subclasses diretamente dentro do mesmo arquivo:

sealed class NetworkResult<out T> {
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val message: String, val code: Int = 0) : NetworkResult<Nothing>()
    object Loading : NetworkResult<Nothing>()
}

fun handle(result: NetworkResult<String>) {
    when (result) {
        is NetworkResult.Success -> println("Data: ${result.data}")
        is NetworkResult.Error  -> println("Error ${result.code}: ${result.message}")
        NetworkResult.Loading   -> println("Loading...")
    }
}

Classe selada + when (exaustivo)

O poder das classes seladas: when é exaustivo. O compilador força você a tratar cada subtipo — nenhum caso é esquecido:

sealed class UiState {
    object Loading : UiState()
    data class Success(val message: String) : UiState()
    data class Error(val error: String) : UiState()
}

fun render(state: UiState): String = when (state) {
    is UiState.Loading      -> "Showing spinner"
    is UiState.Success      -> "Show: ${state.message}"
    is UiState.Error        -> "Error: ${state.error}"
    // Compiler error if you remove any branch!
}

fun main() {
    println(render(UiState.Loading))
    println(render(UiState.Success("Loaded!")))
}

Classe selada versus enumeração

Ambas representam um conjunto fixo de valores, mas:

Enumeração — cada constante é uma única instância, sem dados adicionais por variante
Classe selada — cada variante pode conter dados diferentes e ser uma classe ou um objeto

Use uma enumeração quando as variantes não precisarem de dados. Use uma classe selada quando as variantes precisarem de propriedades diferentes.

Declarações de objeto (单tons)

object cria um singleton — uma única instância, criada sob demanda e segura para uso por várias linhas de execução:

object AppConfig {
    const val BASE_URL = "https://api.example.com"
    const val TIMEOUT = 30L

    fun buildUrl(path: String) = "$BASE_URL/$path"
}

fun main() {
    println(AppConfig.BASE_URL)          // https://api.example.com
    println(AppConfig.buildUrl("users")) // https://api.example.com/users
}

Objetos acompanhantes

Um objeto acompanhante fica dentro de uma classe e fornece membros no nível da classe (como static em Java). É comumente usado para métodos de fábrica:

class Token private constructor(val value: String) {
    companion object {
        fun create(raw: String): Token {
            val cleaned = raw.trim()
            require(cleaned.isNotEmpty()) { "Token must not be blank" }
            return Token(cleaned)
        }
    }
}

fun main() {
    val token = Token.create("  abc123  ")
    println(token.value)  // abc123
}

Classes de dados em um aplicativo real

Combine classes de dados com classes seladas para modelar estados de forma clara:

data class Post(val id: Int, val title: String, val body: String)

sealed class PostState {
    object Loading : PostState()
    data class Loaded(val posts: List<Post>) : PostState()
    data class Failed(val reason: String) : PostState()
}

fun showState(state: PostState) = when (state) {
    PostState.Loading        -> println("Fetching posts...")
    is PostState.Loaded      -> println("${state.posts.size} posts loaded")
    is PostState.Failed      -> println("Failed: ${state.reason}")
}

fun main() {
    showState(PostState.Loaded(listOf(
        Post(1, "Hello", "World"),
        Post(2, "Kotlin", "Rocks")
    )))
}

Verificação rápida

Qual afirmação descreve melhor o que diferencia as classes seladas das classes abstratas comuns?

Recapitulação: classes de dados e classes seladas

Agora você dispõe de duas ferramentas poderosas do Kotlin:

classe de dados — igualdade baseada em valor, copy(), desestruturação e toString() gerado automaticamente
classe selada — hierarquia finita de tipos, when exaustivo; cada variante pode conter seus próprios dados
objeto — singleton; objetos acompanhantes para métodos de fábrica

Juntos, esses padrões substituem o código repetitivo do Java e permitem uma modelagem de estados clara e segura.

Perguntas Frequentes

A aula “Classes de Dados e Classes Seladas” é grátis?

Sim — o texto completo de “Classes de Dados e Classes Seladas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Classes de Dados e Classes Seladas”?

Use classes de dados para igualdade baseada em valores e copy() e classes seladas para hierarquias de tipos exaustivas e uma modelagem de estados mais clara. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Classes de Dados e Classes Seladas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Segurança contra Nulos
Classes e Objetos
Classes de Dados e Classes Seladas
Funções de Extensão e Funções de Ordem Superior

← Voltar para Android Academy