Neste artigo, você aprenderá sobre interfaces e como implementá-las em Kotlin com a ajuda de exemplos.
As interfaces Kotlin são semelhantes às interfaces em Java 8. Elas podem conter definições de métodos abstratos, bem como implementações de métodos não abstratos. No entanto, eles não podem conter nenhum estado.
Ou seja, a interface pode ter uma propriedade, mas precisa ser abstrata ou fornecer implementações de acessador.
Leitura recomendada: aula abstrata de Kotlin
As classes abstratas no Kotlin são semelhantes à interface, com uma diferença importante. Não é obrigatório que as propriedades de uma classe abstrata sejam abstratas ou forneçam implementações de acessador.
Como definir uma interface?
A palavra interface- chave é usada para definir interfaces em Kotlin. Por exemplo,
interface MyInterface (var test: String // propriedade abstrata fun foo () // método abstrato fun hello () = "Olá" // método com implementação padrão)
Aqui,
- uma interface MyInterface é criada.
- a interface tem um teste de propriedade abstrato e um método abstrato
foo(). - a interface também possui um método não abstrato
hello().
Como implementar interface?
Veja como uma classe ou objeto pode implementar a interface:
interface MyInterface (val test: Int // propriedade abstrata fun foo (): String // método abstrato (retorna String) fun hello () (// método com implementação padrão // corpo (opcional))) classe InterfaceImp: MyInterface (override val test: Int = 25 override fun foo () = "Lol" // outro código)
Aqui, uma classe InterfaceImp implementa a interface MyInterface.
A classe substitui membros abstratos (propriedade e foo()método de teste ) da interface.
Exemplo: Como funciona a interface?
interface MyInterface ( val test: Int fun foo() : String fun hello() ( println("Hello there, pal!") ) ) class InterfaceImp : MyInterface ( override val test: Int = 25 override fun foo() = "Lol" ) fun main(args: Array) ( val obj = InterfaceImp() println("test = $(obj.test)") print("Calling hello(): ") obj.hello() print("Calling and printing foo(): ") println(obj.foo()) )
Quando você executa o programa, a saída será:
test = 25 Chamando hello (): Olá, amigo! Chamando e imprimindo foo (): Lol
Conforme mencionado acima, uma interface também pode ter uma propriedade que fornece implementação de acessador. Por exemplo,
interface MyInterface ( // property with implementation val prop: Int get() = 23 ) class InterfaceImp : MyInterface ( // class body ) fun main(args: Array) ( val obj = InterfaceImp() println(obj.prop) )
Quando você executa o programa, a saída será:
23
Aqui, prop não é abstrato. No entanto, é válido dentro da interface porque fornece implementação para o acessador.
No entanto, você não pode fazer algo como val prop: Int = 23dentro da interface.
Implementando duas ou mais interfaces em uma classe
Kotlin não permite herança múltipla verdadeira. No entanto, é possível implementar duas ou mais interfaces em uma única classe. Por exemplo,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMeToo() ( println("From interface B") ) ) // implements two interfaces A and B class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() obj.callMeToo() )
Quando você executa o programa, a saída será:
Da interface A Da interface B
Resolvendo conflitos de substituição (interface múltipla)
Suponha que duas interfaces (A e B) tenham um método não abstrato com o mesmo nome (digamos callMe()método). Você implementou essas duas interfaces em uma classe (digamos C). Agora, se você chamar o callMe()método usando o objeto da classe C, o compilador gerará um erro. Por exemplo,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() )
Aqui está o erro:
Erro: (14, 1) Kotlin: A classe 'C' deve substituir public open fun callMe (): unidade definida em A porque herda vários métodos de interface dela
Para resolver esse problema, você precisa fornecer sua própria implementação. Veja como:
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) ) fun main(args: Array) ( val obj = C() obj.callMe() )
Agora, quando você executar o programa, a saída será:
Da interface A Da interface B
Aqui, a implementação explícita do callMe()método é fornecida na classe C.
classe C: A, B (substituir fun callMe () (super.callMe () super .callMe ()))
A instrução super.callMe()chama o callMe()método da classe A. Da mesma forma, chama o método da classe .super.callMe()callMe()B
