जावा में पैरामीटरेटेड प्रकार: जेनरिक

1. सभी वर्ग इनहेरिट करते हैंObject

जावा में सभी वर्ग निहित रूप से Objectवर्ग को इनहेरिट करते हैं।

हम विश्लेषण करेंगे कि विरासत क्या है और यह जावा कोर खोज में जावा में कैसे काम करती है। अभी के लिए, हम एक साधारण तथ्य पर विचार करेंगे जो इससे निकलता है:

किसी भी वर्ग की वस्तु को एक Objectचर को सौंपा जा सकता है। उदाहरण:

Object o = new Scanner(System.in);

Object o = new String();

Object o = new Integer(15);

Object o = "Hello";

यहीं से खुशखबरी खत्म होती है। कंपाइलर एक चर में सहेजे गए मूल प्रकार के ऑब्जेक्ट का ट्रैक नहीं रखता है Object, इसलिए आप क्लास के तरीकों के अलावा सहेजे गए ऑब्जेक्ट पर तरीकों को कॉल करने में सक्षम नहीं होंगे। Object

यदि आपको ऑब्जेक्ट के मूल प्रकार से जुड़े तरीकों को कॉल करने की आवश्यकता है, तो आपको पहले इसके संदर्भ को सही प्रकार के चर में सहेजना होगा, और फिर उस चर पर विधियों को कॉल करना होगा:

Object o = new Scanner(System.in);
int x = o.nextInt();

Object o = new Scanner(System.in);

Scanner console = (Scanner) o;

int x = console.nextInt();

आप केवल एक स्कैनर चर के लिए एक चर नहीं जा सकते हैं और असाइन नहीं कर सकते हैं Object, भले ही चर किसी ऑब्जेक्ट को Objectसंदर्भित करता हो । Scannerलेकिन आप ऐसा कर सकते हैं यदि आप टाइपकास्ट ऑपरेटर का उपयोग करते हैं , जिसके बारे में आप पहले से ही जानते हैं। यह इसकी सामान्य उपस्थिति है:

Type name1 = (Type) name2;

कहाँ name1एक चर का नाम है Type, और एक चर name2का नाम है जो किसी वस्तु के संदर्भ को संग्रहीत करता है।ObjectType

टाइपकास्टिंग

यदि चर का प्रकार और वस्तु का प्रकार मेल नहीं खाता है, तो a ClassCastExceptionफेंका जाएगा। उदाहरण:

Object o = new Integer(5);
String s = (String) o;

जावा में इस त्रुटि से बचने का एक तरीका है: हम एक चर में संग्रहीत वस्तु के प्रकार की जाँच करके ऐसा करते हैं :

name instanceof Type

ऑपरेटर instanceofजाँचता है कि क्या nameचर एक Typeवस्तु है।

एक उदाहरण के रूप में, आइए विविध वस्तुओं की एक सरणी में एक स्ट्रिंग खोजें:

Object[] objects = {10, "Hello", 3.14};

for (int i = 0; i < objects.length; i++)
{
   if (objects[i] instanceof String)
   {
      String s = (String) objects[i];
      System.out.println(s);
   }
}

2. जेनरिक क्यों दिखाई दिए - संग्रह

चलिए संग्रह पर लौटते हैं।

जैसे ही जावा डेवलपर्स ने ArrayListकक्षा बनाई, वे इसे सार्वभौमिक बनाना चाहते थे, ताकि यह किसी भी प्रकार की वस्तु को स्टोर कर सके। इसलिए उन्होंने Objectतत्वों को संग्रहित करने के लिए s की एक सरणी का उपयोग किया।

इस दृष्टिकोण की ताकत यह है कि आप किसी भी प्रकार की वस्तु को संग्रह में जोड़ सकते हैं।

बेशक, कई कमजोरियां हैं।

नुकसान 1.

