स्थिर चल आणि पद्धती

"चला एका नवीन विषयाकडे वळू. आता, मला स्टॅटिक व्हेरिएबल्स आणि पद्धतींवर चर्चा करायची आहे."

"एली, मी स्टॅटिक व्हेरिएबल्स आणि पद्धतींबद्दल आधीच शिकले आहे. पण मला अधिक तपशील जाणून घ्यायचे आहेत."

"जेव्हा आपण क्लासमध्ये व्हेरिएबल्स घोषित करतो, तेव्हा हे व्हेरिएबल्स एकदाच तयार केले जातील की नाही हे आम्ही परिभाषित करतो किंवा क्लासच्या प्रत्येक उदाहरणाची (ऑब्जेक्ट) स्वतःची प्रत असेल. डीफॉल्टनुसार, प्रत्येक ऑब्जेक्टसाठी व्हेरिएबलची नवीन प्रत तयार केली जाते. हे असे दिसते:"

class Cat                        // Class
{
    String name;                 // Variable

    Cat(String name)             // Constructor
    {
        this.name = name;        // Variable initialization
    }
}

Cat cat1 = new Cat("Oscar"); // Create one object whose name variable contains "Oscar"
Cat cat2 = new Cat("Missy"); // Create one object whose name variable contains "Missy"
System.out.println(cat1.name);
System.out.println(cat2.name);

Oscar
Missy

"समान वर्ग (मांजर) मध्ये घोषित असूनही, व्हेरिएबल्स cat1.nameआणि cat2.nameभिन्न मूल्ये आहेत कारण ते भिन्न वस्तूंचा संदर्भ देतात."
"त्याचा अर्थ होतो."
"तथापि, क्लासच्या प्रत्येक प्रसंगासाठी स्टॅटिक व्हेरिएबलची फक्त एक प्रत अस्तित्त्वात असते आणि ती क्लासचे नाव वापरून ऍक्सेस करणे आवश्यक असते."

class Cat                   // Сlass
{
    String name;            // Instance (non-static) variable
    static int catCount;    // Static variable

    Cat(String name)
    {
        this.name = name;
        Cat.catCount++;   // Increment the static variable by 1
    }
}

System.out.println(Cat.catCount);
Cat cat1 = new Cat("Oscar");

System.out.println(Cat.catCount);
Cat cat2 = new Cat("Missy");

System.out.println(cat1.name);
System.out.println(cat2.name);
System.out.println(Cat.catCount);

0
1
Oscar
Missy
2

"ठीक आहे, याचाही अर्थ आहे."

"जावा पद्धती दोन श्रेणींमध्ये विभागल्या गेल्या आहेत. एखाद्या ऑब्जेक्टवर इन्स्टन्स पद्धती कॉल केल्या जातात आणि त्या ऑब्जेक्टच्या डेटामध्ये प्रवेश असतो. स्टॅटिक पद्धतींना तो प्रवेश नसतो, कारण त्यांच्याकडे ऑब्जेक्टचा संदर्भ नसतो. तथापि, ते संदर्भ देऊ शकतात. क्लासचे स्टॅटिक व्हेरिएबल्स आणि इतर स्टॅटिक पद्धती.

स्थिर पद्धती नॉन-स्टॅटिक पद्धती किंवा नॉन-स्टॅटिक व्हेरिएबल्सला संबोधित करू शकत नाहीत!"

"ते का, एली?"

"प्रत्येक उदाहरण व्हेरिएबल ऑब्जेक्टमध्ये समाविष्ट आहे. जर तुमच्याकडे त्या ऑब्जेक्टचा संदर्भ असेल तरच त्यावर प्रवेश केला जाऊ शकतो. स्थिर पद्धतीसाठी असा कोणताही संदर्भ उपलब्ध नाही."

"उदाहरण पद्धतींचा असा संदर्भ आहे का?"

"होय, हे अप्रत्यक्षपणे इन्स्टन्स मेथड्सकडे पास केले जाते. ज्या ऑब्जेक्टवर इन्स्टन्स मेथड कॉल केला जातो त्याचा संदर्भ अप्रत्यक्षपणे इन्स्टन्स मेथडला जातो. हा संदर्भ स्टोअर करणाऱ्या व्हेरिएबलला हे म्हणतात . यामुळे मेथडला नेहमी ऑब्जेक्टच्या ऍक्सेसमध्ये प्रवेश मिळतो. डेटा किंवा त्याच ऑब्जेक्टवर दुसरी नॉन-स्टॅटिक पद्धत कॉल करा.

ऑब्जेक्ट संदर्भाऐवजी, नल हे स्टॅटिक पद्धतींना दिले जाते. म्हणूनच ते नॉन-स्टॅटिक व्हेरिएबल्स आणि पद्धतींना संबोधित करू शकत नाहीत. त्यांच्याकडे या व्हेरिएबल्स आणि पद्धतींशी संबंधित ऑब्जेक्टचा संदर्भ नाही."

"ठीक आहे, एली, मला ते समजले."

"नॉन-स्टॅटिक पद्धती अशा प्रकारे कार्य करतात:

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat, 17);
Cat.setChildren(cat, cat1, cat2, cat3);

"स्थिर पद्धती कशा कार्य करतात ते येथे आहे:

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"एखादे व्हेरिएबल किंवा पद्धत स्थिर असते जर त्याच्या समोर स्थिर कीवर्ड असेल."

"अशा पद्धती इतक्या कठोरपणे मर्यादित असल्यास त्यांची गरज का आहे?"

"बरं, अशा पद्धतींचे त्यांचे फायदे आहेत."

"प्रथम, आम्हाला स्थिर पद्धती आणि चल वापरण्यासाठी ऑब्जेक्ट संदर्भ पास करण्याची गरज नाही. "

"दुसरे, कधीकधी व्हेरिएबलची एक आणि फक्त एक प्रत असणे आवश्यक असते. उदाहरणार्थ, System.out (सिस्टम क्लासचे स्टॅटिक आउट व्हेरिएबल)."

"तिसरे, काहीवेळा तुम्ही वस्तू तयार करण्यास सक्षम होण्यापूर्वी तुम्हाला पद्धत कॉल करणे आवश्यक आहे."

"एली, तू मला याचे उदाहरण देऊ का?"

" मुख्य() पद्धत स्थिर आहे असे तुम्हाला का वाटते ? ती स्थिर आहे त्यामुळे कोणतीही वस्तू तयार होण्यापूर्वी , मेमरीमध्ये क्लास लोड केल्यानंतर प्रोग्रामर लगेच कॉल करू शकतो ."