जावा चैलेंजर्स # 1: जेवीएम में विधि अधिभार

सभी को शुभ दिन।

हमने पाठ्यक्रम "जावा डेवलपर" की अगली स्ट्रीम पहले ही लॉन्च कर दी है, लेकिन हमारे पास अभी भी कुछ सामग्रियां हैं जिन्हें हम आपके साथ साझा करना चाहते हैं।

जावा चैलेंजर्स लेख श्रृंखला में आपका स्वागत है! लेखों की यह श्रृंखला जावा प्रोग्रामिंग सुविधाओं पर केंद्रित है। उनका विकास एक उच्च योग्य जावा प्रोग्रामर बनने का आपका तरीका है।

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

क्या आप जावा में प्रोग्रामिंग की मूल अवधारणाओं में महारत हासिल करने के लिए तैयार हैं? तो फिर शुरू करते हैं हमारी पहली पहेली!

शब्द "विधि अधिभार"

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

विधि अधिभार क्या है?

मेथड ओवरलोडिंग एक प्रोग्रामिंग तकनीक है जो एक ही वर्ग में एक डेवलपर को विभिन्न मापदंडों के साथ तरीकों के लिए एक ही नाम का उपयोग करने की अनुमति देता है। इस मामले में, हम कहते हैं कि विधि अतिभारित है।

लिस्टिंग 1 विभिन्न मापदंडों के साथ तरीकों को दिखाता है जो संख्या, प्रकार और क्रम में भिन्न होते हैं।

लिस्टिंग 1. ओवरलोडिंग के तरीकों के लिए तीन विकल्प।

//   public class Calculator { void calculate(int number1, int number2) { } void calculate(int number1, int number2, int number3) { } } //   public class Calculator { void calculate(int number1, int number2) { } void calculate(double number1, double number2) { } } //   public class Calculator { void calculate(double number1, int number2) { } void calculate(int number1, double number2) { } } 

विधि अधिभार और आदिम प्रकार

लिस्टिंग 1 में, आपने आदिम प्रकारों को int और double । आइए एक मिनट के लिए खुदाई करें और जावा में आदिम प्रकारों को याद करें।

तालिका 1. जावा में आदिम प्रकार

मुझे विधि अधिभार का उपयोग क्यों करना चाहिए?

ओवरलोडिंग का उपयोग आपके कोड को क्लीनर और पढ़ने में आसान बनाता है, और कार्यक्रम में त्रुटियों से बचने में भी मदद करता है।

लिस्टिंग 1 के विपरीत, एक प्रोग्राम की कल्पना करें जहां आपके पास कई calculate() तरीके हैं जिनके नाम calculate1 , calculate2 , calculate3 समान हैं ... ठीक नहीं? calculate() विधि को ओवरलोड करने से आप एक ही नाम का उपयोग कर सकते हैं और केवल वही बदल सकते हैं जो आवश्यक है - पैरामीटर। अतिभारित तरीकों को खोजना भी बहुत आसान है, क्योंकि वे कोड में समूहीकृत हैं।

ओवरलोड क्या नहीं है

याद रखें कि परिवर्तनशील नाम बदलना अधिभार नहीं है। निम्नलिखित कोड संकलित नहीं करता है:

 public class Calculator { void calculate(int firstNumber, int secondNumber){} void calculate(int secondNumber, int thirdNumber){} } 

आप विधि हस्ताक्षर में वापसी मान को बदलकर भी विधि को अधिभारित नहीं कर सकते। यह कोड भी संकलित नहीं करता है:

 public class Calculator { double calculate(int number1, int number2){return 0.0;} long calculate(int number1, int number2){return 0;} } 

कंस्ट्रक्टर ओवरलोड

आप विधायक को उसी तरीके से अधिभारित कर सकते हैं, जिस तरह से विधि:

 public class Calculator { private int number1; private int number2; public Calculator(int number1) { this.number1 = number1; } public Calculator(int number1, int number2) { this.number1 = number1; this.number2 = number2; } } 

