Classi aperte e sottoclassi

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

L'ereditarietà consente 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 con 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"
}

All'interno di 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 propria proprietà

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 ha i 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 è-un: un cane è un animale, un conto di risparmio è un conto. Quando una classe ne usa soltanto 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 pensata per 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)   // is-a: ereditarietà

class Engine(val horsepower: Int)
class Car(val engine: Engine)                          // has-a: 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 mantiene solo ciò che è nuovo, un elenco privato di nomi dei riporti con addReport(name) e teamSize(). In Employee, raise(percent) aumenta lo stipendio di quella percentuale, arrotondato 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 riporto, applica un aumento del 10% e stampa Ada earns 5500 and leads 2, poi verifica che un manager sia un Employee.

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

Provalo tu

fun main() {
    // Supplied input/output code: keep it as it is
    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}")
}