Case class
Contenitori di dati immutabili
Case class è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Che cos'è una case class?
Una case class è un tipo speciale di classe progettato per contenere dati immutabili. La si dichiara con case class.
Scala genera automaticamente molto codice utile, rendendo le case class la soluzione preferita per modellare i dati.
Dichiararne una
È sufficiente elencare i campi nell'elenco dei parametri. Ogni parametro diventa un campo immutabile.
Non è necessaria la parola chiave new per creare un'istanza.
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 automatico
Le case class ricevono gratuitamente un toString leggibile, che mostra il nome della classe e i valori dei campi.
Questo semplifica notevolmente il debug e la registrazione.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Uguaglianza basata sul valore
Le case class vengono confrontate in base al valore, non al riferimento. Due istanze con gli stessi campi sono uguali.
Le classi normali verrebbero invece confrontate in base all'identità.
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)
}
}Campi immutabili
I campi delle case class sono val per impostazione predefinita, quindi non possono essere riassegnati.
Per ottenere una versione modificata, si crea una nuova istanza anziché modificare quella esistente.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}Il metodo copy
Ogni case class dispone di un metodo copy. Crea una nuova istanza e consente di modificare solo i campi specificati.
Questo è il modo idiomatico di aggiornare dati immutabili.
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)
}
}Supporto al pattern matching
Le case class funzionano perfettamente con match. È possibile decostruirle assegnando un nome ai loro campi in un pattern.
Questo è uno dei motivi principali per usarle.
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)))
}
}Valori predefiniti dei parametri
Come le classi normali, le case class possono avere valori predefiniti per i parametri, che quindi possono essere omessi durante la costruzione.
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)
}
}Aggiungere metodi
Una case class può avere metodi propri nel corpo, proprio come qualsiasi altra classe. Questi operano sui campi immutabili.
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)
}
}Perché usare le case class?
Le case class forniscono gratuitamente:
- un costruttore conciso con campi immutabili
- un
toStringleggibile equalsehashCodebasati sul valore- un metodo
copy - il supporto completo al pattern matching
Sono la base per modellare i dati in Scala.
Mettere tutto insieme
In questo esempio viene creata una case class, che viene copiata, confrontata e analizzata tramite pattern matching.
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 rapida
Verifichi la Sua comprensione delle case class.
Riepilogo
Ha imparato che una case class modella dati immutabili con metodi di supporto generati automaticamente:
- Si crea senza
new; i campi sonovalimmutabili toStringgratuito,equals/hashCodebasati sul valorecopycrea copie modificate- Supporto integrato per il pattern matching
- Sono consentiti valori predefiniti e metodi personalizzati
Domande Frequenti
La lezione «Case class» è gratuita?
Sì — il testo completo di «Case class» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Case class»?
Contenitori di dati immutabili Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Case class»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.