Kotlin Interfaces and SAM Conversion: Why "Interface Does Not Have Constructors" Happens

By the end of this page, you will understand why Kotlin lets you create Java single-method interfaces with lambda syntax, why the same syntax does not automatically work for Kotlin-defined interfaces, and how to correctly instantiate Kotlin interfaces using object expressions or fun interface when appropriate.

The core concept behind this question is SAM conversion.

SAM stands for Single Abstract Method. A SAM type is an interface that has exactly one abstract method. In Java, interfaces like this are often used as callbacks:

public interface MyInterface {
    void onLocationMeasured(Location location);
}

Because there is only one method to implement, Kotlin can often let you replace the full anonymous class with a lambda.

Why the Java version works

When MyInterface is defined in Java and has one abstract method, Kotlin recognizes it as a Java SAM interface. That means this is allowed:

val myObj = MyInterface {
    Log.d("TAG", "measured")
}

Kotlin converts the lambda into an object that implements the interface.

Why the Kotlin version fails

When you rewrite the interface in Kotlin as:

interface MyInterface {
    fun onLocationMeasured(location: Location)
}

it is now just a normal Kotlin interface. A normal interface is and . So Kotlin does not treat as "call a constructor" or "build an implementation" unless the interface is specifically declared as a functional interface.

Think of a normal Kotlin interface as a contract sheet.

It says:

• "Any class using me must provide these methods"

But it does not come with a built-in factory or constructor.

So this does not make sense:

MyInterface { ... }

because you are writing something that looks like calling a constructor, but an interface is not constructible.

Now think of a fun interface as a special one-button adapter.

Because it has only one job, Kotlin can say:

• "If you give me a lambda, I know how to turn that into an implementation."

So:

val myObj = MyInterface { location ->
    println(location)
}

works only when Kotlin knows the interface is a functional interface.

Simple analogy

• interface = a job description
• object : Interface { ... } = hiring a worker and explicitly telling them how to do the job
• fun interface + lambda = using a quick one-task freelancer form because there is only one task to define

1. Normal Kotlin interface: use an object expression

interface MyInterface {
    fun onLocationMeasured(location: Location)
}

val myObj = object : MyInterface {
    override fun onLocationMeasured(location: Location) {
        Log.d("TAG", "Location measured: $location")
    }
}

This is the correct way to create an instance of a regular Kotlin interface.

Why it works

• object : MyInterface creates an anonymous object
• That object implements MyInterface
• You must override all required abstract methods

2. Kotlin functional interface: use fun interface

fun interface MyInterface {
    fun onLocationMeasured(location: Location)
}

 myObj = MyInterface { location ->
    Log.d(, )
}

Consider this Kotlin code:

fun interface MyInterface {
    fun onLocationMeasured(location: String)
}

fun main() {
    val myObj = MyInterface { location ->
        println("Measured: $location")
    }

    myObj.onLocationMeasured("Paris")
}

Step by step

1. Kotlin sees fun interface

fun interface MyInterface {

This tells the compiler:

• this interface has one abstract method
• it can be instantiated from a lambda

2. Kotlin reads the lambda assignment

val myObj = MyInterface { location ->
    println("Measured: $location")
}

Kotlin converts this lambda into an object that implements MyInterface.

Conceptually, it is similar to:

Callback APIs

Interfaces are commonly used to receive events from another part of the program.

Examples:

• location updates
• button click handlers
• download completion events
• sensor readings

fun interface OnDownloadComplete {
    fun onDone(fileName: String)
}

Android listeners

In Android, many Java-based APIs use listener interfaces. Kotlin often lets you pass lambdas for these because they are Java SAM interfaces.

button.setOnClickListener {
    Log.d("TAG", "Clicked")
}

Custom Kotlin APIs

If you are designing your own callback API in Kotlin and want callers to use lambdas, fun interface is often a good choice.

fun interface OnUserLoaded {
    fun onLoaded(name: String)
}

Multiple related callbacks

If your API needs several methods, a regular interface is more appropriate.

In real projects, developers choose between lambdas and object expressions based on API design.

Pattern 1: Simple callback with fun interface

Use this when there is only one action to perform.

fun interface OnSave {
    fun onSave(fileName: String)
}

This keeps call sites clean:

saveDocument(OnSave { fileName ->
    println("Saved $fileName")
})

Pattern 2: Object expression for richer behavior

If the interface has multiple methods or stateful logic, use an object expression.

interface AuthListener {
    fun onSuccess(userId: String)
    fun onError(message: String)
}

val listener = object : AuthListener {
    override fun onSuccess {
        println()
    }

      {
        println()
    }
}

1. Treating a normal interface like a constructor

Broken code:

interface MyInterface {
    fun onLocationMeasured(location: String)
}

val obj = MyInterface {
    println(it)
}

Why it fails:

• MyInterface is not a class
• it has no constructor
• normal Kotlin interfaces do not support lambda instantiation

Fix:

val obj = object : MyInterface {
    override fun onLocationMeasured(location: String) {
        println(location)
    }
}

2. Forgetting to use fun interface

Broken code:

interface OnDone {
    fun complete()
}

val callback = OnDone {
    println("done")
}

interface vs

Quick rules

• A normal Kotlin interface has no constructor.
• MyInterface { ... } only works for SAM-compatible interfaces.
• Java single-method interfaces are usually SAM-compatible in Kotlin.
• Kotlin-defined interfaces need fun interface for lambda instantiation.
• If the interface has multiple abstract methods, use object : InterfaceName { ... }.

Normal interface

interface MyInterface {
    fun onLocationMeasured(location: String)
}

val obj = object : MyInterface {
    override fun onLocationMeasured(location: String) {
        println(location)
    }
}

Functional interface

fun interface MyInterface {
    fun onLocationMeasured(location: String)
}

val obj = MyInterface { location ->
    println(location)
}

Why does Kotlin say an interface does not have constructors?

Because an interface is not a class you can instantiate directly. MyInterface { ... } only works when Kotlin supports SAM conversion for that interface.

Why did the Java interface work but the Kotlin one did not?

Kotlin supports SAM conversion for Java single-method interfaces. A regular Kotlin interface does not automatically get the same treatment.

How do I instantiate a Kotlin interface correctly?

Use an object expression:

val obj = object : MyInterface {
    override fun onLocationMeasured(location: Location) {
        // code
    }
}

When should I use fun interface?

Use it when your Kotlin interface has exactly one abstract method and you want callers to be able to pass a lambda.

Can a fun interface have more than one method?

It can only have one abstract method. Additional non-abstract members may be allowed, but the functional part must remain exactly one abstract method.

Is a lambda the same as an object expression?

Not exactly. A lambda is shorthand for implementing a functional interface or function type. An object expression creates an anonymous object explicitly.

Should I use a function type instead of a ?

• Anonymous objects — Used to create one-off implementations of interfaces and abstract classes.
• fun interface — Kotlin's functional interface feature that enables SAM conversion.
• SAM conversion — The rule that lets a lambda stand in for a single abstract method interface.
• Lambda expressions — The syntax used to pass small blocks of behavior.
• Function types — An alternative to callback interfaces in Kotlin, such as (Location) -> Unit.
• Abstract classes — Another way to define contracts and shared behavior.
• Override keyword — Required when implementing interface methods.
• Java interoperability — Important because Kotlin treats Java interfaces and Kotlin interfaces differently in some cases.