Klasy case
Niezmienne nośniki danych
Klasy case to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Czym jest klasa case?
Klasa case to szczególny rodzaj klasy przeznaczony do przechowywania niezmiennych danych. Deklaruje się ją za pomocą case class.
Scala automatycznie generuje wiele przydatnego kodu, dzięki czemu klasy case są podstawowym sposobem modelowania danych.
Deklarowanie klasy
Wystarczy wymienić pola na liście parametrów. Każdy parametr staje się niezmiennym polem.
Do utworzenia instancji nie jest wymagane słowo kluczowe new.
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)
}
}Automatyczne toString
Klasy case bez dodatkowej pracy otrzymują czytelną metodę toString, pokazującą nazwę klasy i wartości pól.
Ułatwia to debugowanie i rejestrowanie informacji.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Równość wartości
Klasy case są porównywane według wartości, a nie referencji. Dwie instancje z takimi samymi polami są równe.
Zwykłe klasy byłyby porównywane według tożsamości.
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)
}
}Niezmienne pola
Pola klas case są domyślnie typu val, więc nie można przypisywać im nowych wartości.
Aby uzyskać zmodyfikowaną wersję, trzeba utworzyć nową instancję zamiast zmieniać starą.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}Metoda copy
Każda klasa case ma metodę copy. Tworzy ona nową instancję i pozwala zmienić tylko wskazane pola.
Jest to idiomatyczny sposób aktualizowania niezmiennych danych.
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)
}
}Obsługa dopasowywania wzorców
Klasy case bezproblemowo współpracują z match. Można je dekonstruować, nazywając ich pola we wzorcu.
To jeden z najważniejszych powodów, aby ich używać.
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)))
}
}Domyślne wartości parametrów
Podobnie jak zwykłe klasy, klasy case mogą mieć domyślne wartości parametrów, dzięki czemu można pomijać je podczas tworzenia instancji.
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)
}
}Dodawanie metod
Klasa case może mieć własne metody w swoim ciele, tak jak każda klasa. Metody te działają na niezmiennych polach.
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)
}
}Dlaczego klasy case?
Klasy case zapewniają bez dodatkowej pracy:
- zwięzły konstruktor z niezmiennymi polami
- czytelną metodę
toString - oparte na wartości metody
equalsihashCode - metodę
copy - pełnoprawną obsługę dopasowywania wzorców
Stanowią podstawę modelowania danych w Scali.
Połączenie elementów
W tym przykładzie klasa case jest tworzona, kopiowana, porównywana i dopasowywana za pomocą wzorców.
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")
}
}
}Szybki test
Sprawdź swoją wiedzę o klasach case.
Podsumowanie
Dowiedziałeś się, że case class modeluje niezmienne dane i udostępnia automatycznie generowane elementy pomocnicze:
- Można ją tworzyć bez użycia
new; pola są niezmiennymi wartościamival - Bezpłatne
toStringoraz oparte na wartościachequals/hashCode copytworzy zmodyfikowane kopie- Wbudowana obsługa dopasowywania wzorców
- Dozwolone są wartości domyślne i niestandardowe metody
Często zadawane pytania
Czy lekcja „Klasy case” jest bezpłatna?
Tak — pełny tekst „Klasy case” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Co nauczysz się w „Klasy case”?
Niezmienne nośniki danych Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?
Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Klasy case”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?
Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.