Interfaces em Kotlin

Hoje vamos nos aprofundar no entendimento de Programação Orientada a Objetos em Kotlin, veremos como a linguagem lida com interfaces e suas diferenças em relação a Java. As interfaces de Kotlin se diferenciam da sua equivalente em Java. Em Kotlin, as interfaces podem conter declarações de propriedades, por exemplo, algo que não ocorre em Java.

Similarmente a Java, elas podem conter definições de métodos abstratos assim como definições de métodos não abstratos, mas elas não podem conter nenhum estado.

interface Clickable {
    fun click()
}

Para criar um interface usamos a palavra-chave interface, seguida de seu nome e chaves. No exemplo acima temos uma interface chamada Clickable que contém a definição de um método abstrato chamado click(). Qualquer classe não abstrata que implemente essa interface será obrigada a implementar esse método:

class Button : Clickable {
    override fun click() = println("I was clicked")
}

>>> Button().click()
I was clicked

A classe desenvolvida acima Button implementa a interface Clickable (indicado pelos :, que substituem ambas as palavras-chave implements e extends de Java) e sobrescreve o método click(). Essa sobrescrita foi indicada pelo modificador override que é obrigatório em Kotlin, diferentemente de Java.

Como dito anteriormente, as interfaces tanto em Kotlin quanto em Java podem ter definições de métodos não abstratos, com a diferença que a notação default não é necessária:

Kotlin:

interface Clickable {
    fun click()
    fun showOff() = println("I'm clickable!")
}

Java 8:

interface Clickable {
    void click();
    default void showOff() {
        System.out.println("I'm clickable!")
    }
}

Implementando propriedades declaradas em interfaces

Se uma interface declarou uma ou mais propriedades, todas as classes que a implementam devem dar algum jeito de obter o valor dessa ou dessas propriedades.

Interface User:

interface User {
    val nickname: String
}

Vamos observar três possíveis formas de se inicializar a propriedade nickname da interface User em três classes que a implementam: PrivateUser, SubscribingUser e FacebookUser:

class PrivateUser(override val nickname: String) : User

class SubscribingUser(val email: String) : User {
    override val nickname: String
            get() = email.substringBefore('@')
}

class FacebookUser(val accountId: Int) : User {
    override val nickname = getFacebookName(accountId)
}

A primeira classe PrivateUser diz que o valor da propriedade será passado no construtor primário dela mesma, a classe SubscribingUser desenvolve um getter customizado para obter o valor da propriedade e, por fim, a classe FacebookUser apenas inicializa a propriedade de cara. Note que todas as implementações da propriedade foram marcadas com o modificador override.

As interfaces em Kotlin também podem conter getters e setters, mas não podem armazenar dados, visto que isso seria armazenar um estado, o que não é permitido como já dito. Vamos ver um exemplo:

interface User {
    val email: String
    val nickname: String
        get() = email.substringBefore('@')
}

Podemos ver que o valor da propriedade não é armazenado na interface, mas sim calculado todas as vezes que ela é implementada.

Fonte

O post de hoje foi baseado totalmente no incrível e conciso capítulo 4 de Kotlin in Action de Dmitry Jemerov e Svetlana Isakova. Confira o material original para maior entendimento de interfaces na nossa querida linguagem Kotlin.

Próximos posts

Nos próximos post vamos finalizar nossos estudo em Kotlin entendendo como a linguagem lida com classes e objetos. Obrigado pela atenção e até a próxima!

Post anterior:

Estruturas de controle em Kotlin

Ronaldo Costa de Freitas ・ Nov 8 ・ 5 min read

#kotlin #java