Detailed explanation of how to implement static methods in Kotlin similar to Java or C#

How to implement a static method in Kotlin similar to Java or C#, this article summarizes several methods, namely: package-level function, companionObjects

, extension functions and object declarations. This requires everyone to choose according to different situations.

You can find many such articles on the Internet. The official recommendation is package-level functions, and some people say to use companion objects (companion class

). These are good options, but they're not perfect, and we have better options in different situations. I have summarized several methods, namely: package-level functions, companion objects, extension functions and object declarations. This requires everyone to choose according to different situations.

1. Package-level functions

The difference between Kotlin and Java and C# is that you can declare functions

directly in the package. The method is the same as in the category, so I won’t go into details here. It is indeed a very good choice. It is suitable for methods where functions do not need to include internal classes for data sharing.

2. Companion object

Semantically speaking, companion functions are most similar to static methods in Java, so companion objects can completely implement static methods in Java All contents of the class. But using static methods in Java is sometimes no choice. In Kotlin, companion objects are just one of our options. Next I will introduce the companion objects. Have you ever noticed when using Java? When are the static variables
and methods in Java classes initialized? Is it when the static method is first called or when the corresponding Java class is loaded? The answer is when the Java class is loaded (that is, if you have called the instance variables and methods in the Java class, even if you have not used static variables and methods, the static variables have been initialized). Isn’t it appropriate to describe this phenomenon as accompanying?

In Kotlin, it is considered that there are two types of stuff in a class, one is the instance variables and methods in the Java class, and the other is the static variables and methods in the Java class. Kotlin packages static instances and methods into a companion class, and that's what it looks like. Here is an example:

fun main(args: Array<String>) {
 Books.getBestSellers()
}
class Books(var name: String, val page: Int) {
  fun getWordCount()=page*100
  companion object ComBooks{
    var bestSellers=arrayOf("Harry Potter\r\t","Lord of the Rings\r\t")
    fun getBestSellers() {
      bestSellers.forEach{v->println(v)}
    }
  }
}

The companion class is declared using companion. It is loaded in the class where the companion object is located, and the companion object is initialized, just like Java static members. It can be anonymous or have the same name as the containing class. There are two types of calls: Books.ComBooks.getBestSellsers()? or Books.getBestSellsers()?.

3. Extension functions

In Java, we often write Utils classes, which are often targeted at a certain The object performs operations on its functions that match its own program. Most of the methods are static methods, for example:

public class Utils {

  public static boolean isEmpty(String string){
    return string != null && string.length() == 0;
  }

  public static boolean isWeakEmpty(String string){
    return isEmpty(string) && string.trim().length() == 0;
  }
}

Of course we can use the above two methods to implement these static methods, but we have a better way.

fun String.isEmpty() = this != null && this.length == 0;

fun String.isWeakEmpty()= this.isEmpty() && this.trim().length == 0

The above two lines of code extend the String class with two functions. These two functions can be called like their native functions. The code is very beautiful. In fact, the extension function does not modify the internal content of the String class, and only adds two static functions to String. However, compared with Java's Utils class, the readability has been greatly improved.

4. Object declaration

Continue to consider the Utils class above. All methods (and sometimes variables) in this class are Static, this method does not need to be instantiated at all. In Java, we often declare this type as a static class. Is there a good solution for this situation in Kotlin? Is there a better solution than companion objects? Of course there is, object declaration is one.

Object declaration is very easy to understand. It uses the object keyword to declare an object. The object can use variables or methods, such as:

object AppInfo{
  var AppName = "Kotlin Message"
  var AppAuthor = "Riley Ge"
  fun toSimpleString() {
    println("AppName:$AppName,AppAuthor:$AppAuthor") 
  }
}

I found that Kotlin’s objects are really powerful. ! One thing everyone should pay attention to is that AppInfo is lazily initialized when it is accessed for the first time, which means that AppInfo is not initialized when the object is declared.

5. Summary

Having said so many methods, no one is worried that Kotlin does not have static methods now, right? Kotlin does not have it just because he Can do better. Moreover, Kotlin also gives you more choices. You can choose the appropriate method according to your actual situation to make your code efficient and beautiful.

###

The above is the detailed content of Detailed explanation of how to implement static methods in Kotlin similar to Java or C#. For more information, please follow other related articles on the PHP Chinese website!