ओवरलोडिंग के तरीके की समस्या का समाधान करें

क्या आप पहले टेस्ट के लिए तैयार हैं? चलिए पता लगाते हैं!

निम्नलिखित कोड की सावधानीपूर्वक जांच शुरू करें।

लिस्टिंग 2. विधि अधिभार की चुनौती

 public class AdvancedOverloadingChallenge3 { static String x = ""; public static void main(String... doYourBest) { executeAction(1); executeAction(1.0); executeAction(Double.valueOf("5")); executeAction(1L); System.out.println(x); } static void executeAction(int ... var) {x += "a"; } static void executeAction(Integer var) {x += "b"; } static void executeAction(Object var) {x += "c"; } static void executeAction(short var) {x += "d"; } static void executeAction(float var) {x += "e"; } static void executeAction(double var) {x += "f"; } } 

सब ठीक है। आपने कोड का अध्ययन किया है। निष्कर्ष क्या होगा?

1. befe
2. bfce
3. efce
4. aecf

लेख के अंत में सही उत्तर दिया गया है।

अब क्या हुआ? जेवीएम ओवरलोड तरीकों को कैसे संकलित करता है

लिस्टिंग 2 में क्या हुआ, यह समझने के लिए, आपको कुछ चीजों को जानने की आवश्यकता है कि जेवीएम ओवरलोड तरीकों को कैसे संकलित करता है।

सबसे पहले, जेवीएम तर्कसंगत रूप से आलसी है: यह हमेशा एक विधि को निष्पादित करने के लिए कम से कम प्रयास करेगा। इस प्रकार, जब आप सोचते हैं कि जेवीएम ओवरलोडिंग को कैसे संभालता है, तो संकलक की तीन महत्वपूर्ण विशेषताओं को ध्यान में रखें:

1. विस्तार (चौड़ा)
2. पैकेजिंग (ऑटोबॉक्सिंग और अनबॉक्सिंग)
3. परिवर्तनीय लंबाई तर्क (संस्करण)

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

यहाँ एक उदाहरण विस्तार दिया गया है:

 int primitiveIntNumber = 5; double primitiveDoubleNumber = primitiveIntNumber ; 

यह आदिम प्रकारों का विस्तार क्रम है:

( अनुवादक का ध्यान दें - जेएलएस में, आदिम का विस्तार बड़ी भिन्नताओं के साथ वर्णित है, उदाहरण के लिए, लंबे समय तक फ्लोट या डबल में विस्तार किया जा सकता है। )

ऑटो पैकेजिंग उदाहरण:

 int primitiveIntNumber = 7; Integer wrapperIntegerNumber = primitiveIntNumber; 

ध्यान दें कि कोड संकलित करते समय पर्दे के पीछे क्या होता है:

 Integer wrapperIntegerNumber = Integer.valueOf(primitiveIntNumber); 

यहाँ एक उदाहरण है:

 Integer wrapperIntegerNumber = 7; int primitiveIntNumber= wrapperIntegerNumber; 

इस कोड को संकलित करते समय पर्दे के पीछे क्या होता है:

 int primitiveIntNumber = wrapperIntegerNumber.intValue(); 

और यहां चर लंबाई के तर्कों के साथ एक विधि का एक उदाहरण है। ध्यान दें कि चर लंबाई विधियां हमेशा निष्पादित करने के लिए अंतिम होती हैं।

 execute(int... numbers){} 

चर लंबाई तर्क क्या हैं?

परिवर्तनीय लंबाई तर्क केवल तीन डॉट्स (...) द्वारा दिए गए मानों की एक सरणी है। हम इस विधि में कई int संख्याओं को पास कर सकते हैं।

उदाहरण के लिए:

 execute(1,3,4,6,7,8,8,6,4,6,88...); //  ... 

