Kotlin интерфейси (с примери)

В тази статия ще научите за интерфейсите и как да го внедрите в Kotlin с помощта на примери.

Котлин интерфейсите са подобни на интерфейсите в Java 8. Те могат да съдържат дефиниции на абстрактни методи, както и внедряване на не абстрактни методи. Те обаче не могат да съдържат никакво състояние.

Значението е, че интерфейсът може да има свойство, но той трябва да е абстрактен или да предоставя реализации на достъп.

Препоръчително четене: Абстрактна класа на Kotlin

Абстрактните класове в Kotlin са подобни на интерфейса с една важна разлика. Не е задължително свойствата на абстрактния клас да бъдат абстрактни или да осигуряват реализации на достъп.

Как да дефинирам интерфейс?

Ключовата дума interfaceсе използва за дефиниране на интерфейси в Kotlin. Например,

 интерфейс MyInterface (var test: String // абстрактно свойство fun foo () // абстрактен метод fun hello () = "Hello there" // метод с изпълнение по подразбиране)

Тук,

  • създава се интерфейс MyInterface.
  • интерфейсът има тест за абстрактни свойства и абстрактен метод foo().
  • интерфейсът също има абстрактен метод hello().

Как да приложим интерфейс?

Ето как клас или обект могат да реализират интерфейса:

 интерфейс MyInterface (вал тест: Int // абстрактно свойство fun foo (): String // абстрактен метод (връща String) fun hello () (// метод с изпълнение по подразбиране // тяло (по избор))) клас InterfaceImp: MyInterface (замяна val test: Int = 25 override fun foo () = "Lol" // друг код)

Тук клас InterfaceImp реализира интерфейса MyInterface.

Класът заменя абстрактните членове (тестово свойство и foo()метод) на интерфейса.

Пример: Как работи интерфейсът?

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

Когато стартирате програмата, изходът ще бъде:

test = 25 Обаждане на здравей (): Здравей, приятелю! Обаждане и отпечатване на foo (): Lol

Както бе споменато по-горе, интерфейсът може също да има свойство, което осигурява реализация на достъп. Например,

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

Когато стартирате програмата, изходът ще бъде:

 23.

Тук опората не е абстрактна. Въпреки това, той е валиден вътре в интерфейса, защото осигурява изпълнение за достъп.

Не можете обаче да направите нещо като val prop: Int = 23вътре в интерфейса.

Внедряване на два или повече интерфейса в клас

Kotlin не позволява истинско множествено наследяване. Възможно е обаче да се приложат два или повече интерфейса в един клас. Например,

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

Когато стартирате програмата, изходът ще бъде:

 От интерфейс A От интерфейс B

Разрешаване на приоритетни конфликти (множествен интерфейс)

Да предположим, че два интерфейса (A и B) имат абстрактен метод със същото име (да кажем callMe()метод). Приложихте тези два интерфейса в клас (да речем C). Сега, ако извикате callMe()метода, използвайки обекта от клас C, компилаторът ще изведе грешка. Например,

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

Ето грешката:

 Грешка: (14, 1) Kotlin: Класът „C“ трябва да замени публичния отворен забавен callMe (): Единицата, дефинирана в A, защото наследява множество методи за интерфейс от нея

За да разрешите този проблем, трябва да предоставите собствено изпълнение. Ето как:

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

Сега, когато стартирате програмата, изходът ще бъде:

 От интерфейс A От интерфейс B

Тук callMe()е предвидено изрично изпълнение на метод в клас C.

клас C: A, B (замяна на забавен callMe () (super.callMe () super .callMe ()))

Операторът super.callMe()извиква callMe()метода на клас А. По същия начин извиква метода на класа .super.callMe()callMe()B

Интересни статии...