Composition აგებს ქცევას სხვა ობიექტების ჯერჯამულად შენახვის მეშვეობით ("has-a" ურთიერთობა) და მათზე დელეგირებით. Inheritance იძენს ქცევას კლასის გაფართოვების მეშვეობით ("is-a"). რჩევა "კომპოზიცია უპირატესია" არსებობს იმიტომ, რომ მემკვიდრეობა ქმნის მჭიდრო, მოუღალო დაკავშირებას ზედა კლასის კოდთან, ხოლო კომპოზიცია დაკავშირებული რჩება მოქნილი.
<T> <T> {
{ add(x); }
T { remove(size() - ); }
}
class Stack<T> {
private final List<T> items = new ArrayList<>(); // HAS-A list
void push(T x) { items.add(x); }
T pop() { return items.remove(items.size() - 1); }
// only push/pop are exposed → LIFO invariant is safe
}
სიის შენახვის ნაცვლად იყო-ს არჩევით, Stack ხელმისაწვდომი ხდის მხოლოდ იმ ოპერაციებს, რომელთა გაჩვენებაც სჭირდება.
| კომპოზიცია | მემკვიდრეობა |
|---|---|
| მოქნილი, ნაწილებს ჩანაცვლებენ runtime-ზე | დაფიქსირებული კომპილაციის დროს |
| შიგნიდან იმალება (დელეგირება) | მთელი ინტერფეისი მემკვიდრეობით |
| მეტი კაბელი/boilerplate | ნაკლები კოდი კი ის is-a |
| თავიდან აცილებს მოუღალო ზედა კლას | სუბკლასი ირღვევა თუ ზედა კლასი შეიცვლება |
მემკვიდრეობის გამოყენება მხოლოდ ჭეშმარიტი, სტაბილური is-a ურთიერთობებისთვის; კომპოზიცია "ამ ქცევა მჭირდება" სიტუაციებში.
მემკვიდრეობა ზედა კლასის მთელი ინტერფეისს ხელმისაწვდომი ხდის, ამიტომ სუბკლასი ვერ აკონტროლებს სრულად საკუთარ ხელშეკრულებას — Stack extends ArrayList გაჟონვა კლასიკური მაგალითია.
კომპოზიცია რელაციებს ხელმისაწვდომი და ჩანაცვლებადი ინახავს, რის გამოც დამოკიდებულების ინექცია, სტრატეგიის ნიმუშები და უმეტეს მოქნილი დიზაინი მას ეყრდნობა.