हा कीवर्ड जावा

CodeGym वर, पहिल्या धड्यांपासून विद्यार्थ्यांना Java या कीवर्डची अक्षरशः ओळख करून दिली जाते. कालांतराने, त्याचा अर्थ स्पष्ट होतो. परंतु मागे वळून पाहताना, बरेच लोक कदाचित स्वतःला कबूल करतात की त्यांना या कीवर्डचा झेन बर्याच काळापासून समजू शकला नाही. हा लेख या कीवर्डच्या रहस्यांवर पडदा टाकेल ज्यांना अद्याप असे करणे शक्य झाले नाही अशा प्रत्येकासाठी... मला तुम्हाला शिल्ड्टचा जावा संदर्भ मिळाला आहे , नंतर पृष्ठ 171 वर तुम्ही पाहू शकता की हा कीवर्ड ऑब्जेक्टचा संदर्भ देण्यासाठी पद्धत आवश्यक आहे ज्याने ते म्हटले आहे. आम्ही त्यासह धडा संपवू शकतो. परंतु आम्हाला तपशील आवश्यक आहेत. नियमानुसार, आपल्याला हे दोन प्रकरणांमध्ये वापरण्याची आवश्यकता आहे:

1. जेव्हा इन्स्टन्स व्हेरिएबल आणि मेथड/कन्स्ट्रक्टर व्हेरिएबलचे नाव समान असते;
2. जेव्हा तुम्हाला दुसर्‍या प्रकारच्या कन्स्ट्रक्टरकडून विशिष्ट प्रकारचे कन्स्ट्रक्टर (उदाहरणार्थ, डीफॉल्ट कन्स्ट्रक्टर किंवा पॅरामीटराइज्ड कन्स्ट्रक्टर) कॉल करण्याची आवश्यकता असते. याला स्पष्ट कन्स्ट्रक्टर कॉल देखील म्हणतात.

आणि त्याबद्दल आहे - फक्त दोन प्रकरणे आहेत जिथे हा भयंकर कीवर्ड वापरला गेला आहे. आता ही दोन प्रकरणे उदाहरणांमध्ये पाहू.

उदाहरण 1: उदाहरण व्हेरिएबल आणि पद्धत व्हेरिएबलचे नाव समान आहे.

समजा आपल्याकडे नाव फील्ड परिभाषित करणारा एक मानवी वर्ग आहे: चला नाव व्हेरिएबलसाठी सेटर तयार करू (सेटर पूर्णपणे कार्यशील आहे - येथे कोणतेही कॅच नाही):

