Classi aperte e sottoclassi

Fa parte della sezione Programmazione orientata agli oggetti del percorso Kotlin di Coddy. Lezione 17 di 57.

L'ereditarietà permette a una classe di basarsi su un'altra. La sottoclasse eredita tutte le proprietà e i metodi della sua superclasse e può aggiungerne di propri. In Kotlin, le classi sono chiuse per impostazione predefinita, quindi una classe deve essere contrassegnata come open prima che un'altra classe possa estenderla:

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

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

Dentro main:

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

Output:

Rex is an animal
Rex fetches the ball

class Dog(name: String) : Animal(name) indica che Dog estende Animal e passa name al costruttore della superclasse. Il parametro non ha val, perché la proprietà esiste già in Animal. Una classe che non è open non può essere estesa:

class Plant(val name: String)
// class Tree(name: String) : Plant(name)   // errore: questo tipo è final, quindi non può essere esteso

open class Vehicle(val wheels: Int)
class Bike : Vehicle(2)                     // passa un valore fisso
class Truck(val load: Int) : Vehicle(6)     // aggiunge una proprietà propria

Un Dog è un Animal, quindi un'istanza di sottoclasse può essere usata ovunque sia previsto il tipo della superclasse. Una List<Animal> può contenere cani, gatti e animali generici, e ogni elemento dispone dei membri di 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)

All'interno di main:

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

Output:

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

L'ereditarietà modella una relazione is-a: un cane è un animale, un conto di risparmio è un conto. Quando una classe si limita a usare un'altra (un'auto ha un motore), assegnale invece una proprietà di quel tipo. In Kotlin le classi sono chiuse per impostazione predefinita, quindi una classe destinata a essere estesa lo dichiara con open, mentre tutte le altre mantengono il proprio comportamento al sicuro dalle sottoclassi.

open class Account(val owner: String)
class SavingsAccount(owner: String) : Account(owner)   // è un: ereditarietà

class Engine(val horsepower: Int)
class Car(val engine: Engine)                          // ha un: una proprietà

Sfida

Facile

Manager ripete ciò che Employee ha già. Rendi Employee open e trasforma Manager nella sua sottoclasse: Manager(name: String, salary: Int) passa entrambi i valori a Employee e conserva solo ciò che è nuovo, un elenco privato di nomi dei collaboratori con addReport(name) e teamSize(). In Employee, raise(percent) aumenta lo stipendio della percentuale indicata, arrotondando per difetto, e describe() restituisce Ada earns 5500.

Il codice fornito crea un manager a partire dalla prima riga (name,salary), aggiunge ogni nome successivo come collaboratore, concede un aumento del 10% e stampa Ada earns 5500 and leads 2, quindi verifica che un manager sia un Employee.

Il tuo codice va inserito in Employee.kt e Manager.kt. Main.kt contiene il codice di input/output fornito e non può essere modificato.

Provalo tu

fun main() {
    // Codice di input/output fornito: lascialo così com'è
    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}")
}