Declarando Interfaces

Parte da seção Programação Orientada a Objetos do Journey de Kotlin da Coddy. Lição 22 de 57.

Uma interface lista o que um tipo pode fazer sem dizer como. Ela declara métodos e propriedades que toda classe que a implementa deve fornecer. Uma classe implementa uma interface com dois-pontos, assim como uma superclasse, mas sem parênteses, porque uma interface não tem construtor:

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)
}

Dentro de main:

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

Saída:

circle with radius 3
-----

Uma interface também pode declarar propriedades. A classe as fornece como propriedades do construtor, propriedades armazenadas ou getters; a própria interface não armazena nada:

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"
}

Dentro de main:

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

Saída:

taxi: 4
bike on 2 wheels

Cada membro declarado pela interface deve ser implementado, cada um com override, ou a classe não compila. Uma interface não pode ser instanciada:

interface Speaker {
    fun speak(): String
    val volume: Int
}
// class Mute : Speaker { override fun speak() = "" }   // erro: volume não está implementado
// class Loud : Speaker() { ... }                      // erro: uma interface não tem construtor
// val s = Speaker()                                   // erro: não é possível criar uma interface

Uma interface e uma classe abstrata declaram membros sem um corpo. Uma interface não tem construtor nem estado armazenado, e uma classe pode implementar muitas interfaces, mas estender apenas uma classe. Use uma interface para uma capacidade compartilhada por classes não relacionadas, como Drawable ou Comparable, e uma classe abstrata para uma base comum com estado.

interface Drawable { fun draw(): String }                   // uma capacidade
abstract class Shape(val name: String) { abstract fun area(): Double }   // uma base com estado
class Square(val s: Double) : Shape("square"), Drawable {  // uma classe, quaisquer interfaces
    override fun area() = s * s
    override fun draw() = "[]"
}

Desafio

Fácil

Declare os membros da interface Shape: uma propriedade somente leitura name e os métodos area() e perimeter(), ambos retornando Double. Faça Rectangle(width, height) (nome rectangle) e Circle(radius) (nome circle, usando Math.PI) implementá-los. Em seguida, complete describe(shape), que retorna rectangle: area 12.00, perimeter 14.00 com duas casas decimais, usando apenas membros de Shape.

O código fornecido lê linhas r,3,4 ou c,2, cria a forma correspondente e imprime describe(shape).

Seu código deve estar em Shape.kt, Rectangle.kt, Circle.kt e Functions.kt. Main.kt contém o código fornecido de entrada/saída e não pode ser editado.

Experimente você mesmo

fun main() {
    // Código de entrada/saída fornecido: mantenha-o como está
    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))
    }
}