I want to be able to save a class instance to a private/public static variable, but I can't figure out how to do this in Kotlin.
public class Foo {
private static Foo instance;
public Foo() {
if (instance == null) {
instance = this;
}
}
public static Foo get() {
return instance;
}
}
Update: Anyone (like OP) who just needs a so-called "Singleton", sometimes called "Service" (except in Android), should simply use Kotlin's built-in:
object Foo {
// Done, this already does what OP needed,
// because the boilerplate codes (like static field and constructor),
// are taken care of by Kotlin.
}
(Like Roman rightly pointed out in the comment-section.)
Previous answer; If you have (or plan to have) multiple static variables, then continue reading:
The closest thing to Java's static fields is a companion object. You can find the documentation reference for them here: https://kotlinlang.org/docs/reference/object-declarations.html#companion-objects
Your code in Kotlin would look something like this:
class Foo {
companion object {
private lateinit var instance: Foo
fun get(): Foo {
return instance;
}
}
init {
if (instance == null) {
instance = this
}
}
}
If you want your fields/methods to be exposed as static to Java callers, you can apply the @JvmStatic annotation:
class Foo {
companion object {
private lateinit var instance: Foo
@JvmStatic fun get(): Foo {
return instance;
}
}
init {
if (instance == null) {
instance = this
}
}
}
Note that
@JvmStaticdoes not need any import (as it's built-in feature of Kotlin).
static final field in Java without getters, you probably should mark it @JvmField
@JvmField would work as described only within companion object, it just omits getter and setter functionsprivate lateinit var instance: Foo is of not-nullable type, so checking instance == null would never work as expectedIt looks that you want to define a singleton object. It is supported in Kotlin as a first-class concept:
object Foo {
...
}
All the boilerplate code with static field and constructor is taken care by the Kotlin automatically. You don't have to write any of that.
From the Kotlin code you can refer to the instance of this object simply as Foo. From the Java code you can referer to the instance of this object as Foo.INSTANCE, because the Kotlin compiler automatically creates the corresponding static field named INSTANCE.
first you create a simple class then after create a block followed by companion object keyword
for example:
class Test{
companion object{
fun getValue(): String{
return "Test String"
}
}
}
you can call this class function using class name dot function name
for example:
// here you will get the function value
Test.getValue()
You can create a companion object for the class, and if you want the field to be static you can use the annotation @JvmStatic. Companion object have access to private members of the class it is companion for.
See below an example:
class User {
private lateinit var name: String
override fun toString() = name
companion object {
@JvmStatic
val instance by lazy {
User().apply { name = "jtonic" }
}
}
}
class CompanionTest {
@Test
fun `test companion object`() {
User.instance.toString() shouldBe "jtonic"
}
}
