Java Static Methods in Kotlin: Equivalents and Best Practices

By the end of this page, you will understand how Kotlin handles functionality that would be written as static in Java. You will learn when to use top-level functions, companion objects, and object declarations, and how each option maps to common Java patterns.

Kotlin does not use the static keyword. Instead, it offers several language features that cover the same use cases more cleanly.

In Java, static is often used for:

• utility methods
• factory methods
• constants
• shared state
• methods tied to a class rather than an instance

In Kotlin, the equivalent depends on why the method is static.

1. Top-level functions

A function can be declared directly in a file, outside any class:

fun add(a: Int, b: Int): Int {
    return a + b
}

This is the most common replacement for Java utility-style static methods. If the function does not need access to class internals, a top-level function is often the simplest and most idiomatic choice.

2. Companion objects

If the function conceptually belongs to a class, put it inside a companion object:

class User(val name: String) {
    companion object {
        fun createGuest(): User {
            return User("Guest")
        }
    }
}

This is commonly used for factory methods and class-level behavior.

Think of Java static as saying: "this belongs to the class itself, not to a particular object."

Kotlin splits that idea into different tools:

• Top-level function = a tool placed directly on the workbench, ready to use
• Companion object = a tool stored inside a specific class's cabinet
• Object declaration = a special toolbox that exists only once

So instead of one static keyword doing many jobs, Kotlin gives you separate features for separate purposes.

That makes your intent clearer:

• Is this just a general utility? Use a top-level function.
• Is this part of how a class is created or managed? Use a companion object.
• Do you want one shared holder for behavior or state? Use an object declaration.

Top-level function

fun greet(name: String): String {
    return "Hello, $name"
}

fun main() {
    println(greet("Ava"))
}

Use this when the function does not logically belong to a class.

Companion object

class Logger private constructor(val prefix: String) {
    companion object {
        fun default(): Logger {
            return Logger("APP")
        }
    }
}

fun main() {
    val logger = Logger.default()
    println(logger.prefix)
}

Use this when the method is related to the class itself, such as a factory method.

Object declaration

object StringUtils {
    :  {
         text.isBlank() || text.length < 
    }
}

 {
    println(StringUtils.isBlankOrShort())
}

Consider this example:

class User(val name: String) {
    companion object {
        fun guest(): User {
            return User("Guest")
        }
    }
}

fun main() {
    val user = User.guest()
    println(user.name)
}

Step by step:

1. class User(val name: String) defines a class with one property: name.
2. Inside the class, companion object defines class-level behavior.
3. fun guest(): User creates and returns a new User object.
4. In main(), User.guest() is called.
5. Kotlin resolves that call through the companion object.
6. The function returns User("Guest").
7. The returned object is stored in user.
8. println(user.name) prints .

Utility functions

Top-level functions are commonly used for:

• formatting dates
• parsing strings
• validating input
• converting data

Example:

fun normalizeEmail(email: String): String {
    return email.trim().lowercase()
}

Factory methods

Companion objects are useful when creating objects in controlled ways:

class ApiClient private constructor(val baseUrl: String) {
    companion object {
        fun production(): ApiClient {
            return ApiClient("https://api.example.com")
        }
    }
}

Shared configuration or helpers

object declarations are useful for one shared holder:

object AppConfig {
    const val API_VERSION = "v1"
}

In real Kotlin projects, developers usually choose based on ownership and intent.

Common patterns

Top-level utility functions

Used for pure operations that do not depend on object state.

fun parsePort(value: String): Int {
    return value.toIntOrNull() ?: 8080
}

This is common in:

• validation helpers
• mapping functions
• formatting code
• extension-support utilities

Companion object for factories

Used when object creation should be controlled or named.

class Session private constructor(val token: String) {
    companion object {
        fun fromToken(token: String): Session {
            require(token.isNotBlank())
            return Session(token)
        }
    }
}

This often appears with:

• validation before construction
• named constructors
• parsing methods such as fromJson()

1. Translating every Java static method into a companion object

Beginners often put everything into a companion object just because it feels closest to Java.

class MathUtils {
    companion object {
        fun add(a: Int, b: Int): Int = a + b
    }
}

This works, but if the function is just a general helper, a top-level function is usually cleaner:

fun add(a: Int, b: Int): Int = a + b

2. Using an object when no singleton is needed

If you only want a simple helper function, an object may add unnecessary structure.

Broken design:

object EmailHelper {
    fun normalize(email: String): String = email.trim().lowercase()
}

Often simpler:

Top-level function vs companion object

Quick rules

• Kotlin has no static keyword.
• Use a top-level function for standalone helpers.
• Use a companion object for class-related methods.
• Use an object declaration for a singleton.
• Use @JvmStatic when Java interoperability requires static-style access.

Syntax

Top-level function

fun doWork() {
    println("working")
}

Companion object

class MyClass {
    companion object {
        fun create(): MyClass = MyClass()
    }
}

Object declaration

object Utils {
    fun help() {}
}

Java-friendly static access

What is the Kotlin equivalent of a Java static method?

Usually a top-level function or a method inside a companion object, depending on whether the method belongs to a class.

Does Kotlin support static methods?

Not with a static keyword. Kotlin uses other features to cover the same use cases.

When should I use a companion object in Kotlin?

Use it when the function is logically tied to a class, such as factory methods, constants, or class-level utilities.

Are top-level functions better than companion objects?

For standalone utility behavior, yes. They are often simpler and more idiomatic.

What is @JvmStatic in Kotlin?

@JvmStatic tells Kotlin to expose a method in a Java-friendly static style when used inside a companion object or object.

Can a companion object access instance properties?

No. A companion object does not automatically have access to instance data. It can only use class-level members or work with an instance passed to it.

Should I use object for utility methods?

Sometimes, but only when a singleton container makes sense. For many helpers, top-level functions are simpler.

How do I convert Java utility classes to Kotlin?

In many cases, convert their static methods into top-level functions. If grouping is useful, consider an .

• Functions in Kotlin — Static-like behavior in Kotlin is built using functions.
• Companion objects — The main class-level feature used instead of Java static members.
• Object declarations — Useful for singleton-style shared behavior and state.
• Top-level declarations — Important because Kotlin allows functions and properties outside classes.
• @JvmStatic — Relevant when Kotlin code must interoperate with Java code.
• Factory methods — A common reason to use companion objects.
• Singleton pattern — Closely related to Kotlin object declarations.
• Java interoperability in Kotlin — Helps explain how Kotlin features appear when called from Java.