Difference between OnclickListener methods in Kotlin

Question

I am learning Kotlin. Before that, I have worked with Java for Android Development. Kotlin is a great language to learn. I have a confusion while I was using setOnClickListener(View.OnClickListener). I have seen two hints on Android Studio.

I know how to work or define both of them.

The first way to implementing OnClickListerner

 send_button.setOnClickListener(object : View.OnClickListener{
       override fun onClick(p0: View?) {
           TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
       }
   })

and this is the second way of implementing OnClickListener

 send_button.setOnClickListener {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

I understand as far as the second method is based on lambda. But I can't have the proper understanding of these methods.

So, my question is: What is the difference between those methods? If they differ, which one is better and why?

BakaWaii · Accepted Answer · 2017-09-19T06:32:33.100

They refer to the same function but are written in different way. The first one is the typical way to invoke the setOnClickListener() function which accepts an OnClickListener object.

The second one make use of lambda expression. It works because View.OnClickListener is a SAM type defined in Java and Kotlin supports SAM conversions.

Just like Java 8, Kotlin supports SAM conversions. This means that Kotlin function literals can be automatically converted into implementations of Java interfaces with a single non-default method, as long as the parameter types of the interface method match the parameter types of the Kotlin function.

Suppose you have an interface defined in Java like this:

public class Example {
    public interface SingleMethodInterface {
        int length(String text);
    }

    public static void set(SingleMethodInterface sam) {}
}

Then, you can call set() function in the following two ways in Kotlin:

//Passing a function type which accept a `String` and return an `Int`
val length: (String) -> Int = { it.length }
Example.set(length)
//or
Example.set { it.length }

//Passing an object which implements `SingleMethodInterface`
val length2: Main.SingleMethodInterface = object: Main.SingleMethodInterface {
    override fun length(text: String): Int {
        return text.length
    }
}
Example.set(length2)

In short, SAM conversion provide a way to write clean code in Kotlin which interop with Java.

Nice information man, But your example is not relevant to his question. — Bhuvanesh BS, Sep 19 '17 at 06:13
@Bhuvanesh Bs The example I added is used to explain the SAM conversion. — BakaWaii, Sep 19 '17 at 06:25
Sure IntelliJAmiya and thanks again @BakaWaii. for this excellent answer. It helps me lot to understand Kotlin programming Structure. — UltimateDevil, Sep 19 '17 at 07:22
@Vikas Tiwari You are welcome. I am discovering Kotlin too. I think there can be a more well-explain answer from someone for this question. — BakaWaii, Sep 19 '17 at 07:29

score 5 · Answer 2 · edited Sep 19 '17 at 08:12

Your Question: What is the difference between those methods? If they differ, which one is better and why?

After compilation, both will produce the same bytecode but while writing it will give you more readability by single line implementation.

The great feature of Java 8 is Lambda expressions. With Lambda you can write java code simpler. The ugly look of code slightly changed by this feature.

Example: source

You can write Single Abstract Method (SAM) as lambda.

If your interface has an only one method.

public interface StateChangeListener {

    public void onStateChange(State oldState, State newState);

}

You can write it as Lambda like this.

stateOwner.addStateListener(
    (oldState, newState) -> System.out.println("State changed")
);

But both of the methods are same but you can see the second one is so simple and removed ugly implementation.

In Kotlin, lambda expressions are different from Java.

Kotlin lambda expression example: source

val add: (Int, Int) -> Int = { a, b ->  a + b }

The above function variable can be called like this:

val addedValue: Int = add(5, 5)

This will return you the added value of two integers.

In this example you can see (Int, Int) -> Int, this is called lambda function in Kotlin.

So Kotlin lambda and Java lambda functions are completely different.

You can see in the Kotlin Docs:

Just like Java 8, Kotlin supports SAM conversions. This means that Kotlin function literals can be automatically converted into implementations of Java interfaces with a single non-default method, as long as the parameter types of the interface method match the parameter types of the Kotlin function.

Actually, you are writing the lambda in kotlin, later it will be converted to java interface. So both methods are different. But when it comes to execution both are same. It won't affect compile time so it's always suggested to use lambda.

Hope it helps :)

He asked for difference between lambda method and normal method. Please update your answer @Intellij Amiya — Bhuvanesh BS, Sep 19 '17 at 06:09
Thanks, for you answer @IntelliJAmiya. It helps me lot to understand. setOnClickListener transformation — UltimateDevil, Sep 19 '17 at 06:57

Difference between OnclickListener methods in Kotlin

2 Answers2