Clases case
Contenedores de datos inmutables
Clases case es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué es una case class?
Una case class es un tipo especial de clase diseñado para contener datos inmutables. Se declara mediante case class.
Scala genera automáticamente mucho código útil, por lo que las case classes son la forma habitual de modelar datos.
Declarar una
Solo tiene que enumerar los campos en la lista de parámetros. Cada parámetro se convierte en un campo inmutable.
No se necesita la palabra clave new para crear una instancia.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(3, 4)
println(p.x)
println(p.y)
}
}toString automático
Las case classes obtienen gratuitamente un toString legible que muestra el nombre de la clase y los valores de sus campos.
Esto facilita enormemente la depuración y el registro de datos.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Igualdad por valor
Las case classes se comparan por valor, no por referencia. Dos instancias con los mismos campos son iguales.
Las clases normales se compararían por identidad.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val a = Point(1, 2)
val b = Point(1, 2)
println(a == b)
}
}Campos inmutables
Los campos de una case class son val de forma predeterminada, por lo que no se pueden reasignar.
Para obtener una versión modificada, debe crear una instancia nueva en lugar de modificar la anterior.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}El método copy
Toda case class tiene un método copy. Este crea una instancia nueva y permite cambiar solo los campos que indique.
Esta es la forma idiomática de actualizar datos inmutables.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
val moved = p.copy(y = 99)
println(p)
println(moved)
}
}Compatibilidad con la coincidencia de patrones
Las case classes funcionan perfectamente con match. Puede deconstruirlas nombrando sus campos en un patrón.
Esta es una de las principales razones para usarlas.
case class Point(x: Int, y: Int)
object Main {
def describe(p: Point): String = p match {
case Point(0, 0) => "origin"
case Point(x, 0) => s"on x-axis at $x"
case Point(x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(describe(Point(0, 0)))
println(describe(Point(5, 0)))
println(describe(Point(2, 3)))
}
}Valores predeterminados de los parámetros
Al igual que las clases normales, las case classes pueden tener valores predeterminados para sus parámetros, por lo que puede omitirlos al construirlas.
case class User(name: String, active: Boolean = true)
object Main {
def main(args: Array[String]): Unit = {
val u1 = User("Ada")
val u2 = User("Bo", false)
println(u1)
println(u2)
}
}Añadir métodos
Una case class puede tener sus propios métodos en el cuerpo, como cualquier clase. Estos operan sobre los campos inmutables.
case class Rect(w: Int, h: Int) {
def area: Int = w * h
}
object Main {
def main(args: Array[String]): Unit = {
val r = Rect(3, 4)
println(r.area)
}
}¿Por qué usar case classes?
Las case classes le proporcionan gratuitamente:
- Un constructor conciso con campos inmutables
- Un
toStringlegible equalsyhashCodebasados en el valor- Un método
copy - Compatibilidad integrada con la coincidencia de patrones
Son la base para modelar datos en Scala.
Integración
Aquí se crea, copia y compara una case class, y se hace coincidir con un patrón, todo en un mismo ejemplo.
case class Money(amount: Int, currency: String)
object Main {
def main(args: Array[String]): Unit = {
val price = Money(10, "USD")
val sale = price.copy(amount = 8)
println(price == sale)
sale match {
case Money(a, "USD") => println(s"$a dollars")
case Money(a, c) => println(s"$a $c")
}
}
}Comprobación rápida
Compruebe su comprensión de las case classes.
Resumen
Ha aprendido que una case class modela datos inmutables con utilidades generadas automáticamente:
- Se construye sin
new; sus campos sonvalinmutables toString,equalsyhashCodebasados en el valor, incluidos gratuitamentecopycrea copias modificadas- Compatibilidad integrada con la coincidencia de patrones
- Se permiten valores predeterminados y métodos personalizados
Preguntas frecuentes
¿La lección «Clases case» es gratis?
Sí — el texto completo de «Clases case» 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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Clases case»?
Contenedores de datos inmutables Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 1 de 4.
¿Cuánto tiempo toma la lección «Clases case»?
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 Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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.