Was ist der Unterschied zwischen sealed-Klassen und abstrakten Klassen in Kotlin?

Der Hauptunterschied zwischen sealed-Klassen und abstrakten Klassen besteht darin, dass sealed-Klassen die Vererbungshierarchie auf eine Datei oder ein Modul beschränken (für Kotlin 1.5+). Die Nachkommen einer sealed-Klasse müssen in derselben Datei wie die sealed-Klasse selbst deklariert werden, was eine vollständige Überprüfung bei der Verwendung von when-Ausdrücken gewährleistet.

Unterschiede:

• Vererbung:
  • Abstrakte Klassen können überall im Projekt vererbt werden.
  • Sealed-Klassen können nur innerhalb derselben Datei (vor Kotlin 1.5) oder im selben Modul (ab Kotlin 1.5+) vererbt werden.
• Verwendung mit when:
  • Bei Verwendung von when mit einem sealed-Typ kann der Compiler überprüfen, ob alle möglichen Untertypen berücksichtigt wurden, was when vollständig macht und das explizite Angeben eines else-Zweigs überflüssig macht, wenn alle Untertypen behandelt werden.
  • Bei abstrakten Klassen kann der Compiler die Vollständigkeit nicht garantieren, daher ist oft ein else erforderlich.
• Erstellung von Instanzen:
  • Weder abstrakte noch sealed-Klassen können direkt instanziiert werden.
• Mitglieder:
  • Sowohl abstrakte als auch sealed-Klassen können abstrakte und nicht abstrakte Mitglieder haben.

Beispiel für eine sealed-Klasse:

sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
}

fun processResult(result: Result<Int>) {
    when (result) {
        is Result.Success -> {
            // Verarbeitung des erfolgreichen Ergebnisses
            println("Erfolg: ${result.data}")
        }
        is Result.Error -> {
            // Fehlerbehandlung
            println("Fehler: ${result.message}")
        }
        // Kein else erforderlich, wenn alle Nachkommen behandelt werden
    }
}

Beispiel für eine abstrakte Klasse:

abstract class Shape {
    abstract fun area(): Double
}

class Circle(val radius: Double) : Shape() {
    override fun area(): Double = Math.PI * radius * radius
}

class Rectangle(val width: Double, val height: Double) : Shape() {
    override fun area(): Double = width * height
}

fun calculateArea(shape: Shape): Double {
    return shape.area()
}

Wann verwenden:

• Sealed-Klassen: Ideal zur Darstellung einer begrenzten Anzahl möglicher Zustände oder Typen, wenn eine vollständige Überprüfung in when-Ausdrücken erforderlich ist. Werden häufig zur Modellierung von Operationsergebnissen (Erfolg/Fehler), UI-Zuständen, Ereignissen verwendet.
• Abstrakte Klassen: Geeignet zur Definition allgemeiner Funktionalitäten und Verträge für eine Gruppe verwandter Klassen, die überall im Projekt vererbt werden können.

Kurz gesagt, bieten sealed-Klassen eine strengere Kontrolle über die Vererbungshierarchie und verbessern die Sicherheit und Lesbarkeit des Codes bei der Verarbeitung einer begrenzten Anzahl von Untertypen.