వేరియబుల్ దృశ్యమానత

1. స్థానిక వేరియబుల్స్

వేరియబుల్స్ గురించి మరింత తీవ్రంగా మాట్లాడుకుందాం. కానీ ఈసారి మేము వారి అంతర్గత నిర్మాణం గురించి చర్చించము. బదులుగా, వేరియబుల్స్ అవి ఉన్న కోడ్‌తో ఎలా సంకర్షణ చెందుతాయి అనే దానిపై మేము దృష్టి పెడతాము.

పద్ధతుల లోపల డిక్లేర్ చేయబడిన అన్ని వేరియబుల్స్ లోకల్ వేరియబుల్స్ అంటారు . స్థానిక వేరియబుల్ అది ప్రకటించబడిన కోడ్ బ్లాక్‌లో మాత్రమే ఉంది. లేదా, మరింత ఖచ్చితంగా చెప్పాలంటే, అది ప్రకటించబడిన క్షణం నుండి అది ప్రకటించబడిన కోడ్ బ్లాక్ ముగిసే వరకు ఉనికిలో ఉంటుంది.

సరళత కోసం, ఒక ఉదాహరణను పరిశీలిద్దాం:

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 రెండవ వేరియబుల్ ప్రకటించబడిన కోడ్ బ్లాక్‌లో మొదటి b వేరియబుల్ కనిపించనందున మాత్రమే మేము రెండవ లోకల్ వేరియబుల్ పేరుని ప్రకటించగలిగాము b.

2. పారామితులు

మేము ఇంతకు ముందే చెప్పినట్లుగా, ప్రతి పద్ధతికి మనం పారామితులు అని పిలిచే వేరియబుల్స్ ఉండవచ్చు. వారి దృశ్యమానత మరియు జీవితకాలం గురించి ఏమిటి?

అంతా సూటిగా ఉంటుంది. ఎగ్జిక్యూషన్ మెథడ్‌లోకి అడుగుపెట్టినప్పుడు (అంటే పద్ధతి యొక్క కోడ్ అమలు చేయడం ప్రారంభించినప్పుడు) పారామితులు సృష్టించబడతాయి. పద్ధతి ముగిసినప్పుడు అవి తొలగించబడతాయి. పద్ధతి యొక్క శరీరం అంతటా అవి కనిపిస్తాయి.

ఉదాహరణ:

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ఇది కేవలం ఒక వేరియబుల్, దీని రకం స్ట్రింగ్‌ల శ్రేణి. మరియు అన్ని పారామితుల వలె, ఇది పద్ధతి యొక్క శరీరంలో ప్రతిచోటా అందుబాటులో ఉంటుంది. మేము సాధారణంగా మా ఉదాహరణలలో దానిని విస్మరిస్తాము.

3. తరగతిలోని వేరియబుల్స్

మీరు లెవల్ 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

ఒక పద్ధతిని అమలు చేస్తున్నప్పుడు స్థానిక వేరియబుల్స్ ఉన్నాయి. తరగతి యొక్క ఇన్‌స్టాన్స్ వేరియబుల్స్ ఆ వస్తువు ఉన్నంత వరకు తరగతి యొక్క ఆబ్జెక్ట్‌లో ఉంటాయి. మీరు తదుపరి స్థాయిలో తరగతి వస్తువుల గురించి వివరాలను తెలుసుకుంటారు.

4. స్టాటిక్ వేరియబుల్స్

పద్ధతుల వలె, తరగతిలోని వేరియబుల్స్ స్టాటిక్ లేదా నాన్-స్టాటిక్ కావచ్చు. స్టాటిక్ పద్ధతులు స్టాటిక్ వేరియబుల్స్‌ను మాత్రమే యాక్సెస్ చేయగలవు.

స్థాయి 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 వేరియబుల్స్‌ని తరలించాము మరియు వాటిని స్థిరంగా ప్రకటించాము . పబ్లిక్ స్టాటిక్ వేరియబుల్స్ ప్రోగ్రామ్‌లోని ఏదైనా పద్ధతి నుండి యాక్సెస్ చేయబడతాయి (మరియు ఒక పద్ధతి నుండి మాత్రమే కాదు).