რა არის Generics და რა მიზნით გამოიყენება?

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

გამოყენებულია:

1. ტიპების უსაფრთხოების გაუმჯობესება (Type Safety): კომპილატორი ამოწმებს მონაცემთა ტიპებს კომპილაციის დროს, თავიდან აცილებს შეცდომებს, რომლებიც შეიძლება გამოვლინდეს მხოლოდ შესრულების დროს (Runtime Errors).

   // მაგალითი გენერიკების გარეშე - პოტენციური შეცდომა მონაცემების ამოღებისას
   List list = new ArrayList();
   list.add("string");
   list.add(123); // შეიძლება დაამატოს ნებისმიერი ტიპი
   String s = (String) list.get(1); // შეცდომა ClassCastException დროს შესრულების
   

2. კოდის მრავალჯერადი გამოყენება (Code Reusability): ერთსა და იმავე კოდი შეიძლება მუშაობდეს სხვადასხვა ტიპის მონაცემებთან, საჭიროების გარეშე დაწეროს სხვადასხვა ვერსიები თითოეულ ტიპზე.

   // გენერიკებით - უსაფრთხო გამოყენება
   List<String> list = new ArrayList<>(); // მითითებულია ტიპი String
   list.add("string");
   // list.add(123); // კომპილატორი გამოიტანს შეცდომას - ვერ დაამატებთ int-ს
   String s = list.get(0); // არ არის საჭირო ტიპის გადაყვანა
   

3. კოდის წაკითხულობის გაუმჯობესება: მონაცემთა ტიპების მკაფიო მითითება ეხმარება გაიგოთ, თუ რა მონაცემებთან მუშაობს კოდი.

4. პროდუქტიულობის ოპტიმიზაცია: ზოგიერთი ენის (მაგალითად, C#) გენერიკები უზრუნველყოფს უკეთეს შესრულებას შედარებით ბაზის ტიპებთან (მაგალითად, Object), რადგან არ არის საჭირო ბოქსინგი/რებოქსინგი (boxing/unboxing).

მაგალითად, სტანდარტული კოლექციები (სია, ნაკრები, რუკები) უმეტეს ენებში იყენებენ გენერიკებს, რათა უზრუნველყონ უსაფრთხოება და სარგებელი.

Без Generics	С Generics
მუშაობს Object ტიპთან	მუშაობს კონკრეტულ ტიპებთან
საჭიროებს ტიპის მკაფიო გადაყვანას	არ საჭიროებს გადაყვანას ტიპების
ტიპის შეცდომები იპოვება Runtime-ში	ტიპის შეცდომები იპოვება კომპილაციის დროს
ნაკლებად წასაკითხი კოდი	უფრო წასაკითხი კოდი