జెనరిక్లు రకంద్వారా పారామితిమతమైన వర్గాలు మరియు పద్ధతులను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తాయి, తద్వారా ఒకే కోడ్ అনేక రకాలతో పనిచేస్తుంది సంకలన-సమయ రకం భద్రత ఉంచుతూ. ఇది parametric బహురూపతం — "ఒక ఆకృతి, ఏదైనా రకం."
();
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 రన్టైమ్లో జెనరిక్ రకాలను తొలగిస్తుంది (type erasure) — మీరు new T() లేదా instanceof List<String> చేయలేరు. C++ టెంప్లేట్లు మరియు C# జెనరిక్లు విభిన్నంగా ప్రవర్తిస్తాయి (monomorphization / reified types).
జెనరిక్లు మళ్లీ ఉపయోగం మరియు భద్రతను ఒకేసారి ఇస్తాయి: ఒక List<T> ప్రతి మూలకం రకానికి పనిచేస్తుంది, కంపైలర్ రకం ఎర్రర్లను పట్టుకుంటుంది, ఇవి లేకపోతే రన్టైమ్ క్రాష్లుగా ఉండేవి.
వారు సురక్షితం కాని కాస్ట్లను తొలగిస్తారు మరియు సేకరణల యొక్క వెన్నెముక, కోడ్ను మరింత పునర్వినియోగం చేయదగినది మరియు దుర్వినియోగం చేయడం కష్టమైనది.