Offene Klassen und Unterklassen

Teil des Abschnitts Objektorientierte Programmierung der Kotlin-Journey von Coddy. Lektion 17 von 57.

Vererbung ermöglicht es einer Klasse, auf einer anderen aufzubauen. Die Unterklasse erhält jede Eigenschaft und Methode ihrer Oberklasse und kann eigene hinzufügen. Kotlin-Klassen sind standardmäßig geschlossen, daher muss eine Klasse mit open gekennzeichnet werden, bevor eine andere Klasse sie erweitern kann:

open class Animal(val name: String) {
    fun describe() = "$name is an animal"
}

class Dog(name: String) : Animal(name) {
    fun fetch() = "$name fetches the ball"
}

Innerhalb von main:

val rex = Dog("Rex")
println(rex.describe())
println(rex.fetch())

Ausgabe:

Rex is an animal
Rex fetches the ball

class Dog(name: String) : Animal(name) besagt, dass Dog Animal erweitert und name an den Konstruktor der Oberklasse weitergibt. Der Parameter hat kein val, weil die Eigenschaft bereits in Animal vorhanden ist. Eine Klasse, die nicht open ist, kann nicht erweitert werden:

class Plant(val name: String)
// class Tree(name: String) : Plant(name)   // Fehler: dieser Typ ist final, daher kann er nicht erweitert werden

open class Vehicle(val wheels: Int)
class Bike : Vehicle(2)                     // übergibt einen festen Wert
class Truck(val load: Int) : Vehicle(6)     // fügt seine eigene Eigenschaft hinzu

Ein Dog ist ein Animal, daher kann eine Instanz einer Unterklasse überall dort verwendet werden, wo der Typ der Oberklasse erwartet wird. Eine List<Animal> kann Hunde, Katzen und gewöhnliche Tiere enthalten, und jedes Element verfügt über die Member von Animal:

open class Animal(val name: String) {
    fun describe() = "$name is an animal"
}
class Dog(name: String) : Animal(name)
class Cat(name: String, val indoor: Boolean) : Animal(name)

Innerhalb von main:

val pets: List<Animal> = listOf(Dog("Rex"), Cat("Tom", true), Animal("Generic"))
for (p in pets) println(p.describe())

Ausgabe:

Rex is an animal
Tom is an animal
Generic is an animal

Vererbung modelliert eine ist-eine-Beziehung: Ein Hund ist ein Tier, ein Sparkonto ist ein Konto. Wenn eine Klasse lediglich eine andere verwendet (ein Auto hat einen Motor), gib ihr stattdessen eine Eigenschaft dieses Typs. Geschlossene Klassen sind in Kotlin der Standard, sodass eine Klasse, die zur Erweiterung gedacht ist, dies mit open angibt und jede andere Klasse ihr Verhalten vor Unterklassen schützt.

open class Account(val owner: String)
class SavingsAccount(owner: String) : Account(owner)   // is-a: Vererbung

class Engine(val horsepower: Int)
class Car(val engine: Engine)                          // has-a: eine Eigenschaft

Aufgabe

Einfach

Manager wiederholt, was Employee bereits hat. Mache Employee offen und verwandle Manager in dessen Unterklasse: Manager(name: String, salary: Int) übergibt beide Werte an Employee und behält nur das Neue, eine private Liste von Namen der Mitarbeiter mit addReport(name) und teamSize(). In Employee erhöht raise(percent) das Gehalt um diesen Prozentsatz, abgerundet, und describe() gibt Ada earns 5500 zurück.

Der bereitgestellte Code erstellt aus der ersten Zeile (name,salary) einen Manager, fügt jeden folgenden Namen als Mitarbeiter hinzu, gewährt eine Gehaltserhöhung von 10 % und gibt Ada earns 5500 and leads 2 aus. Anschließend wird überprüft, dass ein Manager ein Employee ist.

Dein Code gehört in Employee.kt und Manager.kt. Main.kt enthält den bereitgestellten Eingabe-/Ausgabecode und kann nicht bearbeitet werden.

Probier es selbst

fun main() {
    // Bereitgestellter Ein-/Ausgabe-Code: belasse ihn wie er ist
    val input = generateSequence(::readLine).toList()
    val (name, salary) = input[0].split(",")
    val boss = Manager(name, salary.toInt())
    for (report in input.drop(1)) boss.addReport(report)
    boss.raise(10)
    println("${boss.describe()} and leads ${boss.teamSize()}")
    println("a manager is an employee: ${(boss as Any) is Employee}")
}