संग्रह से तत्वों को पुनर्प्राप्त करते समय एक प्रकार का रूपांतरण ऑपरेटर लिखना हमेशा आवश्यक था:

ArrayList numbers = new ArrayList();


for (int i = 0; i < 10; i++)
   numbers.add(i * 10);


int sum = 0;
for (int i = 0; i < 10; i++)
{
   sum = sum + (Integer) numbers.get(i);
}

हानि 2.

इस बात की कोई गारंटी नहीं थी कि संग्रह में एक विशिष्ट प्रकार का तत्व है

ArrayList numbers = new ArrayList();


for (int i = 0; i < 10; i++)
   numbers.add(i * 2.5);


int sum = 0;
for (int i = 0; i < 10; i++)
{
   sum = sum + (Integer) numbers.get(i);
}

डेटा को संग्रह में कहीं भी रखा जा सकता है:

• दूसरे तरीके से
• दूसरे कार्यक्रम में
• एक फ़ाइल से
• नेटवर्क पर

हानि 3.

संग्रह में डेटा गलती से बदला जा सकता है।

आप अपने डेटा से भरे संग्रह को किसी विधि से पास कर सकते हैं। वह विधि, जो एक अलग प्रोग्रामर द्वारा लिखी गई है, अपने डेटा को आपके संग्रह में जोड़ती है।

संग्रह का नाम स्पष्ट रूप से इंगित नहीं करता है कि इसमें किस प्रकार का डेटा संग्रहीत किया जा सकता है। और भले ही आप अपने चर को एक स्पष्ट नाम दें, इसके संदर्भ में एक दर्जन विधियों को पारित किया जा सकता है, और उन विधियों को निश्चित रूप से चर के मूल नाम के बारे में कुछ भी पता नहीं चलेगा।

3. जेनरिक

जावा में, जेनरिक नामक इस अच्छी चीज से इन सभी समस्याओं को समाप्त कर दिया जाता है।

जावा में, जेनरिक का अर्थ है टाइप पैरामीटर को टाइप करने की क्षमता। नतीजा एक जटिल समग्र प्रकार है। इस तरह के मिश्रित प्रकार का सामान्य दृश्य यह है:

ClassName<TypeParameter>

यह एक सामान्य वर्ग है। और इसका उपयोग जहाँ भी आप आमतौर पर कक्षाओं का उपयोग करते हैं, किया जा सकता है।

ArrayList<Integer> list;

list = new ArrayList<Integer> ();

ArrayList<Integer>[] array;

Integerऐसे संग्रह में केवल चर ही संग्रहीत किए जा सकते हैं:

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(1));
list.add(2);
list.add("Hello");

आप सीखेंगे कि जावा कलेक्शंस खोज में टाइप पैरामीटर के साथ अपनी खुद की कक्षाएं कैसे बनाएं। अभी के लिए, हम देखेंगे कि उनका उपयोग कैसे करना है और वे कैसे काम करते हैं।

4. जेनरिक कैसे काम करते हैं

वास्तव में, जेनरिक बहुत आदिम हैं।

कंपाइलर केवल सामान्य प्रकारों को सामान्य प्रकारों से बदल देता है। लेकिन जब एक सामान्य प्रकार के तरीकों का उपयोग किया जाता है, तो कंपाइलर टाइप पैरामीटर में पैरामीटर डालने के लिए टाइपकास्ट ऑपरेटर जोड़ता है:

ArrayList<Integer> list = new ArrayList<Integer>();

ArrayList list = new ArrayList();

list.add(1);

list.add( (Integer) 1 );

int x = list.get(0);

int x = (Integer) list.get(0);

list.set(0, 10);

list.set(0, (Integer) 10);

मान लीजिए कि हमारे पास एक ऐसी विधि है जो पूर्णांकों के संग्रह में संख्याओं का योग करती है:

public int sum(ArrayList<Integer> numbers)
{
   int result = 0;

   for (int i = 0; i < numbers.size(); i++)
      result = result + numbers.get(i);

   return result;
}

