Generics ਤੁਹਾਨੂੰ ਕਿਸਮ ਦੁਆਰਾ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਕਲਾਸਾਂ ਅਤੇ ਵਿਧੀਆਂ ਲਿਖਣ ਦਿੰਦੇ ਹਨ, ਤਾਂ ਜੋ ਇੱਕੋ ਹੀ ਕੋਡ ਬਹੁਤ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦਕਿ compile-time ਕਿਸਮ ਦੀ ਸੁਰੱਖਿਆ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ। ਇਹ parametric polymorphism ਹੈ — "ਇੱਕ ਆਕਾਰ, ਕੋਈ ਵੀ ਕਿਸਮ।"
();
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++ templates ਅਤੇ C# generics ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਵਿਵਹਾਰ ਕਰਦੇ ਹਨ (monomorphization / reified types)।
Generics ਇਸੇ ਸਮੇਂ ਮੁੜ ਵਰਤੋ ਅਤੇ ਸੁਰੱਖਿਆ ਦੋਵੇ ਦਿੰਦੇ ਹਨ: ਇੱਕ List<T> ਹਰ ਤੱਤ ਕਿਸਮ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ, ਕੰਪਾਇਲਰ ਕਿਸਮ ਦੀਆਂ ਗ਼ਲਤੀਆਂ ਫੜਦਾ ਹੈ ਜੋ ਵਰਨਾ runtime ਕ੍ਰੈਸ਼ ਹੋਤੇ।
ਉਹ ਅਸੁਰੱਖਿਅਤ casts ਨੂੰ ਖਤਮ ਕਰਦੇ ਹਨ ਅਤੇ collections ਦੀ ਰੀਢ ਦੀ ਹੱਡ੍ਡੀ ਹਨ, ਕੋਡ ਨੂੰ ਦੋਵੇਂ ਵੱਧ ਪੁਨਃ ਵਰਤੋ ਯੋਗ ਅਤੇ ਗਲਤ ਵਰਤੋ ਕਰਨਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੇ ਹਨ।