Interface (Interface) en Kotlin

在本文中，您将借助示例学习有关接口以及如何在Kotlin中实现接口的知识。

Kotlin接口类似于Java 8中的接口。它们可以包含抽象方法的定义以及非抽象方法的实现。但是，它们不能包含任何状态。

也就是说，接口可能有属性，但它必须是抽象的或者必须提供访问器实现。

推荐阅读： Kotlin 抽象类

Kotlin中的抽象类与接口相似，但有一个重要区别。抽象类的属性不是必须抽象的或提供访问器实现的。

如何定义接口？

关键字interface用于在Kotlin中定义接口。例如，

interface MyInterface {
　　　　var test: String　　　//抽象属性
　　　　fun foo()　　　　　　　　　　//抽象方法
　　　　fun hello() = "Hello there"　//具有默认实现的方法
}

这里，

• 创建接口 MyInterface。
  

• 该接口有一个抽象属性 test 和一个抽象方法 foo()。
  

• 该接口还具有非抽象方法 hello()。

如何实现接口？

这是类或对象如何实现接口的方法：

interface MyInterface {
　　　　val test: Int　　　//抽象属性
　　　　fun foo() : String　　　//抽象方法（返回字符串）
　　　　fun hello() {　　　//具有默认实现的方法
　　　　　　　　//　body （optional）
　　　　}
}
class InterfaceImp: MyInterface {
　　　　override val test: Int =　25
　　　　override fun foo() = "Lol"
　　　　//其他代码
}

在这里，InterfaceImp 类实现了 MyInterface 接口。

该类重写接口的抽象成员（test属性 和 foo()方法）。

示例：接口如何工作？

interface MyInterface {
　　　　val test: Int
　　　　fun foo() : String
　　　　fun hello() {
　　　　　　　　println("你好，伙计!")
　　　　}
}
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("Appel hello(): ")
　　　　obj.hello()
　　　　print("Appel et affichage foo(): ")
　　　　println(obj.foo())
}

Lors de l'exécution du programme, la sortie est :

test =　25
Appel hello(): 你好，伙计!
Appel et affichage foo(): Lol

Comme mentionné précédemment, une interface peut également avoir des propriétés qui fournissent une implémentation d'accès. Par exemple,

interface MyInterface {
　　　　//Propriétés avec implémentation
　　　　val prop: Int
　　　　　　　　get() =　23
}
class InterfaceImp: MyInterface {
　　　　//Corps de la classe
}
fun main(args: Array<String>) {
　　　　val obj = InterfaceImp()
　　　　println(obj.prop)
}

Lors de l'exécution du programme, la sortie est :

23

Ici, prop n'est pas abstrait, mais il est valide dans l'interface car il fournit une implémentation d'accès.

Mais vous ne pouvez pas exécuter une opération similaire à l'intérieur d'une interface, comme val prop: Int = 23 opérations.

Implémenter deux ou plusieurs interfaces dans une classe

Kotlin ne permet pas une véritable héritage multiple. Cependant, vous pouvez implémenter deux ou plusieurs interfaces dans une classe. Par exemple,

interface A {
　　　　fun callMe() {
　　　　　　　　println(" provenant de l'interface A")
　　　　}
}
interface B {
　　　　fun callMeToo() {
　　　　　　　　println(" provenant de l'interface B")
　　　　}
}
//Implémenter les deux interfaces A et B
class Child: A, B
fun main(args: Array<String>) {
　　　　val obj = Child()
　　　　obj.callMe()
　　　　obj.callMeToo()
}

Lors de l'exécution du programme, la sortie est :

provenant de l'interface A
provenant de l'interface B

Résolution des conflits de redéfinition (multiples interfaces)

Supposons que deux interfaces (A et B) aient des méthodes non abstraites de même nom (par exemple, la méthode callMe()). Vous implémentez ces deux interfaces dans une classe (par exemple, C). Maintenant, si vous appelez la méthode callMe() avec un objet de la classe C, le compilateur générera une erreur. Par exemple

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

Voici l'erreur levée :

Erreur :(14,　1) Kotlin: La classe 'C' doit redéfinir la fonction publique ouverte callMe(): Unit définie dans A car elle hérite de multiples méthodes d'interface de celle-ci

Pour résoudre ce problème, vous devez fournir votre propre implémentation. Voici comment faire :

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

Maintenant, lorsque vous exécutez le programme, la sortie sera :

Interface　　A
Interface　　B

Ici, une implémentation explicite de la méthode callMe() est fournie dans la classe C.

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

L'instruction super<A>.callMe() appelle la méthode callMe() de la classe A. De même, super<B>.callMe() appelle la méthode callMe() de la classe B.