An article to understand the extension method of kotlin

Usage

Extended functions are another killer function of kotlin. They can expand the capabilities of certain classes without modifying the source code and facilitate development.

For example, here is a way to add a method to a String to get the first element.

fun (): Char {
  if (isEmpty()) {
    throw NoSuchElementException("String is empty")
  }
  return this[0]
}

fun main(args: Array<String>) {
  println("Hello,World".first())
}

An additional note here is that in the method body of the extension function, it can directly access the variables of the extension object public. For example, in the above method, we can also write this:

fun (): Char {
  if (length < 1) {
    throw NoSuchElementException("String is empty")
  }
  return this[0]
}

Through this, you can access the extended object within the method, and here you get the first character through this[0].

Under in hood

It looks amazing, but his principle is very simple. We must always remember that the kotlin JVM is developed based on the JVM, and the kotlin source code will eventually become bytecode and then run. When you encounter something you don’t know much about syntax, you can directly decompile the bytecode, or Decompile it into Java methods, and you can understand the mystery.

After we decompile the above code into Java, we can discover the secrets.

public static final char first(@NotNull String $this$first){
  ($this$first, "$this$first");
  if ($this$() < 1) {
   throw (Throwable)(new NoSuchElementException("String is empty"));
  } else {
   return $this$(0);
  }
}

It turned out that a public static final method was generated, but this generation was syntactic sugar provided by kotlin, which helped us complete. Seeing this code also explains why the public members of the extended object can be accessed within the extension object method.

Overloading and polymorphism

Can the extension method be inherited or overloaded? Let's take a look at the example

open class Animal
class Dog : Animal()

fun () = "Animal"
fun () = "Dog"

fun main(args: Array<String>) {
  println(Dog().desc())
  var animal: Animal = Dog()
  println(())
}

// output:
// Dog
// Animal

If the extension method can be overloaded, then Dog should be output both times. Let's take a look at the truth as before.

@NotNull
public static final String desc(@NotNull Animal $this$desc) {
  ($this$desc, "$this$desc");
  return "Animal";
}

@NotNull
public static final String desc(@NotNull Dog $this$desc) {
  ($this$desc, "$this$desc");
  return "Dog";
}

It can be seen that two desc methods have actually been generated, and the parameters in them are still moved, so the call of this method is only related to the extension object itself. It has been determined at compile time that there is no polymorphism.

Extended properties

This is a very magical setting. kotlin cannot really add a property to the extended object, but only provides a syntax sugar. What does it mean? Let's take a look at the following example in detail.

var : Char
  get() {
    if (isEmpty()) {
      throw NoSuchElementException(“String is empty”)
    }
    return this[0]
  }
  set(value) {
    println(“set value to $value”)
  }

fun main() {
  “Hello, World”.first = ‘G'
  println(“Hello,World”.first)
}

We have extended the properties of kotlin and added a first. We can give this so-called first attribute separately, note that it is called, add the get and set methods. We can then call the set and get methods with = and ., just like in the main method. But in fact, the first attribute is not generated in the end. Let's take a look at the decompiled code.

public static final Char getFirst(@NotNull String $this$first) {
  ($this$first, "$this$first");
  CharSequence var1 = (CharSequence)$this$first;
  boolean var2 = false;
  if (() == 0) {
   throw (Throwable)(new NoSuchElementException("String is empty"));
  } else {
   return $this$(0);
  }
}

public static final void setFirst(@NotNull String $this$first, char value) {
  ($this$first, "$this$first");
  String var2 = "set value to " + value;
  boolean var3 = false;
  (var2);
}

I saw that there was no, but I actually just added two methods setFirst and getFirst, and there was no actual attribute added. This is also one of the syntactic sugars provided to us by kotlin. You should eat sugar, but you should also be careful of tooth decay!

OK, the above is the entire content of this article. I hope that the content of this article has certain reference value for your study or work. Thank you for your support.