जावा में विधि पैरामीटर

1. तर्क पारित करना

और अब मजा शुरू होता है। आप शायद पहले से ही इस तरह के तरीकों से जानते हैं System.out.println()कि हम तर्कों को तरीकों से पारित कर सकते हैं। एक बार जब हम विधि के अंदर होते हैं, तो हम उन्हें पैरामीटर के रूप में संदर्भित करते हैं। वास्तव में, पैरामीटर उन लाभों को बहुत बढ़ाते हैं जो हमें विधियों को बनाने और उपयोग करने से मिलते हैं।

हम मापदंडों के साथ एक विधि कैसे घोषित करते हैं? यह वास्तव में काफी सरल है:

public static void name(parameters)
{
  method body
}

name विधि का अनूठा नाम कहां है और method body विधि बनाने वाले आदेशों का प्रतिनिधित्व करता है। और parameters कॉमा द्वारा अलग किए गए विधि पैरामीटर के लिए प्लेसहोल्डर है। आइए इस टेम्पलेट का अधिक विस्तार से वर्णन करें:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

उदाहरण:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

यदि हम नहीं चाहते कि विधि में पैरामीटर हों, तो हम केवल कोष्ठकों को खाली छोड़ देते हैं।

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

उदाहरण के लिए, आइए एक ऐसी विधि लिखते हैं जो दी गई संख्या में टेक्स्ट की एक स्ट्रिंग प्रदर्शित करती है।

आप पहले से ही जानते हैं कि स्क्रीन पर एक स्ट्रिंग को कई बार प्रदर्शित करने के लिए कोड कैसे लिखा जाता है। लेकिन आपको कौन सी स्ट्रिंग प्रिंट करनी चाहिए? और कितनी बार? इसके लिए हमें पैरामीटर चाहिए।

ऐसा करने वाला कोड इस तरह दिखेगा:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

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

2. तर्क

मैं पैरामीटर के साथ एक विधि को कॉल करने के लिए आपका ध्यान थोड़ा और आकर्षित करना चाहता हूं।

विधि को दिए गए मान आमतौर पर तर्क कहलाते हैं जब वे विधि में पारित होते हैं।

आइए एक और उदाहरण देखें:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

जब printLines विधि को पहली बार कॉल किया गया था, तो इसके पैरामीटर को निम्नलिखित मान निर्दिष्ट किए गए थे:
String text = "Hi", int count = 10.

जब printLinesविधि को दूसरी बार कॉल किया गया, तो इसके पैरामीटर को अलग-अलग मान असाइन किए गए:
String text = "Bye", int count = 20.

पैरामीटर वेरिएबल्स से अधिक या कम नहीं हैं, जिन्हें किसी विधि को कॉल करने पर कुछ मान निर्दिष्ट किए जाते हैं। मान "Hi", "Bye", 10, और 20स्वयं तर्क कहलाते हैं।"

3. किसी विधि को कॉल करते समय परस्पर विरोधी चर नाम

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

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

अब तक, बहुत अच्छा: हमारे पास एक strचर है। textजब विधि को कॉल किया जाता है तो इसका मान पैरामीटर को असाइन किया जाता है । हमारे पास एक nचर है। countजब विधि को कॉल किया जाता है तो इसका मान पैरामीटर को सौंपा जाता है ।" अब तक, सब कुछ स्पष्ट है।

अब आइए mainविधि में अपने चर का नाम बदलें:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

दो बातों पर ध्यान दें

पहला: हमारे पास अलग-अलग तरीकों से एक ही नाम के वेरिएबल्स हैं। ये अलग-अलग चर हैं (हम जानबूझकर उन्हें अलग-अलग रंगों का उपयोग करके चित्रित करते हैं)। सब कुछ पिछले उदाहरण की तरह ही काम करता है, जहाँ विधि में वेरिएबल्स का mainनाम दिया गया था strऔर n.

दूसरा: विधि कहे जाने पर कुछ भी जादुई नहीं होता है। मापदंडों को केवल तर्क मान निर्दिष्ट किए जाते हैं। चाहे वे संख्याएँ हों, तार हों, चर हों या भाव हों।

