Kotlin interface

Kotlin Interface and Java 8 similar , Use interface Keyword definition interface , Allow method to have default implementation ：

interface MyInterface { fun bar() //  Unrealized  fun foo() { // The implemented  //  Optional method body  println("foo") } }

Implementation interface

A class or object can implement one or more interfaces .

class Child : MyInterface { override fun bar() { //  Method body  } }

example

interface MyInterface { fun bar() fun foo() { //  Optional method body  println("foo") } } class Child : MyInterface { override fun bar() { //  Method body  println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); }

The output is ：

foo
bar

Properties in the interface

Properties in an interface can only be abstract , Initialization value... Is not allowed , The interface does not save property values , When implementing the interface , Properties must be overridden ：

interface MyInterface{ var name:String //name  attribute ,  In the abstract  } class MyImpl:MyInterface{ override var name: String = "runoob" // Overridden properties  }

example

interface MyInterface { var name:String //name  attribute ,  In the abstract  fun bar() fun foo() { //  Optional method body  println("foo") } } class Child : MyInterface { override var name: String = "runoob" // Overridden properties  override fun bar() { //  Method body  println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); println(c.name) }

The output is ：

foo
bar
runoob

Function rewriting

When implementing multiple interfaces , You may encounter the problem of inheriting multiple implementations of the same method . for example :

example

interface A { fun foo() { print("A") } //  The implemented  fun bar() //  Unrealized , There is no method body , It is abstract.  } interface B { fun foo() { print("B") } //  The implemented  fun bar() { print("bar") } //  The implemented  } class C : A { override fun bar() { print("bar") } //  rewrite  } class D : A, B { override fun foo() { super<A>.foo() super<B>.foo() } override fun bar() { super<B>.bar() } } fun main(args: Array<String>) { val d = D() d.foo(); d.bar(); }

The output is ：

ABbar

Interface in the instance A and B They all define methods foo() and bar(), Both are realized foo(), B Realized bar(). because C It's an implementation A The concrete class , So we have to rewrite bar() And implement this abstract method .

However , If we're from A and B The derived D, We need to implement all methods inherited by multiple interfaces , And specify D How should they be implemented . This rule It applies to inheriting a single implementation （bar()） The method is also applicable to inheriting multiple implementations （foo()） Methods .