Classes case
Conteneurs de données immuables
Classes case est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu’est-ce qu’une classe case ?
Une classe case est un type particulier de classe conçu pour contenir des données immuables. Vous la déclarez avec case class.
Scala génère automatiquement beaucoup de code utile, ce qui fait des classes case la solution privilégiée pour modéliser les données.
En déclarer une
Il suffit d’indiquer les champs dans la liste des paramètres. Chaque paramètre devient un champ immuable.
Le mot-clé new n’est pas nécessaire pour créer une instance.
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 automatique
Les classes case bénéficient gratuitement d’un toString lisible, qui affiche le nom de la classe et les valeurs des champs.
Cela simplifie considérablement le débogage et la journalisation.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Égalité par valeur
Les classes case sont comparées par valeur, et non par référence. Deux instances ayant les mêmes champs sont égales.
Les classes ordinaires seraient comparées selon leur 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)
}
}Champs immuables
Les champs d’une classe case sont des val par défaut ; ils ne peuvent donc pas être réaffectés.
Pour obtenir une version modifiée, vous créez une nouvelle instance au lieu de modifier l’ancienne.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}La méthode copy
Toute classe case possède une méthode copy. Elle crée une nouvelle instance et vous permet de modifier uniquement les champs que vous indiquez.
C’est la manière idiomatique de mettre à jour des données immuables.
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)
}
}Prise en charge de la correspondance par motif
Les classes case fonctionnent parfaitement avec match. Vous pouvez les déconstruire en nommant leurs champs dans un motif.
C’est l’une des principales raisons de les utiliser.
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)))
}
}Valeurs de paramètres par défaut
Comme les classes normales, les classes case peuvent définir des valeurs par défaut pour leurs paramètres ; vous pouvez donc les omettre lors de la construction.
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)
}
}Ajouter des méthodes
Une classe case peut posséder ses propres méthodes dans son corps, comme n’importe quelle classe. Elles opèrent sur les champs immuables.
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)
}
}Pourquoi utiliser les classes case ?
Les classes case vous offrent gratuitement :
- Un constructeur concis avec des champs immuables
- Un
toStringlisible - Les méthodes
equalsethashCodefondées sur la valeur - Une méthode
copy - La correspondance par motif comme fonctionnalité de premier ordre
Elles constituent la base de la modélisation des données en Scala.
Mettre tout ensemble
Ici, une classe case est créée, copiée, comparée et utilisée dans une correspondance par motif, le tout dans un seul exemple.
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")
}
}
}Vérification rapide
Vérifiez votre compréhension des classes case.
Récapitulatif
Vous avez appris qu’une classe case modélise des données immuables avec des outils générés automatiquement :
- Construisez-la sans
new; les champs sont desvalimmuables toString,equals/hashCodefondés sur la valeur, disponibles gratuitementcopycrée des copies modifiées- Prise en charge intégrée de la correspondance par motif
- Les valeurs par défaut et les méthodes personnalisées sont autorisées
Questions Fréquemment Posées
La leçon « Classes case » est-elle gratuite ?
Oui — le texte complet de « Classes case » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Classes case » ?
Conteneurs de données immuables Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Classes case » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.