S10L05 – पैरामीटर का प्रकार

html

Java में Generics पर महारत: शुरुआती और डेवलपर्स के लिए एक व्यापक गाइड
सामग्री की सूची

परिचय..................................................................................................................1
Java में Generics को समझना..................................................................3
सामान्य Generic नोटेशन्स...................................................................................5
Generic डेटा क्लासेज बनाना..........................................................................7
Generics के साथ की-वैल्यू पेयर्स का उपयोग........................................................9
कंस्ट्रक्टर्स और गेटर्स को लागू करना................................................11
toString मेथड को ओवरराइड करना.......................................................................13
Generic क्लासेज को इनिशियलाइज़ करना और उपयोग करना................................................15
Generic मेथड्स की खोज................................................................................17
Generics के उपयोग के लिए सर्वोत्तम अभ्यास................................................................19
निष्कर्ष................................................................................................................21


परिचय
Generics Java में एक शक्तिशाली विशेषता हैं जो डेवलपर्स को type parameters के साथ classes, interfaces, और methods बनाने में सक्षम बनाती हैं। यह क्षमता न केवल code पुन: उपयोगिता को बढ़ावा देती है बल्कि type सुरक्षा सुनिश्चित करती है, जिससे runtime त्रुटियाँ कम होती हैं। इस eBook में, हम generics की दुनिया में गहराई से प्रवेश करते हैं, उनकी सिंटैक्स, सामान्य नोटेशन्स, और व्यावहारिक उपयोगों का अन्वेषण करते हैं। चाहे आप एक शुरुआती हों या बुनियादी ज्ञान वाले डेवलपर, यह गाइड आपको Java generics की पूरी क्षमता को harness करने के लिए आवश्यक उपकरणों से लैस करेगा।

Java में Generics को समझना
Generics को Java 5 में types को parameterize करने के लिए पेश किया गया था। विभिन्न प्रकार के ऑब्जेक्ट्स पर operate करने के लिए classes और methods को अनुमति देकर जबकि compile-time type safety प्रदान करती है, generics typecasting की आवश्यकता को समाप्त कर देती हैं और code की स्पष्टता में सुधार करती हैं।
Generics का उपयोग क्यों करें?

Type Safety: runtime की बजाय compile time पर type संबंधित त्रुटियों को पकड़ें।
Reusability: एक generic class या method को एक बार लिखें और विभिन्न प्रकारों के साथ उपयोग करें।
Elimination of Casts: स्पष्ट typecasting की आवश्यकता को कम करें, जिससे code साफ-सुथरा और कम त्रुटिपूर्ण बनता है।

उदाहरण
एक सरल container class पर विचार करें जो एकल ऑब्जेक्ट को रखती है। generics के बिना, आपको Object का उपयोग करना होगा और typecasting करना होगा:




		
		
			
			
