რა არის ჯენერიკი და რატომ გამოიყენოთ ისინი?

Question

Accepted Answer

**ჯენერიკი** საშუალებას გაძლევთ დაწეროთ კლასები, ინტერფეისები და მეთოდები, რომლებიც მუშაობენ **ტიპის პარამეტრთან**, რომელსაც მითითებენ გამოძახებული კოდი — უზრუნველყოფენ **კომპილაციის დროის ტიპის უსაფრთხოებას** და აღმოფხვრებენ cast-ებს. ისინი ქმნის Collections Framework-ს და მხელთავდელი ბიბლიოთეკების საფუძველს. ## პრობლემა, რომელსაც ჯენერიკი ხსნის ```java // ❌ before generics (or with raw types) — no type safety, requires casts List list = new ArrayList(); list.add("hello"); list.add(42); // oops — anything can go in String s = (String) list.get(1); // ClassCastException at RUNTIME! 💥 // ✅ with generics — the type is enforced at COMPILE time List list = new ArrayList<>(); list.add("hello"); list.add(42); // ❌ compile error — caught immediately String s = list.get(0); // no cast needed — known to be String ``` ჯენერიკი ტიპის შეცდომებს გადაიტანს runtime-დან (`ClassCastException`) **compile time**-ში, და ამოიკლებს ხელით cast-ების საჭიროებას — კოდი უფრო უსაფრთხო და გასუფთავებული ხდება. ## ჯენერიკული კლასები და მეთოდები ```java // a generic class — T is a type parameter filled in by the user public class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } Box b = new Box<>(); // T = String b.set("hi"); String x = b.get(); // typed, no cast // a generic method public static T firstElement(List list) { return list.get(0); } ``` ## შეზღუდული ტიპის პარამეტრები ```java // T must be Number (or a subclass) — lets you call Number methods public static double sum(List list) { double total = 0; for (T n : list) total += n.doubleValue(); // safe — T is a Number return total; } ``` `` შემზღუდავს ტიპის პარამეტრს, რაც საშუალებას გაძლევთ უსაფრთხოდ გამოიყენოთ მაგ ტიპის წევრები. ## Wildcard-ები ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` Wildcard-ები დამატებითი მოქნილობა ემატება მეთოდის პარამეტრებს, რომლებიც უნდა მიიღონ ტიპების დიაპაზონი. ## ტიპის წაშლა (Java-ს შენიშვნა) ```java // generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility) List a = new ArrayList<>(); List b = new ArrayList<>(); a.getClass() == b.getClass(); // true — both are just ArrayList at runtime // consequence: can't do `new T()` or `instanceof List` ``` Java განახორციელებს ჯენერიკებს **ტიპის წაშლის** საშუალებით — ტიპის პარამეტრები არსებობენ compile time-ში, მაგრამ runtime-ში შუაშია, რაც გარკვევილი შეზღუდვები აქვს. ## რატომ აქვს მნიშვნელობა ჯენერიკი აუცილებელია თანამედროვე Java-სთვის — უზრუნველყოფენ compile time-ის ტიპის უსაფრთხოებას (ტიპის შეცდომებს დაფიქსირებენ ადრე, runtime-ის `ClassCastException`-ის ნაცვლად), აღმოფხვრებენ ზედმეტი და შეცდომაში ხელმისაწვდომი cast-ებს, და ხელმისაწვდომი ხდის მხელთავდელ და ტიპის-მოქნილ კოდს. ისინი მთელი Collections Framework-ის (`List`, `Map`) და უთვალავი ბიბლიოთეკის საფუძველი. ჯენერიკული კლასების/მეთოდების, შეზღუდული პარამეტრების, wildcard-ების (PECS) და ტიპის წაშლის შენიშვნის გაგება საშუალებას გაძლევთ სწორად გამოიყენოთ ჯენერიკული API-ები და დაადგინოთ საკუთარი მხელთავდელი, ტიპის უსაფრთხო აბსტრაქციები — ძლიერი და მდგრადი Java-ს დაწერის ღირსეული უნარი.