Classes case
Portadores de dados imutáveis.
Classes case é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 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 é uma classe de caso?
Uma classe de caso é um tipo especial de classe projetado para armazenar dados imutáveis. Você a declara com case class.
Scala gera automaticamente muito código útil para você, tornando as classes de caso a opção padrão para modelar dados.
Declarando uma
Basta listar os campos na lista de parâmetros. Cada parâmetro se torna um campo imutável.
Nenhuma palavra-chave new é necessária para criar uma instância.
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
As classes de caso recebem gratuitamente um toString legível, que exibe o nome da classe e os valores dos campos.
Isso facilita a depuração e o registro de informações.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Igualdade por valor
As classes de caso são comparadas pelo valor, não pela referência. Duas instâncias com os mesmos campos são iguais.
As classes comuns seriam comparadas pela identidade.
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 imutáveis
Os campos de uma classe de caso são val por padrão, portanto não podem ser reatribuídos.
Para obter uma versão modificada, você cria uma nova instância em vez de alterar a antiga.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}O método copy
Toda classe de caso tem um método copy. Ele cria uma nova instância e permite alterar apenas os campos que você nomear.
Essa é a maneira idiomática de atualizar dados imutáveis.
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)
}
}Suporte à correspondência de padrões
As classes de caso funcionam perfeitamente com match. Você pode desconstruí-las nomeando seus campos em um padrão.
Esse é um dos principais motivos para usá-las.
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 padrão de parâmetros
Assim como as classes comuns, as classes de caso podem ter valores padrão para os parâmetros, permitindo que você os omita ao construir uma instância.
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)
}
}Adicionando métodos
Uma classe de caso pode ter seus próprios métodos no corpo, assim como qualquer classe. Eles operam sobre os campos imutáveis.
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 que usar classes de caso?
As classes de caso oferecem gratuitamente:
- Um construtor conciso com campos imutáveis
toStringlegívelequalsehashCodebaseados em valor- Um método
copy - Suporte de primeira classe à correspondência de padrões
Elas são a base para modelar dados em Scala.
Reunindo tudo
Aqui, uma classe de caso é criada, copiada, comparada e usada em uma correspondência de padrões, tudo em um único exemplo.
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")
}
}
}Verificação rápida
Teste sua compreensão de classes de caso.
Recapitulação
Você aprendeu que uma classe de caso modela dados imutáveis com recursos auxiliares gerados automaticamente:
- Construa sem
new; os campos sãovals imutáveis toStringgratuito eequals/hashCodebaseados em valorcopycria cópias modificadas- Suporte integrado à correspondência de padrões
- Valores padrão e métodos personalizados são permitidos
Perguntas Frequentes
A aula “Classes case” é grátis?
Sim — o texto completo de “Classes case” é 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 “Classes case”?
Portadores de dados imutáveis. 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 1 de 4.
Quanto tempo leva a aula “Classes case”?
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.