परिवर्तनीय दृश्यमानता

स्थानिक चल

"अभिवादन, माझ्या प्रिय विद्यार्थ्या! व्हेरिएबल्सबद्दल थोडे अधिक गंभीर होण्याची वेळ आली आहे. परंतु यावेळी आम्ही त्यांच्या अंतर्गत संरचनेवर चर्चा करणार नाही. त्याऐवजी, व्हेरिएबल्स जिथे आहेत त्या कोडशी कसे संवाद साधतात यावर आम्ही लक्ष केंद्रित करू.

"सर्व व्हेरिएबल जे मेथड्सच्या आत घोषित केले जातात त्यांना लोकल व्हेरिएबल्स म्हणतात . स्थानिक व्हेरिएबल फक्त कोडच्या ब्लॉकमध्ये अस्तित्वात असते ज्यामध्ये ते घोषित केले जाते. किंवा अधिक अचूकपणे सांगायचे तर, ते ब्लॉकच्या शेवटी घोषित केल्यापासून ते अस्तित्वात असते. ज्या कोडमध्ये ते घोषित केले आहे.

"स्पष्टपणे, मला एक उदाहरण हवे आहे."

"काही हरकत नाही. हे घ्या:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

a
a
a
a, b
a, b
a, b
a, b, x
a, b, x
a, b
a, b
a
a

"लोकल व्हेरिएबल्स ऍक्सेस करण्याचे नियम आणखी एकदा पाहू या. येथे कोडचा एक ब्लॉक आहे. त्याची सुरुवात आणि शेवट काय आहे?"

"कुरळे ब्रेसेस?"

"बरोबर आहे. हा मेथड बॉडी, लूपचा मुख्य भाग किंवा कंडिशनल स्टेटमेंटसाठी कोडचा फक्त एक ब्लॉक असू शकतो. कोडच्या ब्लॉकमध्ये घोषित केलेले व्हेरिएबल कोडच्या त्या ब्लॉकच्या शेवटपर्यंत अस्तित्वात आहे. मला सांगा, कुठे होईल जर ते लूपच्या मुख्य भागामध्ये घोषित केले असेल तर व्हेरिएबल अस्तित्वात आहे?"

"ते फक्त लूपच्या शरीरातच अस्तित्वात असेल."

"हे बरोबर आहे. आणखी काय, लूपच्या प्रत्येक पुनरावृत्तीवर ते तयार केले जाईल आणि नष्ट केले जाईल."

"याचा अर्थ असा की तुम्ही एकाच नावाने दोन स्थानिक व्हेरिएबल्स एका पद्धतीत घोषित करू शकत नाही — प्रोग्राम संकलित होणार नाही. परंतु कोडचे ब्लॉक जेथे व्हेरिएबल्स घोषित केले आहेत ते ओव्हरलॅप होत नसल्यास तुम्ही हे करू शकता. "

"तू माझ्या आवडत्या असण्यामागे एक कारण आहे, अमिगो. हे तुमच्या मेंदूत दृढ करण्यासाठी आणखी एक उदाहरण घ्या.

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     System.out.println(b);
   }

   if (a < 20)
   {
     int b = 20;
     System.out.println(b);
   }
}

a
a
a
a, b
a, b
a
a
a
a
a, b
a, b
a

"आम्ही नावाचे दुसरे स्थानिक व्हेरिएबल घोषित करू शकलो कारण कोड ब्लॉकमध्ये bपहिला व्हेरिएबल दिसत नाही जेथे दुसरे व्हेरिएबल घोषित केले आहे.bb

पॅरामीटर्स

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

"हम्म... मी स्तब्ध आहे..."

"येथे सर्व काही अगदी सोपे आहे. जेव्हा अंमलबजावणी पद्धतीमध्ये प्रवेश करते (म्हणजे जेव्हा पद्धतीचा कोड कार्यान्वित होणे सुरू होते तेव्हा) पॅरामीटर्स तयार होतात. पद्धत संपल्यावर ते काढून टाकले जातात."

"दुसर्‍या शब्दात, ते पद्धतीच्या संपूर्ण शरीरात दृश्यमान आहेत आणि फक्त तेथे?"

"होय. उदाहरण:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

args
args, a
args, a
args, a
args, a, b
args, a, b
args, a, b
args, a, b, x
args, a, b, x
args, a, b
args, a, b
args, a
args, a

