Util class in Kotlin (Best Approach)? [duplicate]

Question

I was playing with Kotlin, and creating Util class with different ways. I am approaching a way that works best for calling by either Kotlin or Java.

Now I have created many types of Util. And now I am very confused which is best to use and most important why? I am finding best way considering Heap, Memory, Performance.

My question may look stupid for you guys, but I am in maze and can't come to a solution myself.

Here is my playground.

I have created 5 Kotlin files. in which I have put foo() method. and tried to call by Kotlin and Java.

Calling class Bar.kt

class Bar {
    fun bazz() {
        UtilClass.instance.foo()
        UtilClassObject.UtilClassObject.foo()
        UtilCompanionObject.foo()
        UtilFileObject.foo()
        foo() // from UtilFile
    }
}

Calling class Qux.java

public class Qux {
    public void bazz() {
        UtilClass.Companion.getInstance().foo();
        UtilClassObject.UtilClassObject.INSTANCE.foo();
        UtilFileKt.foo();
        UtilFileObject.INSTANCE.foo();
        UtilCompanionObject.Companion.foo();
    }
}

And here is the maze that makes me confused to choose best.

UtilClass.kt

class UtilClass {
    fun foo() { ... }

    companion object {
        val instance = UtilClass()
    }
}

UtilClassObject.kt

class UtilClassObject {
    object UtilClassObject {
        fun foo() { ... }
    }
}

UtilCompanionObject.kt

class UtilCompanionObject {
    companion object {
        fun foo() { ... }
    }
}

UtilFile.kt

fun foo(){ ... }

UtilFileObject.kt

object UtilFileObject {
    fun foo() { ... }
}

It may take to answer my question and explaining it well. So I really appreciate your efforts in advance.

Answer 1

All options are present on the Kotlin reference page for interop between Kotlin and Java: https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html

Your options to call from Java something on class MyUtil and call it without an instance such as MyUtil.foo() then you would simply do one of the two options:

// smallest byte code, 
//   static invocation of foo() from Kotlin side,
//   also static call from Java to foo()
object MyUtil {
    @JvmStatic fun foo() { ... }
}

or

// creates two classes,
//    static lookup of companion followed by virtual call on that instance to foo() from Kotlin, 
//    Java is a static call to foo()
class MyUtil {
    companion object {
        @JvmStatic fun foo() { ... }
    }
}

And you would call it the same from Kotlin MyUtil.foo(). This is specifically the model of making a Kotlin method static.

Both examples look the same from Java in that they are just direct static calls to a static method. From Kotlin the first example is a static call as well, the second looks up an instance of the companion first and then does a virtual call on the method. The Second example creates two classes, the other only creates a single class.

The other options you present are not more efficient and are uglier syntax. Based on smallest byte code, fewest classes, and fastest performance pick the first example that is 1 class only and all static calls.