Companion object у Kotlin-у: шта је то, синтакса и примена

Шта је companion object у Kotlin-у?

companion object — специјална врста object declaration у језику Kotlin која се означава кључном речи companion. Омогућава декларисање чланова који припадају класи, а не њеним инстанцама — односно статичких чланова у терминологији Java-е. За разлику од Java-е, где је static модификатор за појединачна поља и методе, у Kotlin-у статички чланови се групишу унутар једног објекта-пратиоца.

Свака класа у Kotlin-у може садржати тачно један companion object. Чланови овог објекта су доступни путем имена класе без креирања инстанце: MyClass.method(). Истовремено, са становишта бајт-кода, companion object се компајлира у засебну унутрашњу класу, а његови методи постају статички методи спољашње класе када се користи анотација @JvmStatic.

Према Google I/O 2024, companion object је постао главни образац за фабричке методе, константе и помоћне функције у савременим Android апликацијама на Kotlin-у. Програмери га бирају уместо помоћних класа са пакетним функцијама, јер companion object задржава логичку везу са класом-власником.

Користите companion object за груписање статичког контекста — константи, фабрика, помоћних метода које се логички односе на класу, али не захтевају инстанцу.

Синтакса companion object-а: декларација и приступ

Основна синтакса companion object-а је једноставна: кључна реч companion се поставља испред декларације object унутар класе. Ако име није наведено, објекат добија име Companion, којем се може приступити експлицитно или имплицитно.

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

// Приступ путем имена класе
val table = User.TABLE_NAME
val user = User.create("Alice")

У горњем примеру TABLE_NAME и create() су доступни путем User.TABLE_NAME и User.create(). Обратите пажњу на модификатор const за примитивне константе — он гарантује уграђивање вредности у фази компајлирања, аналогно Java static final за primitive и String.

Имплицитни и експлицитни приступ путем Companion

Ако companion object нема име, може му се приступити путем аутоматског имена Companion: User.Companion.TABLE_NAME. У пракси је то ретко потребно, али је корисно при позивању из Java кода или при коришћењу рефлексије.

// Оба позива су еквивалентна
User.create("Bob")
User.Companion.create("Bob")

// Добијање референце на companion object
val companion: User.Companion = User

Именовани companion object и особености

companion object може имати име, што побољшава читљивост кода и омогућава позивање по разумљивом имену. Factory — најчешће име за companion object који се користи као фабрика.

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
val response = HttpResponse.Factory.ok("data")

Именовани companion object помаже у документовању намене статичких чланова. При рефакторисању, име чини код самодокументујућим — програмер одмах види да Factory креира инстанце HttpResponse.

Ограничење: тачно један companion object по класи

Класа може садржати само један companion object. Ово је суштинска разлика од Java-е, где се може декларисати било који број статичких поља и метода без груписања. Ако је потребно више логичких група статичких чланова, користите угњеждене object declarations без companion.

Према званичној документацији Kotlin-а (Kotlin Docs, 2025), ограничење на један companion object мотивисано је дизајном језика: статички чланови треба да буду уско повезани са класом, а један објекат-пратилац обезбеђује јасну границу те везе. Ако статичких чланова има превише — то је сигнал за рефакторисање класе.

Companion object у интерфејсима

У Kotlin-у и интерфејси могу садржати companion object. Ово омогућава дефинисање статичких метода и константи директно унутар интерфејса, што није могуће у Java-и. Овај приступ се често користи за декларисање константи повезаних са интерфејсом или фабричких метода.

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

У овом примеру BASE_URL, TIMEOUT_MS и create() припадају интерфејсу ApiService, а не његовим имплементацијама. Ово је згодно: све константе и фабричка логика за креирање инстанце API сервиса налазе се на једном месту — унутар самог интерфејса.

Имплементације интерфејса не наслеђују чланове companion object-а — они се позивају само путем имена интерфејса: ApiService.BASE_URL.

@JvmStatic и @JvmField: компатибилност са Java-ом

При позивању метода companion object-а из Java кода, они су подразумевано доступни као методи угњеждене класе Companion, а не као статички методи спољашње класе. Да бисте их извезли као праве static методе и поља за Java-у, користите анотацију @JvmStatic за методе и @JvmField за поља.

class MathUtils {
    companion object {
        const val PI = 3.14159

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

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

// Позвано у Java-и као MathUtils.square(5), MathUtils.TAG

Коришћење @JvmStatic се препоручује за све јавне методе companion object-а које треба да буду доступне из Java кода. const се примењује само на примитивне типове и String — за остале типове користите @JvmField.

Практични примери коришћења companion object-а

У реалним пројектима companion object се користи за неколико стандардних сценарија. Фабрички методи — најчешћи образац: уместо више конструктора са различитим потписима користе се именовани фабрички методи у companion object-у.

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

companion object у NetworkResult пружа фабрички метод loading() који креира инстанцу Loading са исправним generic типом. Без овог метода морали бисте креирати инстанцу директно путем Loading(), што открива унутрашњу имплементацију.

Константе и ознаке за логирање

Често се companion object користи за чување константи специфичних за класу. Константе декларисане са const val се уграђују у фази компајлирања, што даје нулти overhead у рантајму.

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