ჯენერიკები საშუალებას გვაძლევს დავწეროთ კლასები და მეთოდები, რომლებიც პარამეტრიზებული არიან ტიპის მიხედვით, ასე რომ იგივე კოდი მუშაობს მრავალი ტიპთან, ხოლო კომპილაციის დროის ტიპის უსაფრთხოება შენარჩუნებული რჩება. ეს არის პარამეტრული პოლიმორფიზმი — "ერთი ფორმა, ნებისმიერი ტიპი".
();
list.add();
(String) list.get();
// With generics: type is known and checked at compile time
List<String> list = new ArrayList<>();
list.add("hi");
String s = list.get(0); // no cast; list.add(42) won't compile
class Box<T> { // T is a type parameter
private T value;
Box(T value) { this.value = value; }
T get() { return value; }
}
Box<Integer> b = new Box<>(42); // T = Integer, checked at compile time
int n = b.get(); // no cast needed
<T extends Comparable<T>> // bounded: T must be comparable
List<? extends Number> // covariance: accept List<Integer>, List<Double>
Java წაშლის ჯენერიკულ ტიპებს runtime-ში (type erasure) — თქვენ ვერ შეძლებთ new T() ან instanceof List<String>. C++ შაბლონები და C# ჯენერიკები სხვაგვარი იქცევიან (monomorphization / reified types).
ჯენერიკები აერთიანებენ გამოყენებას და უსაფრთხოებას ერთდროულად: ერთი List<T> ემსახურება ყველა ელემენტის ტიპს, კომპილატორი ხელმძღვანელობს ტიპის შეცდომებით, რომლებიც სხვა შემთხვევაში runtime-ის შეცდომებული იქნებოდა.
ისინი აღმოფხვრიან არასაფრთხო cast-ებს და წარმოადგენენ კოლექციების საფუძველს, რაც კოდს უფრო ხელმისაწვდომს და უფრო რთულს ხდის გაუფრთხოებელ გამოყენებაში.