Kotlin'de Companion object: nedir, sözdizimi ve kullanımı

Kotlin'de companion object nedir?

companion object, Kotlin'de companion anahtar sözcüğüyle işaretlenmiş özel bir object bildirimi türüdür. Örnekler yerine sınıfa ait olan üyeleri — yani Java terimleriyle statik üyeleri — bildirmeye izin verir. static'in tek tek alanlar ve metotlar için bir değiştirici olduğu Java'nın aksine, Kotlin'de statik üyeler tek bir yoldaş nesne içinde gruplanır.

Kotlin'deki herhangi bir sınıf tam olarak bir companion object içerebilir. Bu nesnenin üyelerine bir örnek oluşturmadan sınıf adı aracılığıyla erişilebilir: MyClass.method(). Bayt kodu açısından, companion object ayrı bir iç sınıf olarak derlenir ve @JvmStatic ek açıklaması kullanıldığında metotları dış sınıfın statik metotları haline gelir.

Google I/O 2024'e göre, companion object, Kotlin'de yazılan modern Android uygulamalarında fabrika metotları, sabitler ve yardımcı işlevler için ana model haline gelmiştir. Geliştiriciler, paket düzeyinde işlevlere sahip yardımcı sınıflar yerine bunu tercih eder çünkü companion object, sahip sınıfla mantıksal bağlantıyı korur.

Statik bağlamı — sabitleri, fabrikaları, mantıksal olarak sınıfa ait olan ancak bir örnek gerektirmeyen yardımcı metotları — gruplamak için companion object kullanın.

Companion object sözdizimi: bildirim ve erişim

companion object'in temel sözdizimi basittir: companion anahtar sözcüğü, sınıf içindeki object bildiriminin önüne yerleştirilir. Bir ad belirtilmezse, nesne Companion adını alır ve açık veya örtük olarak erişilebilir.

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 }
}

// Access via class name
val table = User.TABLE_NAME
val user = User.create("Alice")

Yukarıdaki örnekte, TABLE_NAME ve create()'e User.TABLE_NAME ve User.create() aracılığıyla erişilebilir. İlkel sabitler için const değiştiricisine dikkat edin — derleme zamanında değer eklemesini garanti eder, ilkeller ve String için Java static final'e benzer.

Companion aracılığıyla örtük ve açık erişim

Bir companion object'in adı yoksa, otomatik ad Companion: User.Companion.TABLE_NAME aracılığıyla erişilebilir. Pratikte bu nadiren gereklidir, ancak Java kodundan çağrı yaparken veya yansıma kullanırken yararlıdır.

// Both calls are equivalent
User.create("Bob")
User.Companion.create("Bob")

// Getting reference to companion object
val companion: User.Companion = User

Adlandırılmış companion object ve özellikler

Bir companion object bir ada sahip olabilir, bu da kod okunabilirliğini artırır ve anlamlı bir adla erişime izin verir. Factory, fabrika olarak kullanılan bir companion object için en yaygın addır.

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")
    }
}

// Access via Factory name
val response = HttpResponse.Factory.ok("data")

Adlandırılmış bir companion object, statik üyelerin amacını belgelemeye yardımcı olur. Yeniden düzenlemede, ad kodu kendi kendini belgeleyen hale getirir — geliştirici, Factory'nin HttpResponse örnekleri oluşturduğunu hemen görür.

Sınırlama: sınıf başına tam olarak bir companion object

Bir sınıf yalnızca bir companion object içerebilir. Bu, gruplama olmadan istediğiniz sayıda statik alan ve metot bildirebileceğiniz Java'dan temel bir farktır. Birden çok mantıksal statik üye grubuna ihtiyacınız varsa, companion olmadan iç içe object bildirimleri kullanın.

Resmi Kotlin belgelerine (Kotlin Docs, 2025) göre, tek companion object sınırlaması dil tasarımıyla motive edilmiştir: statik üyeler sınıfla sıkı bir şekilde bağlanmalıdır ve bir yoldaş nesne bu bağlantı için net bir sınır sağlar. Çok fazla statik üye varsa, bu sınıfı yeniden düzenleme sinyalidir.

Arabirimlerde Companion object

Kotlin'de, arabirimler de companion object içerebilir. Bu, Java'da mümkün olmayan bir şekilde, doğrudan bir arabirim içinde statik metotlar ve sabitler tanımlamaya izin verir. Bu yaklaşım, genellikle arabirimle ilgili sabitleri veya fabrika metotlarını bildirmek için kullanılır.

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)
    }
}

Bu örnekte, BASE_URL, TIMEOUT_MS ve create(), ApiService arabirimine aittir, uygulamalarına değil. Bu kullanışlıdır: tüm sabitler ve bir API hizmet örneği oluşturma mantığı tek bir yerde — arabirimin kendi içinde — bulunur.

Arabirim uygulamaları, companion object'in üyelerini devralmaz — bunlar yalnızca arabirim adı: ApiService.BASE_URL aracılığıyla çağrılır.

@JvmStatic ve @JvmField: Java uyumluluğu

Java kodundan companion object metotları çağrılırken, varsayılan olarak dış sınıfın statik metotları olarak değil, iç içe Companion sınıfının metotları olarak erişilebilirler. Bunları Java için gerçek statik metotlar ve alanlar olarak dışa aktarmak için metotlar için @JvmStatic ve alanlar için @JvmField ek açıklamasını kullanın.

class MathUtils {
    companion object {
        const val PI = 3.14159

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

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

// Called in Java as MathUtils.square(5), MathUtils.TAG

Java kodundan erişilebilir olması gereken tüm genel companion object metotları için @JvmStatic kullanılması önerilir. const yalnızca ilkel türlere ve String'e uygulanır — diğer türler için @JvmField kullanın.

Companion object kullanımının pratik örnekleri

Gerçek projelerde, companion object birkaç standart senaryo için kullanılır. Fabrika metotları en yaygın modeldir: farklı imzalara sahip birden çok kurucu yerine, companion object içinde adlandırılmış fabrika metotları kullanılır.

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 içindeki companion object, doğru genel türle bir Loading örneği oluşturan loading() fabrika metodu sağlar. Bu metot olmadan, doğrudan Loading() aracılığıyla bir örnek oluşturmanız gerekir, bu da iç uygulamayı açığa çıkarır.

Sabitler ve günlük etiketleri

companion object genellikle sınıfa özgü sabitleri depolamak için kullanılır. const val ile bildirilen sabitler derleme zamanında satır içine alınır ve çalışma zamanında sıfır ek yük sağlar.

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