Cechy sealed
Zamknięte hierarchie
Cechy sealed to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 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 trait?
trait przypomina interfejs: deklaruje wspólny typ, który mogą rozszerzać inne klasy.
Traits pozwalają grupować powiązane typy pod jednym wspólnym typem, dzięki czemu można ich używać zamiennie.
Podstawowy trait
Trait deklaruje się za pomocą trait, a następnie rozszerza w klasach lub obiektach za pomocą 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)
}
}Co oznacza sealed?
sealed trait może być rozszerzany wyłącznie przez typy zadeklarowane w tym samym pliku.
Zamyka to hierarchię: kompilator zna kompletną listę możliwych podtypów.
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)
}
}Case objects jako warianty
Gdy wariant nie zawiera danych, użyj case object zamiast case class. Zawsze istnieje tylko jedna jego instancja.
To idealne rozwiązanie dla wartości przypominających elementy enuma.
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)
}
}Łączenie obiektów i klas
Sealed trait może zawierać zarówno warianty case object (bez danych), jak i warianty case class (z danymi).
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)
}
}Dopasowywanie do sealed trait
Dopasowujesz wartość do trait i obsługujesz każdy wariant. Ponieważ hierarchia jest sealed, kompilator może sprawdzić, czy uwzględniono wszystkie warianty.
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))
}
}Ostrzeżenia kompilatora
Jeśli pominiesz wariant w dopasowaniu do sealed trait, kompilator ostrzeże o brakującym przypadku.
Pomaga to wykrywać błędy, gdy później dodasz nowy wariant. Omówimy to dokładnie w lekcji o wyczerpującym dopasowywaniu.
Traits mogą deklarować składowe
Trait może deklarować metody lub pola, które wszystkie podtypy współdzielą albo muszą zaimplementować.
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)
}
}Dlaczego sealed?
Oznaczenie trait jako sealed zapewnia:
- Znany, zamknięty zbiór podtypów
- Sprawdzanie kompletności w
match - Bezpieczniejsze refaktoryzowanie podczas dodawania wariantów
Sealed traits wraz z case classes to sposób, w jaki Scala tworzy algebraiczne typy danych.
Korzystanie z hierarchii
Funkcje mogą przyjmować typ trait i działać z dowolnym wariantem, wybierając odpowiednią obsługę za pomocą dopasowywania wzorców.
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")))
}
}Połączenie wszystkiego
Sealed trait z mieszanymi wariantami, udostępniany przez funkcję dopasowującą każdy przypadek.
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)))
}
}Szybkie sprawdzenie
Sprawdź, jak rozumiesz sealed traits.
Podsumowanie
Dowiedziałeś się o sealed traits:
traitdefiniuje wspólny nadtypsealedogranicza podtypy do tego samego pliku- Używaj
case objectdla wariantów bez danych, acase classdla wariantów z danymi - Sealed umożliwia sprawdzanie kompletności w
match
Często zadawane pytania
Czy lekcja „Cechy sealed” jest bezpłatna?
Tak — pełny tekst „Cechy sealed” 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 „Cechy sealed”?
Zamknięte hierarchie Ć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 2 z 4.
Ile czasu zajmuje lekcja „Cechy sealed”?
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.