Интерфейс Kotlin и реализация

Интерфейс — это план класса. Интерфейс Kotlin похож на Java 8. Он содержит объявления абстрактных методов, а также реализацию метода.

Определение интерфейса

Интерфейс в Котлин определяется с помощью ключевого слова interface. Например:

 
interface MyInterface { 
val id: Int // abstract property 
    fun absMethod()// abstract method 
    fun doSomthing() { 
      // optional body 
    } 
} 

Методы, объявленные только без тела метода, по умолчанию являются абстрактными.

Зачем использовать интерфейс Kotlin?

Ниже приведены причины использования интерфейса:

• Использование интерфейса поддерживает функциональность множественного наследования.
• Его можно использовать для ослабления сцепления.
• Он используется для достижения абстракции.

Подкласс расширяет только один суперкласс, но реализует несколько интерфейсов. Расширение родительского класса или реализация интерфейса выполняются с помощью оператора(:) в их подклассе.

Реализация

В этом примере мы реализуем интерфейс MyInterface в классе InterfaceImp. Класс InterfaceImp обеспечивает реализацию идентификатора свойства и абстрактного метода absMethod(), объявленного в интерфейсе MyInterface.

 
interface MyInterface  { 
var id: Int            // abstract property 
    fun absMethod():String    // abstract method 
    fun doSomthing() { 
println("MyInterface doing some work") 
    } 
} 
class InterfaceImp : MyInterface { 
    override var id: Int = 101 
    override fun absMethod(): String{ 
return "Implementing abstract method.." 
    } 
} 
fun main(args: Array) { 
val obj = InterfaceImp() 
println("Calling overriding id value = ${obj.id}") 
obj.doSomthing() 
println(obj.absMethod()) 
} 

Выход:

Calling overriding id value = 101 
MyInterface doing some work 
Implementing abstract method.. 

Реализация нескольких интерфейсов

Мы можем реализовать несколько абстрактных методов разных интерфейсов в одном классе. Все абстрактные методы должны быть реализованы в подклассе. Другие неабстрактные методы интерфейса можно вызывать из производного класса.

Например, создание двух интерфейсов MyInterface1 и MyInterface2 с абстрактными методами doSomthing() и absMethod() соответственно. Эти абстрактные методы переопределяются в производном классе MyClass.

 
interface MyInterface1 { 
    fun doSomthing() 
} 
interface MyInterface2 { 
    fun absMethod() 
} 
class MyClass : MyInterface1, MyInterface2 { 
    override fun doSomthing() { 
println("overriding doSomthing() of MyInterface1") 
    } 
 
    override fun absMethod() { 
println("overriding absMethod() of MyInterface2") 
    } 
} 
fun main(args: Array) { 
val myClass = MyClass() 
myClass.doSomthing() 
myClass.absMethod() 
} 

Выход:

overriding doSomthing() of MyInterface1 
overriding absMethod() of MyInterface2 

Разрешение различных интерфейсов с одним и тем же методом переопределения конфликтов

Давайте рассмотрим пример, в котором интерфейс MyInterface1 и интерфейс MyInterface2 содержат один и тот же неабстрактный метод. Класс MyClass обеспечивает реализацию этих интерфейсов. Вызов метода интерфейса с использованием объекта MyClass вызывает ошибку.

 
interface MyInterface1 { 
    fun doSomthing(){ 
println("overriding doSomthing() of MyInterface1") 
    } 
} 
interface MyInterface2 { 
    fun doSomthing(){ 
println("overriding doSomthing() of MyInterface2") 
    } 
} 
class MyClass : MyInterface1, MyInterface2 { 
 
} 
fun main(args: Array) { 
val myClass = MyClass() 
myClass.doSomthing() 
} 

Выход:

Kotlin: Class 'MyClass' must override public open fun doSomthing(): Unit defined in MyInterface1 because it  
inherits multiple interface methods of it 

Чтобы решить вышеуказанную проблему, нам нужно указать конкретный метод интерфейса, который мы вызываем. Давайте посмотрим на пример ниже.

В приведенном ниже примере два интерфейса MyInterface1 и MyInterface2 содержат два абстрактных метода: adsMethod() и absMethod(name: String) и неабстрактный метод doSomthing() соответственно.

Класс MyClass реализует как интерфейс, так и переопределение абстрактных методов absMethod() и absMethod(name: String) . Чтобы переопределить неабстрактный метод doSomthing(), нам нужно указать имя интерфейса с методом, используя ключевое слово super как super.methodName().

 
interface MyInterface1 { 
    fun doSomthing() { 
println("MyInterface 1 doing some work") 
    } 
        fun absMethod() 
} 
interface MyInterface2 { 
    fun doSomthing(){ 
println("MyInterface 2 doing some work") 
    } 
    fun absMethod(name: String) 
} 
class MyClass : MyInterface1, MyInterface2 { 
    override fun doSomthing() { 
        super.doSomthing() 
    } 
 
    override fun absMethod() { 
println("Implements absMethod() of MyInterface1") 
    } 
    override fun absMethod(n: String) { 
println("Implements absMethod(name) of MyInterface2 name is  $n") 
    } 
} 
fun main(args: Array) { 
val myClass = MyClass() 
myClass.doSomthing() 
myClass.absMethod() 
myClass.absMethod("Ashu") 
} 

Выход:

MyInterface 2 doing some work 
Implements absMethod() of MyInterface1 
Implements absMethod(name) of MyInterface2 name is  Ashu 

 
interface MyInterface1 { 
    fun doSomthing() { 
println("MyInterface 1 doing some work") 
    } 
    fun absMethod() 
} 
 
interface MyInterface2 { 
    fun doSomthing() { 
println("MyInterface 2 doing some work") 
    } 
   fun absMethod() { 
println("MyInterface 2 absMethod") 
    } 
 
} 
 
class C : MyInterface1 { 
    override fun absMethod() { 
println("MyInterface1 absMethod implementation") 
    } 
} 
 
class D : MyInterface1, MyInterface2 { 
    override fun doSomthing() { 
        super.doSomthing() 
        super.doSomthing() 
    } 
 
    override fun absMethod() { 
 
        super.absMethod() 
    } 
} 
 
fun main(args: Array) { 
val d = D() 
val c = C() 
d.doSomthing() 
d.absMethod() 
c.doSomthing() 
c.absMethod() 
} 

Выход:

MyInterface 1 doing some work 
MyInterface 2 doing some work 
MyInterface 2 absMethod 
MyInterface 1 doing some work 
MyInterface1 absMethod implementation