"आम्ही आधी म्हटल्याप्रमाणे, argsफक्त एक व्हेरिएबल आहे ज्याचा प्रकार म्हणजे स्ट्रिंगचा अ‍ॅरे आहे. आणि सर्व पॅरामीटर्सप्रमाणे, ते पद्धतीच्या मुख्य भागामध्ये सर्वत्र उपलब्ध आहे. असे म्हटले आहे की, आम्ही आमच्या उदाहरणांमध्ये सहसा याकडे दुर्लक्ष करतो.

वर्गातील चल

"लेव्हल 1 मधील धडे लक्षात ठेवा, जिथे आम्ही म्हटले आहे की क्लासमध्ये पद्धती आणि व्हेरिएबल्स असू शकतात. पद्धतींना कधीकधी उदाहरण पद्धती आणि व्हेरिएबल्स - उदाहरण व्हेरिएबल्स किंवा फील्ड म्हणतात.

" वर्गाचे व्हेरिएबल्स (किंवा फील्ड) काय आहेत ?

ते व्हेरिएबल्स आहेत जे एका पद्धतीत नव्हे तर वर्गात घोषित केले जातात."

"आणि ते तिथे कशासाठी आहेत?"

"सुरुवातीसाठी, ते वर्गाच्या कोणत्याही (नॉन-स्टॅटिक) पद्धतीतून ऍक्सेस केले जाऊ शकतात. ढोबळपणे सांगायचे तर, उदाहरण व्हेरिएबल्स हे व्हेरिएबल्स आहेत जे वर्गाच्या सर्व पद्धतींद्वारे सामायिक केले जातात.

उदाहरण:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     sum = sum + data;
     count++;
   }

   public void remove(int data)
   {
     sum = sum - data;
     count--;
   }
}

count
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum
count, sum

"या उदाहरणात, आमच्याकडे दोन पद्धती आहेत — add()आणि remove(). पद्धत आणि इन्स्टन्स व्हेरिएबल्स add()वाढवते , आणि पद्धत आणि व्हेरिएबल्स कमी करते. दोन्ही पद्धती सामायिक उदाहरण व्हेरिएबल्सवर कार्य करतात."sumcountremove()sumcount

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

"शाबास, अमिगो. आम्ही काही पायाभरणी केली आहे, आणि तुम्ही पुढील स्तरावर वर्गातील वस्तूंबद्दल तपशील शिकाल.

स्थिर चल

"पद्धतींप्रमाणे, वर्गातील व्हेरिएबल्स स्थिर किंवा नॉन-स्टॅटिक असू शकतात. स्टॅटिक पद्धती केवळ स्टॅटिक व्हेरिएबल्समध्ये प्रवेश करू शकतात.

"मला अद्याप स्थिर व्हेरिएबल्सची स्पष्ट समज नाही."

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

"स्टेटिक व्हेरिएबल (क्लास व्हेरिएबल) बनवण्यासाठी, तुम्हाला staticत्याच्या घोषणेमध्ये कीवर्ड लिहावा लागेल.

"स्टॅटिक व्हेरिएबल्स ज्या क्लासमध्ये ते घोषित केले आहेत त्या ऑब्जेक्ट किंवा उदाहरणाशी बांधील नसतात. त्याऐवजी, ते क्लासचेच असतात. म्हणूनच क्लासचा एकही ऑब्जेक्ट तयार केला नसला तरीही ते अस्तित्वात असतात. तुम्ही याचा संदर्भ घेऊ शकता . रचना वापरून त्यांना इतर वर्गांमधून जसे की:

ClassName.variableName

उदाहरण:

public class Solution
{
   public void add(int data)
   {
     Storage.sum = Storage.sum + data;
     Storage.count++;
   }

   public void remove(int data)
   {
     Storage.sum = Storage.sum - data;
     Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum



Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum

"वरील उदाहरणात, आम्ही एक वेगळा Storageवर्ग तयार केला, त्यात countआणि व्हेरिएबल्स हलवले आणि त्यांना स्थिर घोषित केले . पब्लिक स्टॅटिक व्हेरिएबल्सला प्रोग्राममधील कोणत्याही पद्धतीतून (आणि केवळ एका पद्धतीतूनच) प्रवेश करता येतो."sum

"मला पूर्णपणे समजले नाही, परंतु हे मला सोयीचे वाटते."

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

"आशा आहे, मी हळू हळू ते शोधून काढू शकेन."

"हो, नक्कीच होईल."