public int sum(ArrayList numbers)
{
   int result = 0;

   for (int i = 0; i < numbers.size(); i++)
      result = result + (Integer) numbers.get(i);

   return result;
}

दूसरे शब्दों में, जेनरिक एक प्रकार की सिंटैक्टिक चीनी है, जैसे ऑटोबॉक्सिंग, लेकिन थोड़ा और। ऑटोबॉक्सिंग के साथ, कंपाइलर a को inta Integerऔर इसके विपरीत में परिवर्तित करने के तरीके जोड़ता है, और जेनरिक के लिए यह टाइपकास्ट ऑपरेटर जोड़ता है।

कंपाइलर आपके सामान्य वर्गों को टाइप पैरामीटर के साथ संकलित करने के बाद, वे साधारण कक्षाओं और टाइपकास्ट ऑपरेटरों में परिवर्तित हो जाते हैं। सामान्य प्रकार के वेरिएबल्स को पास किए गए प्रकार के तर्कों के बारे में जानकारी खो गई है। इस प्रभाव को टाइप इरेज़र भी कहा जाता है ।

कभी-कभी सामान्य वर्ग (टाइप पैरामीटर वाले वर्ग) लिखने वाले प्रोग्रामर को वास्तव में तर्कों के रूप में पारित प्रकारों के बारे में जानकारी की आवश्यकता होती है। जावा कलेक्शंस खोज में, आप सीखेंगे कि इससे कैसे निपटा जाए और इसमें क्या शामिल है।

5. जेनरिक के बारे में कुछ तथ्य

यहां जेनरिक के बारे में कुछ और रोचक तथ्य दिए गए हैं।

कक्षाओं में कई प्रकार के पैरामीटर हो सकते हैं। ऐसा कुछ दिखता है:

ClassName<TypeParameter1, TypeParameter2, TypeParameter3>

वास्तव में, यह वास्तव में आश्चर्यजनक नहीं है। कहीं भी संकलक एक ऑपरेटर को एक प्रकार में डालने के लिए जोड़ सकता है, यह कई टाइपकास्ट ऑपरेटरों को जोड़ सकता है।

उदाहरण:

HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(7, "Hello");
map.put(-15, "Hello");

सामान्य प्रकार का उपयोग पैरामीटर के रूप में भी किया जा सकता है । ऐसा कुछ दिखता है:

ClassName<TypeParameter<TypeParameterParameter>>

मान लीजिए हम एक सूची बनाना चाहते हैं जो स्ट्रिंग्स की सूचियों को संग्रहीत करेगी। इस मामले में, हमें ऐसा कुछ मिलेगा:

// List of greetings
ArrayList<String> listHello = new ArrayList<String>();
listHello.add ("Hello");
listHello.add ("Hi");

// List of goodbyes
ArrayList<String> listBye = new ArrayList<String>();
listBye.add("Bye");
listBye.add ("Goodbye");

// List of lists
ArrayList<ArrayList<String>> lists = new ArrayList<ArrayList<String>>();
lists.add(listHello);
lists.add(listBye);

सामान्य प्रकार (प्रकार पैरामीटर वाले प्रकार) का उपयोग सरणी प्रकार के रूप में भी किया जा सकता है। ऐसा कुछ दिखता है:

ClassName<TypeParameter>[] array = new ClassName<TypeParameter>[size];

यहां कुछ भी जादुई नहीं हो रहा है: कोण ब्रैकेट केवल प्रकार का नाम इंगित करते हैं:

ArrayList<String>[] list = new ArrayList<String>[10];

StringArrayList[] list = new StringArrayList[10];

ArrayList<Integer>[] list = new ArrayList<Integer>[10];

IntegerArrayList[] list = new IntegerArrayList[10];

ArrayList<Scanner>[] list = new ArrayList<Scanner>[10];

ScannerArrayList[] list = new ScannerArrayList[10];