चर दायरे के बारे में अधिक

"प्रोफेसर बस अपनी लीक से बाहर नहीं निकल सकता। पुराने शिक्षक जो व्याख्यान देने के आदी हैं, वे हमेशा ऐसे ही होते हैं। ऐसा कुछ भी नहीं है जो वह आपको बता सकते हैं कि आप किताबों में नहीं पा सकते हैं। आप सुनना नहीं सीखते कि कैसे तैरना है । तैराकी व्याख्यान के लिए। व्याख्यान केवल तभी उपयोगी होते हैं जब आप विषय से परिचित होते हैं और लगभग अपने प्रोफेसर जितना ही जानते हैं।"

"फिर भी, उनके सबक उपयोगी हैं।"

"हां। मेरा मतलब है, हम आशा करते हैं कि वे हैं। आप जिस विषय पर अधिक दृष्टिकोण सुनते हैं, आप सच्चाई के करीब पहुंचेंगे। जब आप सिर्फ एक सुनते हैं, तो आप केवल उस पर विश्वास कर सकते हैं या उस पर अविश्वास कर सकते हैं। ठीक है, चलो व्यापार पर वापस जाओ।"

"आइए एक तस्वीर देखें जो मैंने आपको पहले दिखाई है।"

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. एक विधि में घोषित एक चर इसकी घोषणा की शुरुआत से विधि के अंत तक मौजूद है (दिखाई देता है)।

2. कोड ब्लॉक में घोषित चर कोड ब्लॉक के अंत तक मौजूद रहता है।

3. विधि के वापस आने तक एक विधि के पैरामीटर मौजूद रहते हैं।

4. किसी वस्तु में चर उस वस्तु के पूरे जीवनकाल के दौरान मौजूद होते हैं जिसमें वे होते हैं। उनकी दृश्यता भी विशेष पहुँच संशोधक द्वारा नियंत्रित होती है।

5. प्रोग्राम चलने के दौरान पूरे समय स्टेटिक (वर्ग) चर मौजूद रहते हैं। उनकी दृश्यता को एक्सेस संशोधक द्वारा भी परिभाषित किया जाता है।"

"ठीक है। मुझे यह तस्वीर याद है।"

"बहुत बढ़िया। मैं आपको कुछ प्रमुख बिंदुओं के बारे में याद दिलाता हूं।"

"विधियों के अंदर घोषित सभी चर मौजूद हैं (दिखाई दे रहे हैं) उस बिंदु से जहां वे विधि के अंत तक घोषित किए गए हैं (उदाहरण 1)।"

"यदि कोड ब्लॉक में एक चर घोषित किया गया है, तो यह कोड ब्लॉक (उदाहरण 2) के अंत तक मौजूद है।"

"यदि एक चर एक विधि पैरामीटर है, तो यह विधि के पूरे शरीर में मौजूद है (दृश्यमान है) (उदाहरण 3)।"

"यदि एक चर एक उदाहरण चर (उदाहरण 4) है, तो यह एक निश्चित वस्तु से जुड़ा हुआ है और जब तक वस्तु मौजूद है तब तक मौजूद है। यदि कोई वस्तु मौजूद नहीं है, तो चर के कोई उदाहरण नहीं हैं। आप चर का उपयोग कर सकते हैं (अर्थात चर दिखाई देता है) वर्ग के सभी तरीकों से, चाहे वे इसके पहले या बाद में घोषित किए गए हों। प्रत्येक वस्तु के लिए एक नया चर बनाया जाता है। यह अन्य वस्तुओं से स्वतंत्र है। आप स्थिर तरीकों से एक आवृत्ति चर का उपयोग नहीं कर सकते . "

"यदि एक चर को स्थिर घोषित किया जाता है, यानी कीवर्ड स्थिर के साथ चिह्नित किया जाता है, तो यह तब तक मौजूद रहता है जब तक इसकी कक्षा मौजूद होती है। JVM आमतौर पर कक्षा को अपने पहले उपयोग में स्मृति में लोड करता है। यह तब भी होता है जब स्थिर चर प्रारंभ होते हैं।"

"उपरोक्त उदाहरण कैट वर्ग की घोषणा करता है, जिसमें चार चर हैं: ए, बी, एस (गैर-स्थैतिक चर), और गिनती (एक स्थिर चर)। यदि हम इस वर्ग के कई ऑब्जेक्ट बनाते हैं (कहते हैं, तीन), प्रत्येक उनमें वर्ग के गैर-स्थैतिक चर के अपने उदाहरण होंगे। एक स्थिर चर एक वर्ग की सभी वस्तुओं द्वारा साझा किया जाता है। तकनीकी रूप से बोलना, यह इन वस्तुओं के अंदर भी नहीं है, क्योंकि यह किसी भी Cat वस्तुओं के बनने से पहले भी मौजूद था। "

