Interfaces (Interface) no Kotlin

Neste artigo, você aprenderá sobre interfaces e como implementar interfaces no Kotlin com exemplos.

Interface Kotlin é semelhante ao Java 8No Kotlin. Elas podem conter definições de métodos abstratos e implementações de métodos não abstratos, mas não podem conter qualquer estado.

Isso significa que um interface pode ter propriedades, mas elas devem ser abstratas ou fornecer implementações de acessadores.

Recomendado para ler: Classe abstrata Kotlin

As classes abstratas no Kotlin são semelhantes aos interfaces, mas há uma diferença importante. As propriedades de uma classe abstrata não precisam ser abstratas ou fornecer implementações de acessadores.

Como definir um interface?

A palavra-chave interface é usada para definir interfaces em Kotlin. Por exemplo,

interface MyInterface {
　　　　var test: String　　　//Propriedades abstratas
　　　　fun foo()　　　　　　　　　　//Métodos abstratos
　　　　fun hello() = "Olá, aí!")　//Métodos com implementação padrão
}

Aqui,

• Crie o interface MyInterface.
  

• Este interface possui uma propriedade abstrata test e um método abstrato foo().
  

• Este interface também possui um método não abstrato hello().

Como implementar um interface?

Aqui está como uma classe ou objeto implementa um interface:

interface MyInterface {
　　　　val test: Int　　　//Propriedades abstratas
　　　　fun foo() : String　　　//Métodos abstratos (retornando uma string)
　　　　fun hello() {　　　//Métodos com implementação padrão
　　　　　　　　//　corpo (opcional)
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "Lol"
　　　　//Outro código
}

Aqui, a classe InterfaceImp implementa o interface MyInterface.

Esta classe sobrescreve os membros abstratos do interface (propriedade test e método foo()).

Exemplo: como o interface funciona?

interface MyInterface {
　　　　val test: Int
　　　　fun foo() : String
　　　　fun hello() {
　　　　　　　　println("Olá, camarada!")
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "Lol"
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println("test = ${obj.test}")
　　　　print("Chamando hello(): ")
　　　　obj.hello()
　　　　print("Chamando e imprimindo foo(): ")
　　　　println(obj.foo())
}

Quando você executar o programa, a saída será:

test =　25
Chamando hello(): 你好，伙计!
Chamando e imprimindo foo(): Lol

Como mencionado anteriormente, uma interface pode ter propriedades que forneçam implementação de acessores. Por exemplo,

interface MyInterface {
　　　　//Propriedades com implementação
　　　　val prop: Int
　　　　　　　　get() =　23
}
class InterfaceImp: MyInterface {
　　　　//Corpo da classe
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println(obj.prop)
}

Quando você executar o programa, a saída será:

23

Aqui, prop não é abstrata, mas é válida na interface porque fornece a implementação do acessor.

Mas você não pode executar no interior de uma interface algo como val prop: Int = 23 operações.

Implementando duas ou mais interfaces em uma classe

O Kotlin não permite herança múltipla real. No entanto, você pode implementar duas ou mais interfaces em uma classe. Por exemplo,

interface A {
　　　　fun callMe() {
　　　　　　　　println("Vindo da interface A")
　　　　}
}
interface B {
　　　　fun callMeToo() {
　　　　　　　　println("Vindo da interface B")
　　　　}
}
//Implementando duas interfaces A e B
class Child: A, B
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
　　　　obj.callMeToo()
}

Quando você executar o programa, a saída será:

Vindo da interface A
Vindo da interface B

Resolvendo conflitos de sobrescrita (mult interf)

Suponha que duas interfaces (A e B) tenham métodos não abstratos com o mesmo nome (suponha o método callMe()). Você implementa essas duas interfaces em uma classe (suponha C). Agora, se você usar um objeto da classe C para chamar o método callMe(), o compilador gerará um erro. Por exemplo

interface A {
　　　　fun callMe() {
　　　　　　　　println("interface A")
　　　　}
}
interface B {
　　　　fun callMe() {
　　　　　　　　println("interface B")
　　　　}
}
class Child: A, B　
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
}

Este é o erro lançado:

Error: (14,　1Error: () Kotlin: A classe 'C' deve overrides a função pública aberta fun callMe(): Unit definida em A porque herda múltiplos métodos de interface dessa classe

Para resolver esse problema, você precisa fornecer sua própria implementação. Saiba como fazer isso:

interface A {
　　　　fun callMe() {
　　　　　　　　println("interface A")
　　　　}
}
interface B {
　　　　fun callMe() {
　　　　　　　　println("interface B")
　　　　}
}
class　C:　A,　B　{
　　　　override　fun　callMe()　{
　　　　　　　　super<A>.callMe()
　　　　　　　　super<B>.callMe()
　　　　}
}
fun main(args: Array<String>) {
　　　　val　obj　=　C()
　　　　obj.callMe()
}

Agora, quando você executar o programa, a saída será:

Interface　　A
Interface　　B

Aqui, fornece-se uma implementação explícita do método callMe() na classe C.

class　C:　A,　B　{
　　　　override　fun　callMe()　{
　　　　　　　　super<A>.callMe()
　　　　　　　　super<B>.callMe()
　　　　}
}

A sentença super<A>.callMe() chama o método callMe() da classe A. Da mesma forma, super<B>.callMe() chama o método callMe() da classe B.