0Pricing
Android Academy · Lección

Clases de datos y clases selladas

Utilice clases de datos para la igualdad basada en valores y copy(), y clases selladas para jerarquías de tipos exhaustivas y un modelado claro de estados.

Clases de datos y clases selladas es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 4 lecciones en total.

¿Qué son las clases de datos?

Una data class en Kotlin es una clase cuyo propósito principal es almacenar datos. El compilador genera automáticamente métodos útiles:

  • equals() — compara dos instancias por valor
  • hashCode() — hash coherente basado en las propiedades
  • toString() — representación de cadena legible
  • copy() — crea una copia modificada
  • Compatibilidad con la desestructuración

Declaración de una clase de datos

Añada la palabra clave data delante de class. Todas las propiedades deben estar en el constructor primario:

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 un campo

copy() crea una instancia nueva con algunas propiedades modificadas. La original no se modifica (inmutabilidad):

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)
}

Declaraciones por destructuración

Las clases de datos admiten la destructuración: puede desempaquetar las propiedades en variables mediante las funciones componentN() generadas por el 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")
    }
}

¿Qué son las clases selladas?

Una clase sellada es una jerarquía de clases restringida: todas las subclases deben definirse en el mismo archivo. Esto hace que el conjunto de tipos posibles sea conocido en tiempo de compilación.

Use clases selladas para representar un conjunto finito de estados, como resultados de red, estados de la interfaz de usuario o eventos de navegación.

Sintaxis de las clases selladas

Declare las subclases directamente dentro de la clase o en el mismo archivo:

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...")
    }
}

Clase sellada + when (exhaustivo)

La potencia de las clases selladas: when es exhaustivo. El compilador le obliga a gestionar cada subtipo, sin casos olvidados:

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!")))
}

Clase sellada frente a Enum

Ambas representan un conjunto fijo de valores, pero:

  • Enum: cada constante es una instancia única, sin datos adicionales por variante
  • Clase sellada: cada variante puede contener datos diferentes y ser una clase o un objeto

Use enum cuando las variantes no necesiten datos. Use una clase sellada cuando las variantes necesiten propiedades diferentes.

Declaraciones object (Singletons)

object crea un singleton: una única instancia, creada de forma diferida y segura para subprocesos:

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 companion

Un companion object reside dentro de una clase y proporciona miembros de nivel de clase (como static en Java). Se usa habitualmente 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
}

Clases de datos en una aplicación real

Combine clases de datos con clases selladas 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")
    )))
}

Comprobación rápida

¿Qué afirmación describe mejor qué diferencia a las clases selladas de las clases abstractas normales?

Resumen: clases de datos y clases selladas

Ahora dispone de dos herramientas potentes de Kotlin:

  • data class: igualdad basada en valores, copy(), destructuración y toString() generado automáticamente
  • sealed class: jerarquía de tipos finita, when exhaustivo y una variante que puede contener sus propios datos
  • object: singleton y companion objects para métodos de fábrica

En conjunto, estos patrones sustituyen el código repetitivo de Java y permiten modelar estados de forma clara y segura.

Preguntas frecuentes

¿La lección «Clases de datos y clases selladas» es gratis?

Sí — el texto completo de «Clases de datos y clases selladas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Clases de datos y clases selladas»?

Utilice clases de datos para la igualdad basada en valores y copy(), y clases selladas para jerarquías de tipos exhaustivas y un modelado claro de estados. Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Clases de datos y clases selladas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Seguridad frente a valores nulos
  2. Clases y objetos
  3. Clases de datos y clases selladas
  4. Funciones de extensión y de orden superior
← Volver a Android Academy