რა იცით კლასების კომპოზიციაზე პროგრამირებაში?

კომპოზიცია — ეს არის "შეიცავს" ან "შეადგენს ნაწილ-პოლუს" კავშირი, სადაც ერთი კლასი (კომპოზიტი) შეიცავს სხვა კლასის (კომპონენტის) მითითებას ან მისი ეგზემპლარებს. კომპონენტის სიცოცხლის ციკლი ჩვეულებრივ მჭიდროდ არის დაკავშირებული კომპოზიტის სიცოცხლის ციკლთან. ეს არის ძლიერი კავშირი, სადაც კომპონენტი ვერ არსებობს დამოუკიდებლად კომპოზიტის გარეშე.

კომპოზიციის უპირატესობები:

• მოწესრიგება: ადვილია შეცვალო ქცევა, შეცვლით კომპონენტებს.
• მცირე დამოკიდებულება: კლასები ნაკლებად არიან დამოკიდებული ერთმანეთზე მემკვიდრეობასთან შედარებით.
• განახლება: ერთსა და იმავე კომპონენტებს შეიძლება გამოიყენოთ სხვადასხვა კომპოზიტებში.

მაგალითი: კლასი ავტომობილი შეიძლება შეიცავდეს კლასი ძრავა-ს მითითებას. თუ ავტომობილი განადგურდა, მაშინ ძრავა (ამ კონტექსტში) შეწყდება არსებობა.

კლასი ძრავა {
    // ძრავის თვისებები და მეთოდები
}

კლასი მანქანა {
    კერძო ძრავა; // კომპოზიცია

    საჯარო მანქანა() {
        ეს.ძრავა = ახალი ძრავა(); // კომპონენტის შექმნა კომპოზიტში
    }

    // სხვა თვისებები და მეთოდები მანქანის
}

განსხვავება აგრეგაციასთან: აგრეგაციაში კომპონენტები შეიძლება არსებობდნენ დამოუკიდებლად კომპოზიტისგან (სუსტი კავშირი). მაგალითი: კლასი უნივერსიტეტი შეიცავს მითითებებს სტუდენტი კლასის ეგზემპლარებზე. სტუდენტები შეიძლება არსებობდნენ და გარეთ უნივერსიტეტის.

Android-ის განვითარების დროს, კომპოზიცია აქტიურად გამოიყენება, მაგალითად, წარმოდგენების შექმნისას (ViewGroup შეიცავს View-ს), დამოკიდებულებებთან მუშაობაში Dagger/Hilt-ის საშუალებით. ეს არის უპირატესობა მრავალმემკვიდრეობასთან შედარებით (რომელიც Java/Kotlin-ში არ არსებობს კლასებისთვის) და ხშირად უფრო მოქნილი, ვიდრე ერთმემკვიდრეობა.

კლასი UserRepository(private val apiService: ApiService) {
    // UserRepository "გამოყენებს" ApiService-ს (კომპოზიცია/აგრეგაცია)
    ფუნქცია fetchUser(userId: String) {
        // apiService.getUser(userId)
    }
}