Traits seladas
Hierarquias fechadas.
Traits seladas é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que é um trait?
Um trait é semelhante a uma interface: ele declara um tipo comum que outras classes podem estender.
Os traits permitem agrupar tipos relacionados sob uma única abstração, para que possam ser usados de forma intercambiável.
Um trait básico
Declare um trait com trait e faça com que classes ou objetos o estendam com 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)
}
}O que significa sealed?
Um trait sealed só pode ser estendido por tipos declarados no mesmo arquivo.
Isso fecha a hierarquia: o compilador conhece a lista completa de possíveis 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)
}
}Objetos de caso como variantes
Quando uma variante não tem dados, use case object em vez de case class. Existe apenas uma instância.
Isso é perfeito para valores semelhantes aos de uma enumeração.
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)
}
}Combinando objetos e classes
Um trait sealed pode ter variantes case object (sem dados) e variantes case class (com dados).
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)
}
}Correspondência com um trait sealed
Você faz a correspondência com o trait e trata cada variante. Como a hierarquia é sealed, o compilador pode verificar se você cobriu todas elas.
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))
}
}Avisos do compilador
Se você esquecer uma variante em uma correspondência sobre um trait sealed, o compilador avisará sobre o caso ausente.
Isso detecta erros quando você adiciona uma nova variante posteriormente. Exploraremos esse assunto por completo na lição sobre correspondência exaustiva.
Traits podem declarar membros
Um trait pode declarar métodos ou campos que todos os subtipos compartilham ou devem 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 que usar sealed
Selar um trait oferece:
- Um conjunto conhecido e fechado de subtipos
- Verificação de exaustividade em
match - Refatoração mais segura ao adicionar variantes
Traits selados e classes de caso são a forma como Scala cria tipos de dados algébricos.
Usando a hierarquia
As funções podem aceitar o tipo do trait e trabalhar com qualquer variante, usando correspondência de padrões para decidir o comportamento.
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")))
}
}Reunindo tudo
Um trait selado com variantes variadas, compartilhado por meio de uma função que corresponde a 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)))
}
}Verificação rápida
Teste sua compreensão sobre traits selados.
Recapitulação
Você aprendeu sobre traits selados:
- Um
traitdefine um supertipo compartilhado sealedlimita os subtipos ao mesmo arquivo- Use
case objectpara variantes sem dados ecase classpara variantes com dados - Selar permite a verificação de exaustividade em
match
Aprenda Scala com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 39
- Aulas
- 143
Perguntas Frequentes
A aula “Traits seladas” é grátis?
Sim — o texto completo de “Traits 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Traits seladas”?
Hierarquias fechadas. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 2 de 4.
Quanto tempo leva a aula “Traits 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 Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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.