जावा इस कीवर्ड

CodeGym पर, विद्यार्थियों को पहले पाठों से ही जावा के इस कीवर्ड से परिचित कराया जाता है। समय के साथ, इसका अर्थ स्पष्ट हो जाता है। लेकिन पीछे मुड़कर देखने पर, बहुत से लोग शायद खुद को स्वीकार करते हैं कि लंबे समय तक वे इस कीवर्ड के ज़ेन को नहीं समझ सके। यह लेख उन लोगों के लिए इस कीवर्ड के रहस्यों से पर्दा हटाएगा जो अभी तक ऐसा नहीं कर पाए हैं... मेरे पास शिल्ड्ट का जावा संदर्भ है , तो पेज 171 पर आप देख सकते हैं कि यह कीवर्ड उस वस्तु को संदर्भित करने के लिए एक विधि के लिए आवश्यक है जिसने इसे बुलाया। हम इसके साथ पाठ समाप्त कर सकते हैं। लेकिन हमें बारीकियों की जरूरत है। एक नियम के रूप में, आपको इसे दो मामलों में उपयोग करने की आवश्यकता है:

1. जब एक उदाहरण चर और विधि / निर्माता चर का एक ही नाम हो;
2. जब आपको किसी अन्य प्रकार के कंस्ट्रक्टर से एक विशिष्ट प्रकार के कंस्ट्रक्टर (उदाहरण के लिए, एक डिफ़ॉल्ट कंस्ट्रक्टर या पैरामीटरयुक्त कंस्ट्रक्टर) को कॉल करने की आवश्यकता होती है। इसे एक स्पष्ट कन्स्ट्रक्टर कॉल भी कहा जाता है।

और वह इसके बारे में है - केवल दो मामले हैं जहां इस भयानक कीवर्ड का उपयोग किया जाता है। अब आइए इन दो मामलों को उदाहरणों में देखें।

उदाहरण 1: एक उदाहरण चर और विधि चर का एक ही नाम है।

मान लें कि हमारे पास एक मानव वर्ग है जो नाम फ़ील्ड को परिभाषित करता है: चलो नाम चर के लिए एक सेटर बनाते हैं (सेटर पूरी तरह कार्यात्मक है - यहां कोई पकड़ नहीं है):

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

ध्यान दें कि हम स्ट्रिंग न्यूनेम को सेटनाम सेटर विधि में पास करते हैं हमने एक नया चर घोषित किया है और हम इसे जो चाहें नाम दे सकते हैं क्योंकि यह केवल कर्ली ब्रेसिज़ ({}) के भीतर दिखाई देगा जो सेटनाम विधि को संलग्न करता है। ध्यान दें कि सेटर की एक पंक्ति है:

name = newName;

यहां हमने newName नाम से एक नया वेरिएबल पेश किया है और इसे ऑब्जेक्ट के मौजूदा नेम वेरिएबल को असाइन किया है। कई प्रोग्रामर को एक चर को एक नए नाम के साथ पेश करना अजीब लग सकता है जब अंततः हम एक ही चीज़ के बारे में बात कर रहे हों। अर्थात्, हम मानव वर्ग में नाम क्षेत्र के बारे में बात कर रहे हैं। यही कारण है कि जावा के रचनाकारों ने समान चर नाम का आसानी से उपयोग करने का एक तरीका सोचा। दूसरे शब्दों में, एक ही चीज़ को दर्शाने वाले चर के लिए दो नाम क्यों हैं। दूसरे शब्दों में, हम ऐसा कुछ करना चाहते हैं:

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

लेकिन यहां हमें एक समस्या का सामना करना पड़ता है । अब हमारे पास एक ही नाम के दो चर हैं। एक स्ट्रिंग नाम मानव वर्ग का है , जबकि दूसरा स्ट्रिंग नाम इसके सेटनाम विधि का है। नतीजतन, जब आप सेटर में निम्न पंक्ति लिखते हैं तो JVM को पता नहीं चलेगा कि आप किस चर का जिक्र कर रहे हैं:

name = name;

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

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        human1.print();
    }
}
class Human {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    void print() {
        System.out.println(name);
    }
}

इस प्रकार, यह हमें एक ही चीज़ को निरूपित करने के लिए नए चर पेश करने से रोकता है, जिससे कोड क्लीनर और अतिरिक्त चर के साथ कम अव्यवस्थित हो जाता है।

उदाहरण 2: एक स्पष्ट कन्स्ट्रक्टर कॉल के लिए इसका उपयोग करना

एक कंस्ट्रक्टर को दूसरे से कॉल करना तब उपयोगी हो सकता है जब आपके पास (विचित्र रूप से पर्याप्त) कई कंस्ट्रक्टर हों और आप नए कंस्ट्रक्टर को पहले से अलग कंस्ट्रक्टर में लिखे गए इनिशियलाइज़ेशन कोड को डुप्लिकेट नहीं करना चाहते। अस्पष्ट? यह इतना डरावना नहीं है जितना लगता है। नीचे दिए गए कोड को देखें। इसमें मानव वर्ग के लिए दो रचनाकार हैं:

class Human {
    int age;
    int weight;
    int height;

    Human(int age, int weight) {
        this.age = age;
        this.weight = weight;
    }
    Human(int age, int weight, int height) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

यहां हमने पहले दो मापदंडों के साथ एक कंस्ट्रक्टर प्रदान किया है: इंट एज और इंट वेट । मान लीजिए कि इसमें कोड की दो पंक्तियाँ हैं:

this.age = age;
this.weight = weight;

बाद में हम तीन मापदंडों के साथ एक और कंस्ट्रक्टर जोड़ने का फैसला करते हैं, मौजूदा उम्र और वजन के मापदंडों में ऊंचाई जोड़ते हैं। आप इस तरह नया कन्स्ट्रक्टर लिख सकते हैं:

this.age = age;
this.weight = weight;
this.height = height;

लेकिन इस कंस्ट्रक्टर में मौजूदा कोड को दोहराने के बजाय, आप कंस्ट्रक्टर को दो मापदंडों के साथ स्पष्ट रूप से कॉल करने के लिए इस कीवर्ड का उपयोग कर सकते हैं:

this(age, weight);
// and then initialize the missing variable:
this.height = height;

यह ऐसा है जैसे हम तीन-पैरामीटर कंस्ट्रक्टर से कह रहे हैं:

• इस दूसरे कंस्ट्रक्टर को कॉल करें जिसमें दो पैरामीटर हैं
• और फिर एक और चर जोड़ें।

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