चर-लंबाई तर्क (varargs) बहुत सुविधाजनक है कि मानों को एक विधि से सीधे पारित किया जा सकता है। यदि हम सरणियों का उपयोग करते हैं, तो हमें मूल्यों के साथ एक सरणी उदाहरण बनाना होगा।

एक्सटेंशन: केस स्टडी

जब हम संख्या 1 को सीधे executeAction() विधि से पास करते हैं, तो JVM स्वतः इसे एक int रूप में व्याख्या करता है। यही कारण है कि इस संख्या को executeAction(short var) विधि से पारित नहीं किया जाएगा।

इसी तरह, अगर हम 1.0 नंबर पास करते हैं 1.0 JVM अपने आप पहचान लेगा कि यह डबल है।

बेशक, 1.0 संख्या एक float भी हो सकती है, लेकिन इस तरह के शाब्दिक प्रकार पूर्वनिर्धारित हैं। इसलिए, लिस्टिंग 2 में, executeAction(double var) विधि executeAction(double var) ।

जब हम Double आवरण का उपयोग करते हैं, तो दो विकल्प होते हैं: या तो संख्या को एक आदिम प्रकार में अनपैक किया जा सकता है, या इसे Object में विस्तारित किया जा सकता है। (याद रखें कि जावा में हर वर्ग Object क्लास का विस्तार करता है।) इस मामले में, जेवीएम Double टाइप ऑफ Object में एक्सटेंशन का चयन करता है, क्योंकि इसमें अनपैकिंग की तुलना में कम प्रयास की आवश्यकता होती है।

पिछले एक को हम पास करते हैं 1L और चूंकि हमने टाइप निर्दिष्ट किया है, यह long ।

सामान्य अधिभार त्रुटियां

अब तक, आप शायद समझ गए थे कि चीजें ओवरलोडिंग के साथ भ्रमित हो सकती हैं, तो चलिए कुछ समस्याओं को देखते हैं जिनसे आपका सामना होने की संभावना है।

रैपर के साथ ऑटोबॉक्सिंग

जावा एक दृढ़ता से टाइप की गई प्रोग्रामिंग भाषा है और जब हम रैपर के साथ ऑटो-रैपिंग का उपयोग करते हैं, तो कुछ चीजें होती हैं, जिन पर हमें विचार करने की आवश्यकता होती है। सबसे पहले, निम्नलिखित कोड संकलित नहीं करता है:

 int primitiveIntNumber = 7; Double wrapperNumber = primitiveIntNumber; 

ऑटोपैकिंग केवल double प्रकार के साथ काम करेगा क्योंकि जब आप कोड संकलित करते हैं, तो यह इसके बराबर होगा:

 Double number = Double.valueOf(primitiveIntNumber); 

यह कोड संकलित करेगा। पहले int को double विस्तारित किया जाएगा और फिर Double में पैक किया जाएगा। लेकिन ऑटो-पैकेजिंग के दौरान कोई प्रकार का विस्तार नहीं है और Double.valueof कंस्ट्रक्टर एक double उम्मीद करता है, एक int नहीं। इस मामले में, ऑटो-पैकेजिंग काम करेगा यदि हम एक स्पष्ट प्रकार का रूपांतरण करते हैं, उदाहरण के लिए:

 Double wrapperNumber = (double) primitiveIntNumber; 

याद रखें कि Integer Long और Float नहीं हो सकता है और Double नहीं हो सकता है। कोई विरासत नहीं है। इनमें से प्रत्येक प्रकार ( Integer , Long , Float , and Double ) Number और Object ।

यदि संदेह है, तो बस याद रखें कि आवरण संख्या को Number या Object विस्तारित किया जा सकता है। (और भी बहुत कुछ है जो रैपरों के बारे में कहा जा सकता है, लेकिन इसे किसी अन्य लेख के लिए छोड़ दें।)

कोड शाब्दिक

