Kotlinda companion object: bu nima, sintaksisi va qo'llanishi

Kotlinda companion object nima?

companion object — Kotlin tilida object declaration ning maxsus turi bo'lib, companion kalit so'zi bilan belgilanadi. U klassga tegishli bo'lgan a'zolarni, ya'ni Java terminologiyasida statik a'zolarni e'lon qilish imkonini beradi. Java-da static alohida maydon va metodlar uchun modifikator bo'lgan holda, Kotlin-da statik a'zolar bitta obyekt-hamroh ichida guruhlanadi.

Kotlin-da har qanday klass aynan bitta companion objectga ega bo'lishi mumkin. Ushbu obyektning a'zolariga klass nomi orqali namuna yaratmasdan kirish mumkin: MyClass.method(). Shu bilan birga, bayt-kod nuqtai nazaridan companion object alohida ichki klassga kompilyatsiya qilinadi va uning metodlari @JvmStatic annotatsiyasidan foydalanilganda tashqi klassning statik metodlariga aylanadi.

Google I/O 2024 ma'lumotlariga ko'ra, companion object zamonaviy Kotlin Android ilovalarida fabrika metodlari, konstantalar va yordamchi funksiyalar uchun asosiy namunaga aylandi. Dasturchilar uni paket funksiyalari bo'lgan yordamchi klasslar o'rniga tanlaydilar, chunki companion object egalik qiluvchi klass bilan mantiqiy aloqani saqlaydi.

Statik kontekstni guruhlash uchun companion objectdan foydalaning — klassga mantiqiy tegishli bo'lgan, lekin namunani talab qilmaydigan konstantalar, fabrikalar, yordamchi metodlar.

Companion object sintaksisi: e'lon va kirish

Companion objectning asosiy sintaksisi sodda: companion kalit so'zi klass ichida object e'lonidan oldin joylashtiriladi. Agar nom ko'rsatilmasa, obyekt Companion nomini oladi va unga ochiq yoki yashirin tarzda murojaat qilish mumkin.

class User {
    companion object {
        const val TABLE_NAME = "users"

        fun create(name: String): User {
            return User(name)
        }
    }

    val name: String
    constructor(name: String) { this.name = name }
}

// Klass nomi orqali kirish
val table = User.TABLE_NAME
val user = User.create("Alice")

Yuqoridagi misolda TABLE_NAME va create() User.TABLE_NAME va User.create() orqali mavjud. Primitiv konstantalar uchun const modifikatoriga e'tibor bering — u qiymatning kompilyatsiya bosqichida joylashtirilishini kafolatlaydi, Java-dagi static final bilan bir xil.

Companion orqali yashirin va ochiq kirish

Agar companion object nomga ega bo'lmasa, unga avtomatik Companion nomi orqali murojaat qilish mumkin: User.Companion.TABLE_NAME. Amalda bu kamdan-kam talab qilinadi, lekin Java kodidan chaqirishda yoki refleksiyadan foydalanishda foydali.

// Ikkala chaqiruv ham ekvivalent
User.create("Bob")
User.Companion.create("Bob")

// Companion objectga havola olish
val companion: User.Companion = User

Nomli companion object va xususiyatlari

companion object nomga ega bo'lishi mumkin, bu kodning o'qilishini yaxshilaydi va unga tushunarli nom bilan murojaat qilish imkonini beradi. Factory — fabrika sifatida ishlatiladigan companion object uchun eng keng tarqalgan nom.

class HttpResponse {
    companion object Factory {
        fun ok(body: String): HttpResponse = HttpResponse(200, body)
        fun notFound(): HttpResponse = HttpResponse(404, "Not Found")
        fun serverError(): HttpResponse = HttpResponse(500, "Internal Error")
    }
}

// Factory nomi orqali kirish
val response = HttpResponse.Factory.ok("data")

Nomli companion object statik a'zolarning maqsadini hujjatlashtirishga yordam beradi. Refaktoringda nom kodni o'zini-o'zi hujjatlashtiradigan qiladi — dasturchi darhol ko'radi that Factory HttpResponse namunalarini yaratadi.

Cheklov: klassga faqat bitta companion object

Klass faqat bitta companion objectga ega bo'lishi mumkin. Bu Java-dan asosiy farqdir — Java-da guruhlashsiz istalgan sonli statik maydon va metodlarni e'lon qilish mumkin. Agar bir nechta mantiqiy statik a'zo guruhi kerak bo'lsa, companionsiz ichma-ich object declarations dan foydalaning.

