There is no static
keyword in Kotlin.
What is the best way to represent a static
Java method in Kotlin?
Kotlin is a statically typed programming language for the JVM, Android and the browser, 100% interoperable with Java. Blog of JetBrains team discussing static constants in Kotlin.
In Kotlin, we can achieve the functionality of a static method by using a companion identifier. For example, If you want to create a method that will return the address of your company then it is good to make this method static because for every object you create, the address is going to be the same.
One way in which the Kotlin language differs from Java is that Kotlin doesn't contain the static keyword that we're familiar with. In this quick tutorial, we'll see a few ways to achieve Java's static method behavior in Kotlin.
Kotlin is known primarily as a drop-in replacement for Java, but it gets rid of a well-known Java construct: the static keyword. Instead, that class-level functionality is offered mainly by companion objects.
You place the function in the "companion object".
So the java code like this:
class Foo { public static int a() { return 1; } }
will become
class Foo { companion object { fun a() : Int = 1 } }
You can then use it from inside Kotlin code as
Foo.a();
But from within Java code, you would need to call it as
Foo.Companion.a();
(Which also works from within Kotlin.)
If you don't like having to specify the Companion
bit you can either add a @JvmStatic
annotation or name your companion class.
From the docs:
Companion Objects
An object declaration inside a class can be marked with the
companion
keyword:class MyClass { companion object Factory { fun create(): MyClass = MyClass() } }
Members of the companion object can be called by using simply the class name as the qualifier:
val instance = MyClass.create()
...
However, on the JVM you can have members of companion objects generated as real static methods and fields, if you use the
@JvmStatic
annotation. See the Java interoperability section for more details.
Adding the @JvmStatic
annotation looks like this
class Foo { companion object { @JvmStatic fun a() : Int = 1; } }
and then it will exist as a real Java static function, accessible from both Java and Kotlin as Foo.a()
.
If it is just disliked for the Companion
name, then you can also provide an explicit name for the companion object looks like this:
class Foo { companion object Blah { fun a() : Int = 1; } }
which will let you call it from Kotlin in the same way, but from java like Foo.Blah.a()
(which will also work in Kotlin).
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With