Kotlin: Interface ... does not have constructors

Making Interface and Lambda friends: SAM Conversions

Single Abstract Method: Kotlin's interface secret sauce

Kotlin offers an elegant feature for interface implementation called SAM (Single Abstract Method) Conversions. What it does is like a Marvel superhero: it changes the face of a lambda to resemble an interface.

fun interface ClickListener {
    fun onClick(view: View)
}

// Presto! Now `clickListener` is SAM's secret identity
val clickListener = ClickListener { view ->
    println("Bang! View clicked!")
}


Use fun interface trick for Single Abstract Method

Kotlin blessed us with fun interface to define an interface having a single abstract method. So keep the count to one, it's exclusive!

fun interface Transformer<T> {
    fun transform(source: T): T
}

val doubler = Transformer<Int> { it * 2 }  //superpower: doubles the input!


Using Anonymous Objects: For multifaceted interface personalities

When you have an interface with lot more things to say (read: methods), Kotlin allows you to use anonymous objects luging multiple method implementations. Remember, "with great power comes great responsibility"!

interface ComplexInterface {
    fun doSomething()
    fun doSomethingElse()
}

val complexObject = object : ComplexInterface {
    override fun doSomething() {
        //... let's bake a cake!
    }

    override fun doSomethingElse() {
        //... and eat it too!
    }
}


Making sense of Syntax: Implementing and Instantiating

override is the key: Implementation demands it

Kotlin won't just take your word for it. You need to explicitly use the override keyword when implementing an interface. Forget this, and it's Error City.

class ConcreteClass : MyInterface {
    override fun myFunction() {
        // sweeter than sugar: Implementation
    }
}


Correct syntax is the magic wand: interface instantiation

Remember, direct instantiation of an interface in Kotlin is like asking a phoenix to lay an egg! It won't happen! Know your syntax; Kotlin is your friend, but it wants you to 'speak' correctly.

fun interface: Single-method interfaces

When dealing with single-method interfaces, fun interface is the right magic word. Simply write a lambda for the lonely method, and poof!—your interface is happy and ready to roll out!

fun interface Action {
    fun run()
}

val action = Action {
    // run Forrest, run!
    println("Running...")
}


Errors due to syntax: Common Mistakes and Misunderstanding

Syntax clarity: It gifts and takes away

Writers are only as good as their vocabulary, coders as their syntax. Trying to instantiate an interface directly without proper syntax issue, is like asking Thanos for relationship advice. Not gonna end well!

object keyword: A versatile player

Within the cosmos of Kotlin, the keyword object is omnipresent. It's the Ragnarok powerful tool used for declaring everything right from a singleton to companion objects to anonymous objects.

IDE suggestions: Double-edged sword

The power of a good IDE is immense, but be careful! Suggestions by IntelliJ IDEA or Android Studio about converting your lambda to a SAM constructor may be helpful sometimes, but other times might turn your Kotlin code into a sudoky puzzle. Know when to use them, and more importantly, when not to!