Java
			
			class Container {
    private Object obj;

    public Container(Object obj) {
        this.obj = obj;
    }

    public Object getObj() {
        return obj;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						class Container {
    private Object obj;
 
    public Container(Object obj) {
        this.obj = obj;
    }
 
    public Object getObj() {
        return obj;
    }
}
					
				
			
		


generics के साथ, Container class को किसी भी specific type को रखने के लिए parameterize किया जा सकता है:




		
		
			
			
Java
			
			class Container&lt;T&gt; {
    private T obj;

    public Container(T obj) {
        this.obj = obj;
    }

    public T getObj() {
        return obj;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						class Container&lt;T&gt; {
    private T obj;
 
    public Container(T obj) {
        this.obj = obj;
    }
 
    public T getObj() {
        return obj;
    }
}
					
				
			
		



सामान्य Generic नोटेशन्स
Java generics प्रकारों के लिए प्लेसहोल्डर्स के रूप में विशिष्ट एकल-लैटर नोटेशन्स का उपयोग करती हैं। इन नोटेशन्स को समझना साफ-सुथरा और पारंपरिक generic code लिखने के लिए महत्वपूर्ण है।


Notation
Stands For
Usage Scenario


T
Type
एक generic type का प्रतिनिधित्व करता है


E
Element
Java Collections API द्वारा व्यापक रूप से उपयोग किया जाता है


K
Key
की-वैल्यू पेयर्स में keys का प्रतिनिधित्व करता है


V
Value
की-वैल्यू पेयर्स में values का प्रतिनिधित्व करता है


N
Number
संख्यात्मक मानों का प्रतिनिधित्व करता है


विस्तृत व्याख्या

T (Type): सबसे आम उपयोग किया जाने वाला generic type parameter। किसी भी प्रकार का प्रतिनिधित्व करता है।





		
		
			
			
Java
			
			class Box&lt;T&gt; { 
    private T t; 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
			
				
					
				
					1
2
3
4
5
				
						class Box&lt;T&gt; { 
    private T t; 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
					
				
			
		



E (Element): आमतौर पर संग्रह classes द्वारा संग्रह में संग्रहीत तत्वों को दर्शाने के लिए उपयोग किया जाता है।





		
		
			
			
Java
			
			class MyList&lt;E&gt; { 
    // Implementation details
}
			
				
					
				
					1
2
3
				
						class MyList&lt;E&gt; { 
    // Implementation details
}
					
				
			
		



K, V (Key, Value): Maps या किसी भी की-वैल्यू पेयर संग्रहों में उपयोग किया जाता है।





		
		
			
			
Java
			
			class Pair&lt;K, V&gt; { 
    private K key; 
    private V value; 
    // Constructors, getters, setters
}
			
				
					
				
					1
2
3
4
5
				
						class Pair&lt;K, V&gt; { 
    private K key; 
    private V value; 
    // Constructors, getters, setters
}
					
				
			
		



N (Number): संख्यात्मक मानों का प्रतिनिधित्व करता है, उन methods में उपयोगी होते हैं जो संख्यात्मक operations करते हैं।





		
		
			
			
Java
			
			public &lt;N extends Number&gt; void process(N number) { 
    // Implementation
}
			
				
					
				
					1
2
3
				
						public &lt;N extends Number&gt; void process(N number) { 
    // Implementation
}
					
				
			
		



Generic डेटा क्लासेज बनाना
Generic डेटा क्लासेज बनाना आपको ऐसी संरचनाएँ परिभाषित करने की अनुमति देता है जो विभिन्न डेटा प्रकारों को लचीले ढंग से संभाल सकती हैं। नीचे, हम key-value पेयर्स का उपयोग करके एक generic Data class बनाने के चरणों के माध्यम से चलते हैं।
कदम-दर-कदम गाइड
1. Type Parameters के साथ Class को परिभाषित करना




		
		
			
			
Java
			
			public class Data&lt;K, V&gt; {
    private K key;
    private V value;

    public Data(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class Data&lt;K, V&gt; {
    private K key;
    private V value;
 
    public Data(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() {
        return key;
    }
 
    public V getValue() {
        return value;
    }
 
    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
					
				
			
		


व्याख्या:

K और V type parameters हैं जो क्रमशः key और value के प्रकार का प्रतिनिधित्व करते हैं।
constructor key और value को initialize करता है।
getters fields तक पहुंच प्रदान करते हैं।
toString method को ओवरराइड किया गया है ताकि meaningful string representation प्रदान किया जा सके।

2. Generic डेटा क्लास का उपयोग करना




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data);
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data);
    }
}
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		


व्याख्या:

Data का एक instance बनाया जाता है जिसमें Integer key प्रकार के लिए और String value प्रकार के लिए होता है।
toString method एक पठनीय output प्रदान करता है।


Generics के साथ की-वैल्यू पेयर्स का उपयोग
की-वैल्यू पेयर्स कई डेटा स्ट्रक्चर्स में मौलिक हैं, जैसे कि maps। Generics उनकी लचीलापन और type सुरक्षा को बढ़ाते हैं।
एक Key-Value Pair Class बनाना




		
		
			
			
Java
			
			public class KeyValuePair&lt;K, V&gt; {
    private K key;
    private V value;

    public KeyValuePair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { 
        return key; 
    }

    public V getValue() { 
        return value; 
    }

    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class KeyValuePair&lt;K, V&gt; {
    private K key;
    private V value;
 
    public KeyValuePair(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() { 
        return key; 
    }
 
    public V getValue() { 
        return value; 
    }
 
    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
					
				
			
		


KeyValuePair Class का उपयोग करना




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        KeyValuePair&lt;Integer, String&gt; pair = new KeyValuePair<>(10, "Chand");
        System.out.println(pair);
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        KeyValuePair&lt;Integer, String&gt; pair = new KeyValuePair<>(10, "Chand");
        System.out.println(pair);
    }
}
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		


व्याख्या:

KeyValuePair class को specific types के साथ instantiate किया जाता है, यह सुनिश्चित करते हुए कि key एक Integer है और value एक String है।
यह दृष्टिकोण type mismatches को रोकता है और code की पठनीयता को बढ़ाता है।


कंस्ट्रक्टर्स और गेटर्स को लागू करना
कंस्ट्रक्टर्स और गेटर्स किसी भी class के आवश्यक घटक हैं, विशेष रूप से generic ones। वे सुनिश्चित करते हैं कि objects सही ढंग से initialized हों और उनके डेटा तक पहुंच योग्य हों।
कंस्ट्रक्टर्स उत्पन्न करना
Data class उदाहरण में, constructor key और value को initialize करता है:




		
		
			
			
Java
			
			public Data(K key, V value) {
    this.key = key;
    this.value = value;
}
			
				
					
				
					1
2
3
4
				
						public Data(K key, V value) {
    this.key = key;
    this.value = value;
}
					
				
			
		


व्याख्या:

constructor K और V प्रकार के parameters स्वीकार करता है और उन्हें class के fields में असाइन करता है।

गेटर्स बनाना
गेटर्स class के fields तक पढ़ने योग्य पहुंच प्रदान करते हैं:




		
		
			
			
Java
			
			public K getKey() { 
    return key; 
}

public V getValue() { 
    return value; 
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public K getKey() { 
    return key; 
}
 
public V getValue() { 
    return value; 
}
					
				
			
		


व्याख्या:

getKey() type K की key लौटाता है।
getValue() type V की value लौटाता है।


toString मेथड को ओवरराइड करना
toString मेथड को ओवरराइड किया जाता है ताकि object का एक अर्थपूर्ण string representation प्रदान किया जा सके, जो विशेष रूप से debugging और logging के लिए उपयोगी होता है।
Data Class में Implementation




		
		
			
			
Java
			
			@Override
public String toString() {
    return "Key: " + key + ", Value: " + value;
}
			
				
					
				
					1
2
3
4
				
						@Override
public String toString() {
    return "Key: " + key + ", Value: " + value;
}
					
				
			
		


व्याख्या:

यह method key और value को पठनीय प्रारूप में concatenates करता है।

toString मेथड का उपयोग करना




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data.toString());
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data.toString());
    }
}
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		



Generic क्लासेज को इनिशियलाइज़ करना और उपयोग करना
Generic क्लासेज को सही ढंग से इनिशियलाइज़ करने में type parameters को स्पष्ट रूप से निर्दिष्ट करना शामिल होता है या type inference के माध्यम से।
स्पष्ट Type स्पेसिफिकेशन




		
		
			
			
Java
			
			Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
			
				
					
				
					1
				
						Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
					
				
			
		


व्याख्या:

Integer key के लिए निर्दिष्ट है, और String value के लिए।
type सुरक्षा सुनिश्चित करता है key और value के प्रकारों को सीमित करके।

डायमंड ऑपरेटर के साथ Type Inference
Java 7 में पेश किया गया, डायमंड ऑपरेटर (<>) कंपाइलर को type parameters infer करने की अनुमति देता है:




		
		
			
			
Java
			
			Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
			
				
					
				
					1
				
						Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
					
				
			
		


व्याख्या:

कंपाइलर infer करता है कि 10 type Integer का है और "Chand" type String का है, जिससे दाएं हाथ की तरफ type parameters को दोहराने की आवश्यकता समाप्त हो जाती है।


Generic मेथड्स की खोज
Generic मेथड्स वे मेथड्स हैं जो अपने स्वयं के type parameters पेश करते हैं, जिससे अधिक लचीला और पुन: प्रयोज्य code संभव होता है।
एक Generic मेथड परिभाषित करना




		
		
			
			
Java
			
			public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
			
				
					
				
					1
2
3
				
						public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
					
				
			
		


व्याख्या:

<E, N> दो type parameters घोषित करते हैं: E और N.
method display किसी भी प्रकार के parameters स्वीकार कर सकता है element और number के लिए।

Generic मेथड का उपयोग करना




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.display("Test", 40);
    }

    public &lt;E, N&gt; void display(E element, N number) {
        System.out.println("Element: " + element + ", Number: " + number);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.display("Test", 40);
    }
 
    public &lt;E, N&gt; void display(E element, N number) {
        System.out.println("Element: " + element + ", Number: " + number);
    }
}
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Element: Test, Number: 40
			
				
					
				
					1
				
						Element: Test, Number: 40
					
				
			
		


व्याख्या:

display method को String और Integer के साथ call किया जाता है, जो इसकी लचीलापन को प्रदर्शित करता है।

Generic मेथड में Comments जोड़ना




		
		
			
			
Java
			
			/**
 * Displays the element and number.
 *
 * @param element The element of any type.
 * @param number  The number of any type.
 */
public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						/**
 * Displays the element and number.
 *
 * @param element The element of any type.
 * @param number  The number of any type.
 */
public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
					
				
			
		


व्याख्या:

Javadoc comments code की पठनीयता बढ़ाते हैं और method के उद्देश्य और parameters के लिए documentation प्रदान करते हैं।


Generics के उपयोग के लिए सर्वोत्तम अभ्यास
Java में generics का प्रभावी ढंग से उपयोग करने के लिए, निम्नलिखित सर्वोत्तम अभ्यासों का पालन करें:
1. अर्थपूर्ण Type Parameter नामों का उपयोग करें
जबकि T और E जैसे एकल-लैटर नोटेशन्स सामान्य हैं, अधिक वर्णनात्मक नाम का उपयोग code की पठनीयता को बढ़ा सकता है।




		
		
			
			
Java
			
			// Less Descriptive
class Box&lt;T&gt; { /* ... */ }

// More Descriptive
class Box&lt;ItemType&gt; { /* ... */ }
			
				
					
				
					1
2
3
4
5
				
						// Less Descriptive
class Box&lt;T&gt; { /* ... */ }
 
// More Descriptive
class Box&lt;ItemType&gt; { /* ... */ }
					
				
			
		


2. Wildcard उपयोग सीमित करें
Wildcards (?) का अत्यधिक उपयोग code को समझना मुश्किल बना सकता है। उन्हें विवेकपूर्ण ढंग से उपयोग करें और आवश्यकतानुसार bounded type parameters को प्राथमिकता दें।




		
		
			
			
Java
			
			public void processList(List&lt;? extends Number&gt; numbers) {
    // Implementation
}
			
				
					
				
					1
2
3
				
						public void processList(List&lt;? extends Number&gt; numbers) {
    // Implementation
}
					
				
			
		


3. Inheritance के बजाय Composition को प्राथमिकता दें
Generic क्लासेज डिजाइन करते समय, फ्लेक्सिबिलिटी बनाए रखने और coupling को कम करने के लिए inheritance के बजाय composition को प्राथमिकता दें।
4. Primitive Type Parameters से बचें
Generics reference types के साथ काम करते हैं। primitives के साथ काम करते समय wrapper classes (Integer की बजाय int) का उपयोग करें।




		
		
			
			
Java
			
			// Correct
Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");

// Incorrect
Data&lt;int, String&gt; data = new Data<>(10, "Chand"); // Compilation Error
			
				
					
				
					1
2
3
4
5
				
						// Correct
Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
 
// Incorrect
Data&lt;int, String&gt; data = new Data<>(10, "Chand"); // Compilation Error
					
				
			
		


5. Generic Types को Consistent रखें
यह सुनिश्चित करें कि type parameters methods और classes में consistent रूप से उपयोग किए जाते हैं ताकि type सुरक्षा बनी रहे।




		
		
			
			
Java
			
			public class Pair&lt;K, V&gt; {
    // Consistent usage of K and V
}
			
				
					
				
					1
2
3
				
						public class Pair&lt;K, V&gt; {
    // Consistent usage of K and V
}
					
				
			
		


6. Generic Classes और Methods को Document करें
Generic classes और methods के लिए स्पष्ट documentation प्रदान करें ताकि type parameters के उद्देश्य को समझाया जा सके।

निष्कर्ष
Generics Java प्रोग्रामिंग में एक अपरिहार्य उपकरण हैं, जो enhanced type सुरक्षा, पुन: उपयोगिता, और स्वच्छ code प्रदान करते हैं। Generics को समझकर और उन्हें प्रभावी ढंग से लागू करके, डेवलपर्स लचीले और मजबूत applications बना सकते हैं। इस गाइड ने generics के बुनियादी पहलुओं को कवर किया है, जिसमें सामान्य नोटेशन्स, generic क्लासेज, methods, और सर्वोत्तम अभ्यास शामिल हैं। जैसे-जैसे आप Java में गहराई से प्रवेश करते हैं, generics का उपयोग करने से निश्चित रूप से efficient और maintainable code लिखने में योगदान मिलेगा।
नोट: यह लेख AI द्वारा जनरेट किया गया है।
Notation	Stands For	Usage Scenario
T	Type	एक generic type का प्रतिनिधित्व करता है
E	Element	Java Collections API द्वारा व्यापक रूप से उपयोग किया जाता है
K	Key	की-वैल्यू पेयर्स में keys का प्रतिनिधित्व करता है
V	Value	की-वैल्यू पेयर्स में values का प्रतिनिधित्व करता है
N	Number	संख्यात्मक मानों का प्रतिनिधित्व करता है