Является ли одним экземпляром companion object для разных экземпляров класса?

Введение

Companion object (спутниковый объект) в Kotlin действительно является единственным экземпляром для всех экземпляров класса, к которому он принадлежит. Это реализация паттерна "Одиночка" (Singleton) в контексте класса. Давайте детально разберем этот механизм.

Механизм работы Companion Object

Companion object объявляется внутри класса с использованием ключевого слова companion object. Несмотря на то, что он находится в теле класса, он не является частью каждого экземпляра класса. Вместо этого он существует в единственном экземпляре на уровне класса, аналогично статическим членам в Java, но с более богатыми возможностями, так как является полноценным объектом.

Пример кода

class MyClass {
    companion object {
        private var counter: Int = 0
        fun incrementAndGet(): Int {
            return ++counter
        }
    }
    
    val id = incrementAndGet()
}

fun main() {
    val obj1 = MyClass()
    val obj2 = MyClass()
    val obj3 = MyClass()
    
    println("obj1.id = ${obj1.id}") // Вывод: obj1.id = 1
    println("obj2.id = ${obj2.id}") // Вывод: obj2.id = 2
    println("obj3.id = ${obj3.id}") // Вывод: obj3.id = 3
}

В этом примере:

• counter — это свойство companion object, которое существует в единственном экземпляре.
• Каждый раз при создании нового экземпляра MyClass вызывается метод incrementAndGet() того же самого companion object, что приводит к увеличению общего счетчика.
• Результат демонстрирует, что состояние counter разделяется между всеми экземплярами класса.

Доказательство единственности экземпляра

Можно напрямую доказать, что companion object является одним и тем же экземпляром:

class Test {
    companion object {
        val uuid = java.util.UUID.randomUUID()
    }
}

fun main() {
    val instance1 = Test()
    val instance2 = Test()
    
    println(Test.Companion.uuid) // Вывод: одинаковый UUID
    println(Test.uuid)           // Вывод: тот же самый UUID
    
    // Сравнение через ссылку на companion object
    println(Test.Companion === Test.Companion) // Вывод: true
}

Особенности и важные аспекты

1. Доступность

• Члены companion object доступны напрямую через имя класса: MyClass.someFunction().
• Они также могут быть доступны через экземпляры класса, но это считается антипаттерном и не рекомендуется.

2. Наследование и интерфейсы

Companion object может наследовать классы и реализовывать интерфейсы:

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

class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass {
            return MyClass()
        }
    }
}

// Использование
val obj = MyClass.create() // Через интерфейс Factory

3. Именованные companion object'ы

Companion object может иметь имя, хотя это необязательно:

class MyClass {
    companion object Named {
        const val TAG = "MyClass"
    }
}

// Обращение
println(MyClass.Named.TAG)

4. Отличие от статических членов Java

1. Companion object — это объект, который может иметь состояние, наследоваться и реализовывать интерфейсы.
2. В байт-коде JVM члены companion object действительно компилируются в статические члены, если они не обращаются к приватным членам внешнего класса.
3. Для Java-кода companion object доступен через статическое поле Companion: MyClass.Companion.someMethod().

Практическое применение

1. Фабричные методы

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User {
            return User(name.trim())
        }
    }
}

2. Константы

class ApiClient {
    companion object {
        const val BASE_URL = "https://api.example.com"
        const val TIMEOUT = 30_000
    }
}

3. Кеширование и общие ресурсы

class ImageLoader {
    companion object {
        private val cache = mutableMapOf<String, Bitmap>()
        
        fun load(url: String): Bitmap {
            return cache.getOrPut(url) { downloadImage(url) }
        }
    }
}

Заключение

Таким образом, companion object действительно существует как единственный экземпляр на уровне класса, а не на уровне каждого экземпляра класса. Это мощный инструмент Kotlin, который сочетает преимущества статических членов Java с возможностями объектно-ориентированного программирования, позволяя создавать более выразительный и безопасный код. Понимание этого механизма важно для правильного проектирования классов и управления их состоянием и поведением.