जब हम शाब्दिक संख्या के प्रकार को निर्दिष्ट नहीं करते हैं, तो JVM हमारे लिए प्रकार की गणना करेगा। यदि हम सीधे कोड में नंबर 1 उपयोग करते हैं, तो JVM इसे एक int रूप में बनाएगा। यदि हम 1 सीधे एक विधि से पारित करने का प्रयास करते हैं जो short स्वीकार करता है, तो यह संकलन नहीं करेगा।

उदाहरण के लिए:

 class Calculator { public static void main(String... args) { //      // ,   char, short, byte,  JVM    int calculate(1); } void calculate(short number) {} } 

1.0 नंबर 1.0 करने पर वही नियम लागू होगा। हालाँकि यह एक float हो सकता है, लेकिन JVM इसे एक double विचार करेगा।

 class Calculator { public static void main(String... args) { //      // ,   float,  JVM    double calculate(1.0); } void calculate(float number) {} } 

एक और आम गलती यह धारणा है कि Double या कोई अन्य आवरण एक विधि के लिए बेहतर है जो double हो जाता है।

तथ्य यह है कि जेवीएम Double रैपर को Object में विस्तारित करने के बजाय इसे एक आदिम double प्रकार में बदलने का कम प्रयास करता है।

संक्षेप में, जब जावा कोड में सीधे इस्तेमाल किया जाता है, तो 1 int होगा और 1.0 double होगा। एक्सटेंशन निष्पादित करने का सबसे आसान तरीका है, फिर पैकेजिंग या अनपैकिंग है और अंतिम ऑपरेशन हमेशा चर लंबाई के तरीके होंगे।

एक जिज्ञासु तथ्य की तरह। क्या आप जानते हैं कि टाइप char नंबर को स्वीकार करता है?

 char anyChar = 127; // ,  ,    

आपको अधिभार के बारे में क्या याद रखना चाहिए

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

इससे कोड साफ और पढ़ने में आसान रहता है, और यह जोखिम भी कम करता है कि डुप्लिकेट तरीके सिस्टम का हिस्सा तोड़ देंगे।

क्या ध्यान रखें: जब विधि को ओवरलोड करते हैं, तो जेवीएम कम से कम प्रयास करना संभव करेगा।

यहाँ निष्पादन के लिए सबसे आसान रास्ता है:

• पहला चौड़ा हो रहा है।
• दूसरा मुक्केबाजी है
• तीसरा, चर-लंबाई तर्क (varargs)

ध्यान देने योग्य बातें: कठिन परिस्थितियां उत्पन्न होती हैं जब सीधे संख्याओं की घोषणा करते हैं: 1 int होगा और 1.0 double होगा।

यह भी याद रखें कि आप float लिए सिंटैक्स 1F या 1F का उपयोग करके इन प्रकारों को स्पष्ट रूप से घोषित कर सकते हैं और double लिए 1d 1D या 1d 1D ।

यह विधि अधिभार में जेवीएम की भूमिका का निष्कर्ष निकालता है। यह समझना महत्वपूर्ण है कि जेवीएम स्वाभाविक रूप से आलसी है, और हमेशा आलसी मार्ग का अनुसरण करेगा।

जवाब है

लिस्टिंग 2 का उत्तर विकल्प 3 है।

जावा में विधि अधिभार के बारे में अधिक जानें

• जावा 101: जावा में कक्षाएं और ऑब्जेक्ट

पूर्ण शुरुआती के लिए कक्षाओं और वस्तुओं के लिए एक परिचय, विधियों और विधि अधिभार पर छोटे वर्गों सहित।

• जावा 101: प्राथमिक जावा भाषा सुविधाएँ

इसके बारे में अधिक जानें कि यह क्यों महत्वपूर्ण है कि जावा एक दृढ़ता से टाइप की गई भाषा है और जावा आदिम प्रकारों के बारे में जानें।

• जावा विधियों में बहुत सारे पैरामीटर, भाग 4

विधि अधिभार की सीमाओं और नुकसान को जानें, साथ ही कस्टम प्रकार और पैरामीटर ऑब्जेक्ट का उपयोग करके उन्हें कैसे हल करें।