Kotlin-ში კლასის შიგნით ობიექტსა და ობიექტის თანამგზავრის შორის რა განსხვავებაა?

ობიექტი კლასი შიგნით (inner object) დაკავშირებულია გარე კლასის ინстанციასთან და არსებობს მხოლოდ მისი სიცოცხლის ციკლში. ობიექტის კომპანიონი (companion object) არსებობს როგორც სინგლტონი, რომელიც არ არის დაკავშირებული კლასის ინстанციასთან და შეიძლება პირდაპირ მიუთითოთ კლასის სახელით.

ძირითადი განსხვავებები:

• ინსტანციის დაკავშირება: inner object დაკავშირებულია გარე კლასის ინстанციასთან, companion object არა.
• მოწვდომლობა: inner object ხელმისაწვდომია მხოლოდ გარე კლასის ინстанციის მეშვეობით, companion object - პირდაპირ კლასის სახელით.
• მდგომარეობა: inner object შეიძლება ჰქონდეს მდგომარეობა, რომელიც სპეციფიკურია ინстанციისთვის, companion object - საერთო კლასისთვის.
• გამოყენება: inner object ხშირად გამოიყენება Stateful დიზაინის ნიმუშის ან დაკავშირებული ობიექტების ჯგუფირებისათვის ინстанციის შიგნით. companion object გამოიყენება ფაბრიკის მეთოდებისთვის, კონსტანტებისთვის ან სტატიკური წევრებისთვის.

მაგალითი:

class Outer {
    private var outerValue: Int = 0

    inner object InnerObject {
        fun accessOuterValue(): Int {
            return outerValue // inner object-ს აქვს წვდომა გარე კლასის წევრებზე
        }
    }

    companion object CompanionObject {
        const val CONSTANT = "Some constant"

        fun createOuter(): Outer {
            return Outer() // ფაბრიკის მეთოდი
        }
    }
}

fun main() {
    val outer = Outer.CompanionObject.createOuter() // წვდომა companion object-ზე
    // val inner = Outer.InnerObject // შეცდომა: ვერ მიიღებთ InnerObject-ს გარე კლასის ინстанციის გარეშე
    val inner = outer.InnerObject // წვდომა inner object-თან ინстанციის მეშვეობით

    println(inner.accessOuterValue())
    println(Outer.CompanionObject.CONSTANT)
    println(Outer.CONSTANT) // სინდექსური შაქარი CompanionObject-ის წევრებზე წვდომისთვის
}