How setOnClickListener works in Kotlin: under the hood

How setOnClickListener works in Kotlin: under the hood

Every Android developer switching from Java to Kotlin eventually asks: "Why does setOnClickListener now look so simple and elegant?" And it's not magic — behind it lies a powerful language mechanism that we'll break down piece by piece today.

If you've ever written something like:

button.setOnClickListener { \n    toast("Clicked!")\n}\n

...then you've already used SAM conversion and lambda expressions. But how exactly does Kotlin turn this concise code into something Android understands? Let's find out.

The classic Java approach: where it all began

In Java, setOnClickListener looked like this:

button.setOnClickListener(new View.OnClickListener() {\n    @Override\n    public void onClick(View v) {\n        // your code\n    }\n});\n

Here we created an anonymous inner class implementing the View.OnClickListener interface. It worked, but the code was bulky. Kotlin offered an elegant solution — lambda expressions.

Kotlin transformation: how it looks now

In Kotlin, the same code can be written in one line:

button.setOnClickListener { \n    println("Button clicked")\n}\n

But what happens under the hood? Let's break it down step by step.

Step 1. SAM conversion

SAM (Single Abstract Method) is an interface with one abstract method. View.OnClickListener is exactly that: it has only one method onClick(View).

Kotlin automatically converts the lambda into an implementation of this interface. This is SAM conversion. The compiler sees that you're passing a lambda where a View.OnClickListener is expected, and creates an anonymous class for you.

So when you write:

button.setOnClickListener { v -> println("Clicked $v") }\n

...Kotlin generates bytecode roughly like this:

button.setOnClickListener(new OnClickListener() {\n    @Override\n    public void onClick(View v) {\n        System.out.println("Clicked " + v);\n    }\n});\n

Step 2. Parameter shorthand

If the lambda takes one parameter, you can omit it and use the implicit name it:

button.setOnClickListener { \n    println("Clicked $it")\n}\n

This works because Kotlin knows: the only parameter of the onClick method is View. The compiler automatically substitutes it.

What happens at the bytecode level?

Let's look even deeper. When you use a lambda, Kotlin doesn't always create a new object. In some cases, it uses inline functions or caching.

Consider two scenarios:

\n
• Lambda without capturing variables — the compiler can create a single static instance and reuse it.
\n
• Lambda with capturing variables — a new object is created on each call, because the state needs to be preserved.
\n

Example with capturing:

var counter = 0\nbutton.setOnClickListener {\n    counter++\n    println("Clicks: $counter")\n}\n

Here Kotlin creates an object that stores a reference to counter. This is slightly more expensive, but in most cases it's imperceptible.

Alternatives to setOnClickListener in Kotlin

Although lambdas are the most popular way, there are other approaches. Let's look at them.

1. Method reference

If you already have a function that matches the signature, you can pass a reference to it:

fun handleClick(view: View) {\n    println("Handler: $view")\n}\n\nbutton.setOnClickListener(::han