जेनेरिक टाइप में

जेनेरिक टाइप के बारे में

जेनेरिक टाइप ऐसा जेनेरिक क्लास या इंटरफेस होता है जो टाइप को पैरामीटर की तरह लेता है। इससे कंपाइलर क्लास या इंटरफेस पर टाइप सेफ्टी लागू कर सकता है।

इस गैर-जेनेरिक Container इंटरफेस को देखिए:

class Container {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

चूँकि यह Object टाइप की वैल्यू लेता भी है और लौटाता भी है, इसलिए यह किसी भी गैर-प्रिमिटिव टाइप के साथ काम करता है। लेकिन इसकी एक कीमत चुकानी पड़ती है: कुछ कोड get को कॉल करते समय Integer की उम्मीद कर सकते हैं, जबकि कोई दूसरा कोड set को कॉल करके String जोड़ सकता है, और नतीजा यह होता है कि रनटाइम एक्सेप्शन आ जाता है।

जेनेरिक क्लास और जेनेरिक इंटरफेस का रूप ऐसा होता है:

class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }

क्लास या इंटरफेस के नाम के बाद आने वाला टाइप पैरामीटर वाला हिस्सा, जो एंगल ब्रैकेट (<>) के बीच लिखा जाता है, टाइप पैरामीटर तय करता है, यानी T1, T2, ..., और Tn। इन्हें टाइप वेरिएबल भी कहा जाता है। इनका इस्तेमाल क्लास या इंटरफेस के अंदर करके जेनेरिक टाइप सेफ्टी पाई जा सकती है।

यह रहा Container का जेनेरिक रूप:

class Container<E> {
    private E object;

    public void set(E object) { this.object = object; }
    public E get() { return object; }
}

अब इसे बनाते समय हमें घोषित करना होता है कि यह किस टाइप की वैल्यू रखेगा, और कंपाइलर उसी प्रतिबंध को लागू करता है:

// empty <> can infer from context
Container<String> stringContainer = new Container<>();
// compiler knows this is a String, so it is allowed
stringContainer.set("Some string");
// no cast needed, compiler knows it is a String
String result = stringContainer.get();
// this causes a compiler error:
stringContainer.set(42);