मुख्य विधि में चर का नाम बदलने के बाद, कुछ भी नहीं बदला है। वे पहले अलग-अलग तरीकों में अलग-अलग चर थे , और इसलिए वे बने हुए हैं। text और text चर के बीच कोई जादुई संबंध नहीं है ।

4. विधियों के संदर्भ पास करना

मुझे आशा है कि आप पिछले पाठ से सब कुछ समझ गए होंगे, क्योंकि अब हम तर्कों को पारित करने के तरीकों पर फिर से विचार करेंगे, केवल हम और गहराई से गोता लगाएँगे।

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

जब आप एक सरणी चर के लिए एक और सरणी चर निर्दिष्ट करते हैं, तो क्या होता है? यह सही है। स्मृति में एक ही स्थान को संदर्भित करने के लिए दो चर प्रारंभ होते हैं:

और क्या होता है यदि इनमें से एक चर एक विधि पैरामीटर है?

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }

   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

ठीक वैसा ही होता है: पैरामीटर में चर data के रूप में स्मृति के समान क्षेत्र का संदर्भ होगा । monthsजब विधि को कॉल किया जाता है, तो एक साधारण असाइनमेंट होता है: .data = months

और चूंकि दोनों चर एक पूर्णांक को संग्रहीत करने वाली मेमोरी के समान क्षेत्र को संदर्भित करते हैं, तो printArraySum विधि न केवल सरणी से मान पढ़ सकती है, बल्कि उन्हें बदल भी सकती है!

उदाहरण के लिए, हम अपनी खुद की विधि लिख सकते हैं जो समान मान के साथ द्वि-आयामी सरणी भरती है। यह इस तरह दिख सकता है:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

5. एक ही नाम के तरीके

अब एक बार फिर विधि नामों पर लौटते हैं।

जावा मानकों को अद्वितीय नाम रखने के लिए एक ही कक्षा में सभी विधियों की आवश्यकता होती है। दूसरे शब्दों में, एक ही कक्षा में दो समान नामित विधियों की घोषणा करना असंभव है।

समानता के लिए विधियों की तुलना करते समय, न केवल नामों को ध्यान में रखा जाता है, बल्कि पैरामीटर के प्रकार भी ! ध्यान दें कि मापदंडों के नाम पर ध्यान नहीं दिया जाता है । उदाहरण:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

क्यों कुछ विधियों को समान माना जाता है , जबकि अन्य भिन्न हैं ? और किसी विधि की विशिष्टता का निर्धारण करते समय पैरामीटर नामों पर ध्यान क्यों नहीं दिया जाता है?

विशिष्टता आखिर क्यों जरूरी है? बात यह है कि जब कंपाइलर किसी प्रोग्राम को कंपाइल करता है, तो उसे पता होना चाहिए कि आप किसी दिए गए स्थान पर किस विधि को कॉल करना चाहते हैं।

उदाहरण के लिए, यदि आप लिखते हैं , तो संकलक स्मार्ट है और आसानी से निष्कर्ष निकालेगा कि आप पैरामीटर के साथ यहां विधि को कॉल करना चाहते हैं।System.out.println("Hi")println()String

लेकिन अगर आप लिखते हैं , तो कंपाइलर पैरामीटर के साथ विधि को कॉल देखेगा ।System.out.println(1.0)println()double

जब किसी विधि को कहा जाता है, तो संकलक यह सुनिश्चित करता है कि तर्क के प्रकार पैरामीटर के प्रकार से मेल खाते हैं। यह तर्कों के नाम पर कोई ध्यान नहीं देता है। जावा में, पैरामीटर नाम संकलक को यह निर्धारित करने में मदद नहीं करते हैं कि किस विधि को कॉल करना है। और इसीलिए किसी विधि की विशिष्टता का निर्धारण करते समय उन्हें ध्यान में नहीं रखा जाता है।

एक विधि का नाम और उसके मापदंडों के प्रकार को विधि हस्ताक्षर कहा जाता है । उदाहरण के लिए,sum(int, int)

प्रत्येक वर्ग में अद्वितीय नाम वाले तरीकों के बजाय अद्वितीय हस्ताक्षर वाले तरीके होने चाहिए ।