Rasmiy Kotlin hujjatlariga ko'ra (Kotlin Docs, 2025), bitta companion object cheklovi til dizayni bilan asoslangan: statik a'zolar klass bilan chambarchas bog'liq bo'lishi kerak va bitta obyekt-hamroh bu bog'liqlikning aniq chegarasini ta'minlaydi. Statik a'zolar juda ko'p bo'lsa — bu klassni refaktoring qilish uchun signaldir.

Interfeyslarda companion object

Kotlin-da interfeyslar ham companion objectga ega bo'lishi mumkin. Bu Java-da mumkin bo'lmagan holda, to'g'ridan-to'g'ri interfeys ichida statik metodlar va konstantalarni belgilash imkonini beradi. Ushbu yondashuv tez-tez interfeys bilan bog'liq konstantalar yoki fabrika metodlarini e'lon qilish uchun ishlatiladi.

interface ApiService {
    companion object {
        const val BASE_URL = "https://api.example.com"
        const val TIMEOUT_MS = 5000

        fun create(client: OkHttpClient): ApiService =
            Retrofit.Builder()
                .baseUrl(BASE_URL)
                .client(client)
                .build()
                .create(ApiService::class.java)
    }
}

Ushbu misolda BASE_URL, TIMEOUT_MS va create() ApiService interfeysiga tegishli, uning amalga oshirilishiga emas. Bu qulay: API xizmatining namunasini yaratish uchun barcha konstantalar va fabrika mantig'i bir joyda — interfeysning o'zida joylashgan.

Interfeysning amalga oshirilishi companion object a'zolarini meros qilib olmaydi — ular faqat interfeys nomi orqali chaqiriladi: ApiService.BASE_URL.

@JvmStatic va @JvmField: Java bilan muvofiqlik

Java kodidan companion object metodlarini chaqirishda ular sukut bo'yicha Companion ichki klassining metodlari sifatida mavjud, tashqi klassning statik metodlari sifatida emas. Ularni Java uchun haqiqiy static metod va maydon sifatida eksport qilish uchun metodlar uchun @JvmStatic, maydonlar uchun @JvmField annotatsiyasidan foydalaning.

class MathUtils {
    companion object {
        const val PI = 3.14159

        @JvmStatic
        fun square(x: Int): Int = x * x

        @JvmField
        val TAG: String = "MathUtils"
    }
}

// Java-da MathUtils.square(5), MathUtils.TAG sifatida chaqiriladi

@JvmStatic dan foydalanish Java kodidan mavjud bo'lishi kerak bo'lgan barcha umumiy companion object metodlari uchun tavsiya etiladi. const faqat primitiv turlarga va String ga qo'llaniladi — qolgan turlar uchun @JvmField dan foydalaning.

Companion objectdan foydalanishning amaliy misollari

Real loyihalarda companion object bir nechta standart stsenariy uchun qo'llaniladi. Fabrika metodlari — eng keng tarqalgan naqsh: turli imzolarga ega ko'plab konstruktorlar o'rniga companion objectda nomli fabrika metodlaridan foydalaniladi.

sealed class NetworkResult<out T> {
    data class Success<out T>(val data: T) : NetworkResult<T>()
    data class Error(val message: String) : NetworkResult<Nothing>()

    companion object {
        fun loading<T>(): NetworkResult<T> =
            Loading()
    }
}

private class Loading<T> : NetworkResult<T>()

NetworkResult dagi companion object to'g'ri generic turi bilan Loading namunasini yaratuvchi loading() fabrika metodini taqdim etadi. Bu metodsiz to'g'ridan-to'g'ri Loading() orqali namuna yaratish kerak bo'lardi, bu esa ichki amalga oshirishni ochib beradi.

Loging uchun konstantalar va teglar

Tez-tez companion object klassga xos konstantalarni saqlash uchun ishlatiladi. const val bilan e'lon qilingan konstantalar kompilyatsiya bosqichida joylashtiriladi, bu esa ishlash vaqtida nol yuk beradi.

class UserRepository {
    companion object {
        private const val TAG = "UserRepository"
        private const val CACHE_SIZE = 100
        private const val DEFAULT_PAGE_SIZE = 20
    }
}