Dichiarare le interfacce

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

Un’interfaccia elenca ciò che un tipo può fare senza specificare come. Dichiara metodi e proprietà che ogni classe che la implementa deve fornire. Una classe implementa un’interfaccia con i due punti, come avviene con una superclasse, ma senza parentesi, perché un’interfaccia non ha un costruttore:

interface Drawable {
    fun draw(): String
}
class Circle(val radius: Int) : Drawable {
    override fun draw() = "circle with radius $radius"
}
class Line(val length: Int) : Drawable {
    override fun draw() = "-".repeat(length)
}

All’interno di main:

println(Circle(3).draw())
println(Line(5).draw())

Output:

circle with radius 3
-----

Un'interfaccia può dichiarare anche proprietà. La classe le fornisce come proprietà del costruttore, proprietà memorizzate o getter; l'interfaccia stessa non memorizza nulla:

interface Vehicle {
    val wheels: Int
    val label: String
}
class Car(override val label: String) : Vehicle {
    override val wheels = 4
}
class Bike : Vehicle {
    override val wheels = 2
    override val label: String
        get() = "bike on $wheels wheels"
}

All'interno di main:

println("${Car("taxi").label}: ${Car("taxi").wheels}")
println(Bike().label)

Output:

taxi: 4
bike on 2 wheels

Ogni membro dichiarato dall’interfaccia deve essere implementato, ciascuno con override, altrimenti la classe non viene compilata. Non è possibile istanziare un’interfaccia:

interface Speaker {
    fun speak(): String
    val volume: Int
}
// class Mute : Speaker { override fun speak() = "" }   // errore: volume non è implementato
// class Loud : Speaker() { ... }                      // errore: un'interfaccia non ha un costruttore
// val s = Speaker()                                   // errore: non è possibile creare un'interfaccia

Sia un'interfaccia sia una classe astratta dichiarano membri senza un corpo. Un'interfaccia non ha un costruttore né uno stato memorizzato, e una classe può implementare molte interfacce ma estendere una sola classe. Usa un'interfaccia per una capacità condivisa da classi non correlate, come Drawable o Comparable, e una classe astratta come base comune dotata di stato.

interface Drawable { fun draw(): String }                   // una capacità
abstract class Shape(val name: String) { abstract fun area(): Double }   // una classe base con stato
class Square(val s: Double) : Shape("square"), Drawable {  // una classe, un numero qualsiasi di interfacce
    override fun area() = s * s
    override fun draw() = "[]"
}

Sfida

Facile

Dichiara i membri dell’interfaccia Shape: una proprietà di sola lettura name e i metodi area() e perimeter(), entrambi con valore restituito Double. Fai in modo che Rectangle(width, height) (nome rectangle) e Circle(radius) (nome circle, che usa Math.PI) li implementino. Poi completa describe(shape), che restituisce rectangle: area 12.00, perimeter 14.00 con due cifre decimali, usando solo i membri di Shape.

Il codice fornito legge righe come r,3,4 o c,2, crea la forma corrispondente e stampa describe(shape).

Il tuo codice va inserito in Shape.kt, Rectangle.kt, Circle.kt e Functions.kt. Main.kt contiene il codice fornito per l’input/output e non può essere modificato.

Provalo tu

fun main() {
    // Codice di input/output fornito: lascialo così com'è
    val input = generateSequence(::readLine).toList()
    for (line in input) {
        val p = line.split(",").map { it.trim() }
        val shape: Shape = if (p[0] == "r") Rectangle(p[1].toDouble(), p[2].toDouble()) else Circle(p[1].toDouble())
        println(describe(shape))
    }
}