"यहाँ क्या होता है अगर हम चर sस्थिर घोषित करते हैं:"

"ठीक है। मुझे लगता है कि मैं समझ गया।"

"क्या आप समान नाम वाले चर घोषित कर सकते हैं?"

"एक विधि के अंदर नहीं। एक विधि के भीतर घोषित सभी चर के अद्वितीय नाम होने चाहिए। एक विधि के तर्कों को स्थानीय चर भी माना जाता है।"

"सदस्य चर के बारे में क्या?"

"सदस्य चर भी प्रत्येक वर्ग के लिए अद्वितीय होना चाहिए।"

"लेकिन एक अपवाद है: स्थानीय चर और सदस्य चर के नाम समान हो सकते हैं। "

"यदि हम इस तरह के एक चर को बदलते हैं, तो दो समान नाम वाले चरों में से कौन सा बदल जाएगा?"

"यदि हमारे कोड में कई दृश्य (सुलभ) चर हैं - कहते हैं, एक उदाहरण चर और एक स्थानीय चर - स्थानीय चर का उपयोग किया जाएगा।"

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

"यह कोड दो गिनती चर घोषित करता है। पंक्ति 3 एक आवृत्ति चर , और पंक्ति 8 - एक स्थानीय चर घोषित करता है ।"

"यहाँ क्या होता है जब रन विधि निष्पादित होती है:"

"पंक्ति 7 में, हम उदाहरण चर का उपयोग करते हैं और इसे 15 मान देते हैं"

"पंक्ति 8 में, हम एक नया स्थानीय चर घोषित करते हैं (बनाते हैं) : count। यह उदाहरण चर को मास्क करता है। स्थानीय चर वह है जो विधि में बाद के सभी कोड (एक्सेस) देखेंगे।"

"समझ गया।"

"लोकल वेरिएबल इंस्टेंस वेरिएबल को मास्क करता है। दूसरे शब्दों में, लोकल वेरिएबल को एक्सेस किया जाना है। हालाँकि, आप इंस्टेंस वेरिएबल को भी एक्सेस कर सकते हैं। ऐसा करना थोड़ा और जटिल है।"

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

"स्थैतिक तरीकों और स्थैतिक चर के बारे में आप मुझे और क्या बता सकते हैं?"

"स्थैतिक विधियाँ और चर वर्ग की वस्तुओं से जुड़े नहीं हैं; वे कक्षा से ही जुड़े हुए हैं। यदि हम दस चर वस्तुएँ बनाते हैं (इस स्तर की शुरुआत में उदाहरण देखें), तो हमारे पास दस उदाहरण चर चर होंगे (प्रत्येक के लिए एक ऑब्जेक्ट) और केवल एक साझा (स्थिर) चर TEXT ।"

"मेरा एक सवाल है।"

"स्थैतिक और गैर-स्थैतिक तरीकों में क्या अंतर है?"

"आइए देखें कि गैर स्थैतिक विधि कैसे काम करती है:"

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

"जब आप <object> dot <method name> का उपयोग करके एक विधि को कॉल करते हैं , तो आप वास्तव में एक क्लास विधि को कॉल कर रहे हैं और उसी ऑब्जेक्ट को पहले तर्क के रूप में पास कर रहे हैं। विधि के अंदर, ऑब्जेक्ट को 'यह' कहा जाता है । में सभी ऑपरेशन विधि इस वस्तु और उसके डेटा पर की जाती है।"

"वाह! तो यह सब ऐसे ही काम करता है!"

"और इस तरह एक स्थिर विधि काम करती है।"

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

"जब आप एक स्थैतिक विधि को कॉल करते हैं, तो इसके लिए कोई ऑब्जेक्ट पास नहीं किया जाता है। दूसरे शब्दों में, 'यह' शून्य के बराबर होता है। यही कारण है कि एक स्थिर विधि गैर स्थैतिक चर और विधियों तक नहीं पहुंच सकती है (क्योंकि इसमें पास करने के लिए कोई 'यह' नहीं है इन विधियों के लिए)।

"हम्म। मुझे लगता है कि मैं समझ गया। कम से कम थोड़ा सा।"

"और यहाँ अंकल डिएगो ... और उनके कार्य आते हैं।"