class Human {
    String name;


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

लक्षात घ्या की आम्ही स्ट्रिंग newName हे setName सेटर पद्धतीत पास करतो आम्ही एक नवीन व्हेरिएबल घोषित केले आहे आणि आम्हाला हवे ते नाव दिले आहे कारण ते फक्त कुरळे ब्रेसेस ({}) मध्ये दिसेल जे setName पद्धत संलग्न करतात . लक्षात ठेवा की सेटरमध्ये एकच ओळ आहे:

name = newName;

येथे आम्ही newName नावाचे एक नवीन व्हेरिएबल आणले आहे आणि ते ऑब्जेक्टच्या विद्यमान नाव व्हेरिएबलला दिले आहे. जेव्हा आपण शेवटी त्याच गोष्टीबद्दल बोलत असतो तेव्हा अनेक प्रोग्रामरना नवीन नावासह व्हेरिएबल सादर करणे विचित्र वाटू शकते. म्हणजेच, आम्ही मानवी वर्गातील नाव फील्डबद्दल बोलत आहोत . म्हणूनच Java च्या निर्मात्यांनी समान व्हेरिएबल नाव सोयीस्करपणे वापरण्याचा एक मार्ग विचार केला. दुस-या शब्दात, व्हेरिएबलला एकच गोष्ट दर्शवणारी दोन नावे का आहेत. दुसऱ्या शब्दांत, आम्हाला असे काहीतरी करायचे आहे:

class Human {
    String name;


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

पण इथे आम्हाला एक समस्या येते . आपल्याकडे आता एकाच नावाचे दोन व्हेरिएबल्स आहेत. एक स्ट्रिंग नाव मानवी वर्गाशी संबंधित आहे , तर दुसरे स्ट्रिंग नाव त्याच्या setName पद्धतीचे आहे . परिणामी, तुम्ही सेटरमध्ये खालील ओळ लिहिता तेव्हा तुम्ही कोणत्या व्हेरिएबलचा संदर्भ घेत आहात हे JVM ला कळणार नाही:

name = name;

Java गृहीत धरते की तुम्हाला सर्वात जवळचे नाव व्हेरिएबल आहे, म्हणजे setName पद्धतीतील एक : त्यामुळे असे दिसून आले की तुम्ही फक्त पद्धतीचे नाव व्हेरिएबल स्वतःला नियुक्त करत आहात. ज्याला अर्थातच काही अर्थ नाही. त्यामुळे, सेटनेम पद्धतीतील नाव व्हेरिएबलपासून मानवी वर्गाचे नाव व्हेरिएबल वेगळे करण्यासाठी भाषेला काही मार्ग आवश्यक होता . हा कीवर्ड सादर करून ही समस्या सोडवली गेली , जे या प्रकरणात सूचित करते की आपण मानवी वर्गाच्या उदाहरणाशी संबंधित व्हेरिएबलचा संदर्भ घेऊ इच्छित आहात , पद्धतीमधील व्हेरिएबल नाही: दुसऱ्या शब्दांत, हेआम्ही लेखाच्या सुरुवातीला नमूद केल्याप्रमाणे कॉलिंग ऑब्जेक्टचा संदर्भ देते. परिणामी, setName पद्धत तयार केलेल्या ऑब्जेक्टवर व्यक्तीचे नाव सेट करते. हा कीवर्ड न वापरता प्रोग्रामचा कोड खाली दिला आहे . कोड मानवी ऑब्जेक्ट तयार करतो आणि त्याला एक नाव देतो: आणि या कीवर्डसह कोड येथे आहे :

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);
    }
}

अशाप्रकारे, हे समान गोष्ट दर्शविण्यासाठी नवीन व्हेरिएबल्स सादर करणे टाळू देते, कोड क्लिनर बनवते आणि अतिरिक्त व्हेरिएबल्ससह कमी गोंधळात टाकते.

उदाहरण २: हे स्पष्ट कन्स्ट्रक्टर कॉलसाठी वापरणे

एका कन्स्ट्रक्टरला दुसर्‍याकडून कॉल करणे उपयुक्त ठरू शकते जेव्हा तुमच्याकडे (विचित्रपणे पुरेसे) एकाधिक कन्स्ट्रक्टर असतात आणि तुम्ही नवीन कन्स्ट्रक्टरला आधी वेगळ्या कन्स्ट्रक्टरमध्ये लिहिलेला इनिशियलायझेशन कोड डुप्लिकेट करू इच्छित नाही. गोंधळलेला? हे दिसते तितके भयानक नाही. खालील कोड पहा. मानवी वर्गासाठी यात दोन कन्स्ट्रक्टर आहेत :

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;
    }
}

येथे आम्ही प्रथम दोन पॅरामीटर्ससह एक कन्स्ट्रक्टर प्रदान केला आहे: int age आणि int weight . समजा त्यात कोडच्या दोन ओळी आहेत:

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;

हे असे आहे की आम्ही तीन-पॅरामीटर कन्स्ट्रक्टरला म्हणत आहोत:

• दोन पॅरामीटर्स असलेल्या या दुसऱ्या कन्स्ट्रक्टरला कॉल करा
• आणि नंतर दुसरे व्हेरिएबल जोडा.

एवढेच =). शेवटी, आम्ही लक्षात घेतो की Java मध्ये हा कीवर्ड फक्त पद्धती आणि कन्स्ट्रक्टरमध्ये वापरला जातो. परंतु हे सर्व नॉन-स्टॅटिक पद्धतींना अस्पष्टपणे पास केले जाते (म्हणूनच याला अनेकदा अप्रत्यक्ष पॅरामीटर म्हटले जाते) आणि पद्धत म्हटल्या जाणार्‍या ऑब्जेक्टचा संदर्भ घेण्यासाठी वापरला जाऊ शकतो. या कीवर्डला घाबरू नका, कारण हे भयानक नाही.