Traits sellados
Jerarquías cerradas
Traits sellados es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 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 un trait?
Un trait es similar a una interfaz: declara un tipo común que otras clases pueden ampliar.
Los traits permiten agrupar tipos relacionados bajo un mismo concepto para poder utilizarlos indistintamente.
Un trait básico
Declare un trait con trait y haga que las clases u objetos lo amplíen mediante extends.
trait Shape
case class Circle(r: Double) extends Shape
case class Square(side: Double) extends Shape
object Main {
def main(args: Array[String]): Unit = {
val s: Shape = Circle(2.0)
println(s)
}
}¿Qué significa sealed?
Un trait sealed solo puede ser ampliado por tipos declarados en el mismo archivo.
Esto cierra la jerarquía: el compilador conoce la lista completa de posibles subtipos.
sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color
object Main {
def main(args: Array[String]): Unit = {
val c: Color = Green
println(c)
}
}Case objects como variantes
Cuando una variante no tiene datos, use case object en lugar de case class. Solo existe una instancia.
Es perfecto para valores similares a los de una enumeración.
sealed trait Direction
case object North extends Direction
case object South extends Direction
object Main {
def main(args: Array[String]): Unit = {
val d: Direction = North
println(d)
}
}Combinar objetos y clases
Un trait sealed puede tener variantes case object (sin datos) y variantes case class (con datos).
sealed trait Event
case object Started extends Event
case class Failed(reason: String) extends Event
object Main {
def main(args: Array[String]): Unit = {
val e: Event = Failed("timeout")
println(e)
}
}Hacer match sobre un trait sealed
Haga match sobre el trait y gestione cada variante. Como la jerarquía está sellada, el compilador puede verificar que se han cubierto todas.
sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color
object Main {
def hex(c: Color): String = c match {
case Red => "#FF0000"
case Green => "#00FF00"
case Blue => "#0000FF"
}
def main(args: Array[String]): Unit = {
println(hex(Green))
}
}Advertencias del compilador
Si olvida una variante en un match sobre un trait sealed, el compilador le advierte de que falta un caso.
Esto detecta errores cuando más adelante añade una variante nueva. Exploraremos este tema en profundidad en la lección sobre coincidencias exhaustivas.
Los traits pueden declarar miembros
Un trait puede declarar métodos o campos que todos los subtipos comparten o deben implementar.
sealed trait Animal {
def sound: String
}
case object Dog extends Animal { def sound = "Woof" }
case object Cat extends Animal { def sound = "Meow" }
object Main {
def main(args: Array[String]): Unit = {
println(Dog.sound)
println(Cat.sound)
}
}¿Por qué usar sealed?
Sellar un trait le proporciona:
- Un conjunto conocido y cerrado de subtipos
- Comprobación de exhaustividad en
match - Refactorizaciones más seguras al añadir variantes
Los traits sealed junto con las case classes son la forma en que Scala construye tipos de datos algebraicos.
Usar la jerarquía
Las funciones pueden aceptar el tipo del trait y trabajar con cualquier variante, derivando el comportamiento mediante la coincidencia de patrones.
sealed trait Payment
case class Cash(amount: Int) extends Payment
case class Card(number: String) extends Payment
object Main {
def summary(p: Payment): String = p match {
case Cash(a) => s"cash $a"
case Card(n) => s"card ending ${n.takeRight(4)}"
}
def main(args: Array[String]): Unit = {
println(summary(Cash(50)))
println(summary(Card("123456789012")))
}
}Integración
Un trait sealed con variantes mixtas, compartido mediante una función que hace match con cada caso.
sealed trait Result
case object Pending extends Result
case class Success(value: Int) extends Result
case class Error(msg: String) extends Result
object Main {
def show(r: Result): String = r match {
case Pending => "waiting"
case Success(v) => s"ok: $v"
case Error(m) => s"fail: $m"
}
def main(args: Array[String]): Unit = {
List(Pending, Success(7), Error("boom")).foreach(r => println(show(r)))
}
}Comprobación rápida
Compruebe su comprensión de los traits sealed.
Resumen
Ha aprendido sobre los traits sealed:
- Un
traitdefine un supertipo compartido sealedlimita los subtipos al mismo archivo- Use
case objectpara variantes sin datos ycase classpara variantes con datos - Sellar un trait permite comprobar la exhaustividad en
match
Aprende Scala con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 39
- Lecciones
- 143
Preguntas frecuentes
¿La lección «Traits sellados» es gratis?
Sí — el texto completo de «Traits sellados» 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 «Traits sellados»?
Jerarquías cerradas 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 2 de 4.
¿Cuánto tiempo toma la lección «Traits sellados»?
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.
Todas las lecciones de este curso
- Clases case
- Traits sellados
- Tipos de datos algebraicos
- Coincidencia exhaustiva