java - एक विधि के लिए जावा परिवर्तनीय संख्या या तर्क




arguments parameter-passing variadic-functions (6)

एक विधि घोषित करना संभव है जो चरम संख्याओं की अनुमति देगा?

परिभाषा में इस्तेमाल प्रतीकवाद क्या है जो इंगित करता है कि विधि को पैरामीटर की एक चर संख्या की अनुमति देनी चाहिए?

उत्तर: varargs


Answers

हाँ जावा विधि पैरामीटर में vargs की अनुमति देता है।

class  Varargs{public int add(int... numbers){ int result = 1; for(int number: numbers){result= result+numbers;  }  return result; }}

हाँ, यह मुमकिन है:

public void myMethod(int...numbers) { ... }

यदि आप विभिन्न प्रकार के तर्कों का उपयोग कर सकते हैं, तो इसका उपयोग करें:

public void foo(Object... x) {
    String first    =  x.length > 0 ? (String)x[0]  : "Hello";
    int duration    =  x.length > 1 ? Integer.parseInt((String) x[1])     : 888;
}   
foo("Hii", ); 
foo("Hii", 146); 

सुरक्षा के लिए, इस तरह का उपयोग करें:
if (!(x[0] instanceof String)) { throw new IllegalArgumentException("..."); }

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


यह सही है। आप varargs पर ओरेकल गाइड में इसके बारे में अधिक जानकारी प्राप्त कर सकते हैं।

यहां एक उदाहरण दिया गया है:

void foo(String... args) {
    for (String arg : args) {
        System.out.println(arg);
    }
}

जिसे कहा जा सकता है

foo("foo"); // Single arg.
foo("foo", "bar"); // Multiple args.
foo("foo", "bar", "lol"); // Don't matter how many!
foo(new String[] { "foo", "bar" }); // Arrays are also accepted.
foo(); // And even no args.

Variable number of arguments

एक विधि में तर्कों की एक चर संख्या को पास करना संभव है। हालांकि, कुछ प्रतिबंध हैं:

  • पैरामीटर की चर संख्या सभी एक ही प्रकार की होनी चाहिए
  • उन्हें विधि के भीतर एक सरणी के रूप में माना जाता है
  • वे विधि का अंतिम पैरामीटर होना चाहिए

इन प्रतिबंधों को समझने के लिए, निम्न कोड स्निपेट में विधि पर विचार करें, पूर्णांक की सूची में सबसे बड़ा पूर्णांक वापस करने के लिए उपयोग किया जाता है:

private static int largest(int... numbers) {
     int currentLargest = numbers[0];
     for (int number : numbers) {
        if (number > currentLargest) {
            currentLargest = number;
        }
     }
     return currentLargest;
}

स्रोत ओरेकल प्रमाणित एसोसिएट जावा एसई 7 प्रोग्रामर अध्ययन गाइड 2012


मैंने अभी देखा है कि आपने मेरे लेख का संदर्भ दिया है।

जावा स्पेक का कहना है कि जावा में सबकुछ पास-बाय-वैल्यू है। जावा में "पास-बाय-रेफरेंस" जैसी कोई चीज़ नहीं है।

इसे समझने की कुंजी यह है कि कुछ ऐसा है

Dog myDog;

एक कुत्ता नहीं है; यह वास्तव में एक कुत्ते के लिए एक सूचक है।

इसका मतलब क्या है, जब आपके पास है

Dog myDog = new Dog("Rover");
foo(myDog);

आप अनिवार्य रूप से बनाई गई Dog ऑब्जेक्ट का पता foo विधि पर पास कर रहे हैं।

(मैं अनिवार्य रूप से कहता हूं क्योंकि जावा पॉइंटर्स प्रत्यक्ष पते नहीं हैं, लेकिन इस तरह उनके बारे में सोचना सबसे आसान है)

मान लीजिए कि Dog ऑब्जेक्ट मेमोरी एड्रेस 42 पर रहता है। इसका मतलब है कि हम विधि को 42 पास करते हैं।

अगर विधि को परिभाषित किया गया था

public void foo(Dog someDog) {
    someDog.setName("Max");     // AAA
    someDog = new Dog("Fifi");  // BBB
    someDog.setName("Rowlf");   // CCC
}

चलो देखते हैं कि क्या हो रहा है।

  • पैरामीटर कुछ someDog मूल्य 42 पर सेट है
  • लाइन "एएए" पर
    • कुछ Dog को Dog लिए इंगित किया जाता है (पता 42 पर Dog वस्तु)
    • वह Dog (पता 42 पर एक) को अपना नाम मैक्स में बदलने के लिए कहा जाता है
  • लाइन पर "बीबीबी"
    • एक नया Dog बनाया गया है। मान लीजिए कि वह 74 पर है
    • हम 74 को पैरामीटर कुछ someDog असाइन करते हैं
  • लाइन "सीसीसी" पर
    • कुछ Dog को Dog लिए इंगित किया जाता है (पता 74 पर Dog वस्तु)
    • वह Dog (पता 74 पर वाला एक) को अपना नाम रोवल में बदलने के लिए कहा जाता है
  • फिर, हम वापस आते हैं

अब चलिए सोचें कि विधि के बाहर क्या होता है:

क्या myDog बदल गया?

कुंजी है

ध्यान में रखते हुए कि myDog Dog एक सूचक है , न कि एक वास्तविक Dog , जवाब नहीं है। myDog अभी भी मूल्य 42 है; यह अभी भी मूल Dog को इंगित कर रहा है (लेकिन ध्यान दें कि "एएए" रेखा के कारण, इसका नाम अब "मैक्स" है - अभी भी वही कुत्ता; myDog का मान नहीं बदला है।)

पते का पालन करना और इसके अंत में क्या बदलना पूरी तरह से मान्य है; हालांकि, परिवर्तनीय नहीं बदलता है।

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

सी ++ में, एडा, पास्कल और अन्य भाषाएं जो पास-बाय-रेफरेंस का समर्थन करती हैं, आप वास्तव में पारित चर को बदल सकते हैं।

यदि जावा पास-बाय-रेफरेंस myDog था, तो हमने ऊपर परिभाषित foo विधि बदल दी होगी जहां myDog इंगित कर रहा था जब उसने बीबीबी पर कुछ someDog असाइन किया था।

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





java arguments parameter-passing variadic-functions