Kotlin - Interfaccia

In questo capitolo impareremo a conoscere l'interfaccia in Kotlin. In Kotlin, l'interfaccia funziona esattamente in modo simile a Java 8, il che significa che possono contenere l'implementazione del metodo e la dichiarazione di metodi astratti. Un'interfaccia può essere implementata da una classe per utilizzare la sua funzionalità definita. Abbiamo già introdotto un esempio con un'interfaccia nel Capitolo 6 - sezione "Classe interna anonima". In questo capitolo impareremo di più al riguardo. La parola chiave "interfaccia" viene utilizzata per definire un'interfaccia in Kotlin come mostrato nella parte di codice seguente.

interface ExampleInterface {
   var myVar: String     // abstract property
   fun absMethod()       // abstract method
   fun sayHello() = "Hello there" // method with default implementation
}

Nell'esempio sopra, abbiamo creato un'interfaccia chiamata "ExampleInterface" e al suo interno abbiamo un paio di proprietà e metodi astratti tutti insieme. Guarda la funzione chiamata "sayHello ()", che è un metodo implementato.

Nel seguente esempio, implementeremo l'interfaccia sopra in una classe.

interface ExampleInterface  {
   var myVar: Int            // abstract property
   fun absMethod():String    // abstract method
   
   fun hello() {
      println("Hello there, Welcome to TutorialsPoint.Com!")
   }
}
class InterfaceImp : ExampleInterface {
   override var myVar: Int = 25
   override fun absMethod() = "Happy Learning "
}
fun main(args: Array<String>) {
   val obj = InterfaceImp()
   println("My Variable Value is = ${obj.myVar}")
   print("Calling hello(): ")
   obj.hello()
   
   print("Message from the Website-- ")
   println(obj.absMethod())
}

La parte di codice precedente produrrà il seguente output nel browser.

My Variable Value is = 25
Calling hello(): Hello there, Welcome to TutorialsPoint.Com!
Message from the Website-- Happy Learning

Come accennato in precedenza, Kotlin non supporta più eredità, tuttavia, la stessa cosa può essere ottenuta implementando più di due interfacce alla volta.

Nel seguente esempio creeremo due interfacce e successivamente implementeremo entrambe le interfacce in una classe.

interface A {
   fun printMe() {
      println(" method of interface A")
   }
}
interface B  {
   fun printMeToo() {
      println("I am another Method from interface B")
   }
}

// implements two interfaces A and B
class multipleInterfaceExample: A, B

fun main(args: Array<String>) {
   val obj = multipleInterfaceExample()
   obj.printMe()
   obj.printMeToo()
}

Nell'esempio precedente, abbiamo creato due interfacce di esempio A, B e nella classe denominata "multipleInterfaceExample" abbiamo implementato due interfacce dichiarate in precedenza. La parte di codice precedente produrrà il seguente output nel browser.

method of interface A
I am another Method from interface B