Gjenerikët ju lejojnë të shkruani klasa, ndërfaqe dhe metoda që punojnë me një parametër tipi të specifikuar nga thirësi — duke ofruar siguri të tipit në kohën e kompilimit dhe duke eliminuar nevojën për casting. Ata fuqizojnë Collections Framework dhe biblioteka të ripërdorshme.
();
list.add();
list.add();
(String) list.get();
List<String> list = <>();
list.add();
list.add();
list.get();
Gjenerikët lëvizin gabimet e tipit nga koha e ekzekutimit (ClassCastException) në kohën e kompilimit, dhe hequr nevojën për casting manual — duke e bërë kodin më të sigurt dhe më të pastër.
// a generic class — T is a type parameter filled in by the user
public class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
Box<String> b = new Box<>(); // T = String
b.set("hi");
String x = b.get(); // typed, no cast
// a generic method
public static <T> T firstElement(List<T> list) {
return list.get(0);
}
// T must be Number (or a subclass) — lets you call Number methods
public static <T extends Number> double sum(List<T> list) {
double total = 0;
for (T n : list) total += n.doubleValue(); // safe — T is a Number
return total;
}
<T extends X> kufizon parametrin e tipit, duke ju lejuar të përdorni anëtarët e atij tipi me siguri.
List<? extends Number> nums; // "some subtype of Number" — read (producer)
List<? super Integer> sink; // "Integer or a supertype" — write (consumer)
// PECS: Producer Extends, Consumer Super
Zëvendësuesit shtojnë fleksibilitet për parametrat e metodës që duhet të pranojnë grupe tipi.
// generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility)
List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
a.getClass() == b.getClass(); // true — both are just ArrayList at runtime
// consequence: can't do `new T()` or `instanceof List<String>`
Java zbaton gjenerikët përmes fshirjes së tipit — parametrat e tipit ekzistojnë në kohën e kompilimit por hiqen në kohën e ekzekutimit, i cili ka disa kufizime.
Gjenerikët janë thelbësorë për Java modernë — ata ofrojnë siguri të tipit në kohën e kompilimit (kapja e gabimeve të tipit herët në vend të ClassCastException në kohën e ekzekutimit), eliminojnë casting të lodhur dhe të prirur për gabime, dhe mundësojnë kod të ripërdorshëm, të fleksibil në lidhje me tipin.
Ata janë themeli i të gjithë Collections Framework (List<String>, Map<K,V>) dhe bibliotekave të panumërta.
Zotërimi i klasave/metodave gjenerike, parametrave të kufizuar, zëvendësuesve (PECS), dhe paralajmërimit të fshirjes së tipit ju lejon të përdorni saktë API-t gjenerike dhe të hartoni abstraksionet tuaja të ripërdorshme, të sigurta për tipin — një aftësi thelbësore për të shkruar Java të fortë dhe të mirëmbajtshme.