Зачем в Kotlin нужен companion object и как он заменяет static поля из Java?

Что такое companion object и зачем он нужен?

Вы правы: companion object в Kotlin — это аналог static из Java, но с важными отличиями. Kotlin полностью отказался от ключевого слова static, потому что в Kotlin всё является объектом. companion object — это не просто синтаксический сахар, а полноценный объект-компаньон, который живёт внутри класса.

Главное преимущество: companion object — это объект, а значит он может реализовывать интерфейсы, наследоваться от классов и иметь собственное имя. Вот ключевые возможности:

• Реализация интерфейсов — объект-компаньон может реализовывать интерфейсы, что невозможно с static методами в Java.
• Наследование — companion object может расширять другие классы.
• Именование — вы можете дать объекту имя (или использовать имя по умолчанию Companion).
• Полноправный объект — его можно передавать как аргумент, сохранять в переменные и т.д.

Пример с интерфейсом

Представьте, что вы хотите, чтобы у каждого класса была фабрика объектов. С companion object это легко:

interface Factory<T> {
    fun create(): T
}

class User private constructor(val name: String) {
    companion object : Factory<User> {
        override fun create() = User("Новый пользователь")
        
        fun createGuest() = User("Гость")
    }
}

// Использование
fun main() {
    val factory: Factory<User> = User // companion object реализует интерфейс!
    val user = factory.create()
    println(user.name) // Новый пользователь
    
    val guest = User.createGuest()
    println(guest.name) // Гость
}

В Java вы не смогли бы передать сам класс как реализацию интерфейса — пришлось бы создавать отдельный класс-фабрику.

Именование и доступ

Вы можете дать объекту имя и обращаться к нему:

class MyClass {
    companion object MyCompanion {
        val CONST = 42
    }
}

// Доступ
println(MyClass.CONST)         // 42 (имя объекта необязательно)
println(MyClass.MyCompanion.CONST) // тоже 42

Если имя не указано, используется Companion:

class MyClass {
    companion object {
        val CONST = 42
    }
}

println(MyClass.Companion.CONST) // так тоже можно

Почему не static?

Kotlin спроектирован так, чтобы избежать статического контекста. static в Java нарушает принципы ООП — статические методы не принадлежат экземпляру, а висят в воздухе. В Kotlin companion object — это настоящий объект, который:

• Имеет доступ к private членам класса (как static в Java).
• Может быть расширен с помощью extension-функций.
• Может быть использован в выражениях with() или apply().

Когда использовать companion object?

• Фабричные методы (например, User.createGuest()).
• Константы, связанные с классом (val MIN_AGE = 18).
• Счётчики экземпляров.
• Реализация паттерна Singleton, если нужно привязать к классу.

Важно: если вам не нужна привязка к классу, используйте обычный объект (object declaration) на уровне пакета. А если нужны только константы — top-level val.

// Если не нужна связь с классом — лучше так:
const val MIN_AGE = 18
object UserFactory {
    fun createGuest() = User("Гость")
}

Таким образом, companion object — это мощный инструмент, который даёт больше гибкости, чем static в Java. Он сохраняет всё лучшее от статических членов, но добавляет возможности ООП.

class User {
    companion object {
        @JvmStatic
        fun createGuest() = User("Гость")
        
        @JvmField
        val MIN_AGE = 18
    }
}

// Из Java:
User.createGuest(); // теперь это static метод
User.MIN_AGE;       // static поле