Utils class in Kotlin

Photo by Matteo Grassi on Unsplash

TL;DR: You can create utils class by putting methods inside an object, or use package-level functions.

If you’re integrating with Java code and need a true static utils method, you can put this method inside an object and annotate it with @JvmStatic.

For newcomers, Kotlin is a cross-platform, statically typed language with type inference. Kotlin is designed to interoperate fully with Java.

Kotlin is sponsored by JetBrains and Google. Google finally announced it to be a first-class language for writing Android apps in Google I/O 17.

Two years ago, when using Kotlin for the first time, I struggled to write a utils class, so I asked this question on StackOverflow. After that, I realized there are many ways to achieve that. In this article, I will cover how utils are written in Kotlin, but first, you need to know some basic concepts.

The static keyword

Java developers are familiar with static methods — which declared within a class using static keyword and can be accessed directly using the class name.

So can we do the same in Kotlin? The answer is YES, but in a different way.

Unlike Java, there is nothing called static in Kotlin.

So how can we achieve this?

Objects

There are 3 common types of objects in Kotlin: Object Declaration, Companion Object, and Object Expression.

Object — a powerful data type in Kotlin!

Object declarations

Singleton pattern is always very useful, and Kotlin makes it easy to declare:

This is an object declaration, it has a name following object keyword.

Like singleton, there is only one instance of an object, which is created the first time it’s accessed, in a thread-safe manner.

To refer to the object, we use its name directly:

val saber = SaberFactory.makeLightSaber(150)

Companion Objects

A companion object is an object that tied to a class with companion keyword.

Companion object can be used to declare method to be tied to a class rather than to instances of it.

A companion object is also singleton, so its methods can be accessed directly:

val saber = Saber.makeLightSaber(150)

The difference from a normal class

The difference is: you cannot initialize an object (like new in Java).

In fact, object is just a data type with a single instance. So if we want to find something similar in Java, that would be the Singleton pattern.

The best way to show the difference is to look at decompiled Kotlin code in Java form:

Here is the equivalent Java code generated: a singleton and a normal class.

Why does Kotlin introduce objects?

The primary reason is that Kotlin tries to do away with statics, leaving us with a purely Object-Oriented language. Kotlin discourages developers from using those concepts, instead, it replaces statics with singleton objects.

Calling Kotlin from Java

Kotlin code can be easily called from Java.

Kotlin is 100% interoperable with Java

Package-level functions

Package-level functions are all functions declared in a source file without an enclosing class or object.

All the functions declared in the file app.kt inside package org.example, are compiled into static methods of a Java class named org.example.AppKt (the class name in PascalCase + Kt ).

So that:

Will become:

Then in Java, we use AppKt to call the method:

org.example.AppKt.makeLightSaber();

Note: In the past, all top-level functions in the same package became a single Java class named after the package. But for some reason described here, JetBrains decided to get rid of this Single-Facade paradigm and use the file name for the generated class instead (app.kt → AppKt.class).

So, what if we want to change AppKt to another name?

@file:JvmName

The name of the generated Java class can be changed with @JvmName annotation

Then in Java, we use SaberUtils to call the method, instead of AppKt:

org.example.SaberUtils.makeLightSaber();

Note that, having multiple files with the same generated Java class name (same package & file name, or same @JvmName) will cause an error.

@JvmStatic

As mentioned above, Kotlin represents package-level functions as static methods. However, it can also generate static methods for those defined in objects if you annotate them as @JvmStatic. If you use this annotation, the compiler will generate both a static method in the enclosing class of the object and an instance method in the object itself.

For example:

In Java, you can use both as static method or normal method (of singleton).

SaberFactory.makeStaticSaber(); // works fine
SaberFactory.makeNonStaticSaber(); // error
SaberFactory.INSTANCE.makeNonStaticSaber(); // works, call through the singleton INSTANCE
SaberFactory.INSTANCE.makeStaticSaber(); // works too

Utils class in Kotlin

First approach

Use object. Create your utils method inside an object:

It’s fine when call this method from Kotlin, but when call from Java you need to add INSTANCE, because it’s just a normal method of singleton instance, not a static method.

// Call from Kotlin
SaberUtils.makeLightSaber(150)
// Call from Java
SaberUtils.INSTANCE.makeLightSaber(150)

Second approach

Use package-level functions (without class or object):

Now you can call SaberUtils.makeLightSaber() from Java code. But from Kotlin code it only allows to use makeLightSaber() method directly (without SaberUtils prefix), because it does not tie to any class.

What is the good approach?

The second approach is actually quite idiomatic in Kotlin. There’s no need to scope your utils method inside anything. Package-level functions are just fine to use, in fact, that’s what most of the standard lib consists of.

In Java, the utils class was the only way to provide utils methods. But these methods do not belong to any particular type or object, so using object for that in Kotlin does not make any sense. It isn't a singleton, right?

But there are also some reasons to choose the first approach:

• Use object to avoid showing all utils in suggestions when start typing.
• As a Java developer, for most utils methods I would prefer Utils.foo() than foo() in both Java and Kotlin.

Then, the third solution is: put methods inside object and use @JvmStatic for each of them.

Photo by Brendan Church on Unsplash

So what do you think? What is your approach to write utils class in Kotlin? Please comment below.

Happy coding~